/* $OpenBSD: pk_subr.c,v 1.10 2003/12/21 15:30:21 miod Exp $ */ /* $NetBSD: pk_subr.c,v 1.12 1996/03/30 21:54:33 christos Exp $ */ /* * Copyright (c) University of British Columbia, 1984 * Copyright (C) Computer Science Department IV, * University of Erlangen-Nuremberg, Germany, 1992 * Copyright (c) 1991, 1992, 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by the * Laboratory for Computation Vision and the Computer Science Department * of the the University of British Columbia and the Computer Science * Department (IV) of the University of Erlangen-Nuremberg, Germany. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)pk_subr.c 8.1 (Berkeley) 6/10/93 */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include int pk_sendspace = 1024 * 2 + 8; int pk_recvspace = 1024 * 2 + 8; struct pklcd_q pklcd_q = {&pklcd_q, &pklcd_q}; struct x25bitslice x25_bitslice[] = { /* mask, shift value */ {0xf0, 0x4}, {0xf, 0x0}, {0x80, 0x7}, {0x40, 0x6}, {0x30, 0x4}, {0xe0, 0x5}, {0x10, 0x4}, {0xe, 0x1}, {0x1, 0x0} }; static struct x25_ifaddr *pk_ifwithaddr(struct sockaddr_x25 *); static void pk_reset(struct pklcd *, int); /* * Attach X.25 protocol to socket, allocate logical channel descripter and * buffer space, and enter LISTEN state if we are to accept IN-COMMING CALL * packets. * */ struct pklcd * pk_attach(so) struct socket *so; { struct pklcd *lcp; int error = ENOBUFS; MALLOC(lcp, struct pklcd *, sizeof(*lcp), M_PCB, M_NOWAIT); if (lcp) { bzero((caddr_t) lcp, sizeof(*lcp)); insque(&lcp->lcd_q, &pklcd_q); lcp->lcd_state = READY; lcp->lcd_send = pk_output; if (so) { error = soreserve(so, pk_sendspace, pk_recvspace); lcp->lcd_so = so; if (so->so_options & SO_ACCEPTCONN) lcp->lcd_state = LISTEN; } else sbreserve(&lcp->lcd_sb, pk_sendspace); } if (so) { so->so_pcb = lcp; so->so_error = error; } return (lcp); } /* * Disconnect X.25 protocol from socket. */ void pk_disconnect(lcp) struct pklcd *lcp; { struct socket *so = lcp->lcd_so; struct pklcd *l, *p; switch (lcp->lcd_state) { case LISTEN: for (p = 0, l = pk_listenhead; l && l != lcp; p = l, l = l->lcd_listen); if (p == 0) { if (l != 0) pk_listenhead = l->lcd_listen; } else if (l != 0) p->lcd_listen = l->lcd_listen; pk_close(lcp); break; case READY: pk_acct(lcp); pk_close(lcp); break; case SENT_CLEAR: case RECEIVED_CLEAR: break; default: pk_acct(lcp); if (so) { soisdisconnecting(so); sbflush(&so->so_rcv); } pk_clear(lcp, 241, 0); /* Normal Disconnect */ } } /* * Close an X.25 Logical Channel. Discard all space held by the connection * and internal descriptors. Wake up any sleepers. */ void pk_close(lcp) struct pklcd *lcp; { struct socket *so = lcp->lcd_so; /* * If the X.25 connection is torn down due to link * level failure (e.g. LLC2 FRMR) and at the same the user * level is still filling up the socket send buffer that * send buffer is locked. An attempt to sbflush () that send * buffer will lead us into - no, not temptation but - panic! * So - we'll just check wether the send buffer is locked * and if that's the case we'll mark the lcp as zombie and * have the pk_timer () do the cleaning ... */ if (so && so->so_snd.sb_flags & SB_LOCK) lcp->lcd_state = LCN_ZOMBIE; else pk_freelcd(lcp); if (so == NULL) return; so->so_pcb = 0; soisdisconnected(so); #if 0 sofree (so); /* gak!!! you can't do that here */ #endif } /* * Create a template to be used to send X.25 packets on a logical channel. It * allocates an mbuf and fills in a skeletal packet depending on its type. * This packet is passed to pk_output where the remainer of the packet is * filled in. */ struct mbuf * pk_template(lcn, type) int lcn, type; { struct mbuf *m; struct x25_packet *xp; MGETHDR(m, M_DONTWAIT, MT_HEADER); if (m == 0) panic("pk_template"); m->m_act = 0; /* * Efficiency hack: leave a four byte gap at the beginning * of the packet level header with the hope that this will * be enough room for the link level to insert its header. */ m->m_data += max_linkhdr; m->m_pkthdr.len = m->m_len = PKHEADERLN; xp = mtod(m, struct x25_packet *); *(long *) xp = 0; /* ugly, but fast */ /* xp->q_bit = 0; */ X25SBITS(xp->bits, fmt_identifier, 1); /* xp->lc_group_number = 0; */ SET_LCN(xp, lcn); xp->packet_type = type; return (m); } /* * This routine restarts all the virtual circuits. Actually, the virtual * circuits are not "restarted" as such. Instead, any active switched circuit * is simply returned to READY state. */ void pk_restart(pkp, restart_cause) struct pkcb *pkp; int restart_cause; { struct mbuf *m; struct pklcd *lcp; int i; /* Restart all logical channels. */ if (pkp->pk_chan == 0) return; /* * Don't do this if we're doing a restart issued from * inside pk_connect () --- which is only done if and * only if the X.25 link is down, i.e. a RESTART needs * to be done to get it up. */ if (!(pkp->pk_dxerole & DTE_CONNECTPENDING)) { for (i = 1; i <= pkp->pk_maxlcn; ++i) if ((lcp = pkp->pk_chan[i]) != NULL) { if (lcp->lcd_so) { lcp->lcd_so->so_error = ENETRESET; pk_close(lcp); } else { pk_flush(lcp); lcp->lcd_state = READY; if (lcp->lcd_upper) (*lcp->lcd_upper)(NULL, lcp); } } } if (restart_cause < 0) return; pkp->pk_state = DTE_SENT_RESTART; pkp->pk_dxerole &= ~(DTE_PLAYDCE | DTE_PLAYDTE); lcp = pkp->pk_chan[0]; m = lcp->lcd_template = pk_template(lcp->lcd_lcn, X25_RESTART); m->m_pkthdr.len = m->m_len += 2; mtod(m, struct x25_packet *)->packet_data = 0; /* DTE only */ mtod(m, octet *)[4] = restart_cause; pk_output(lcp); } /* * This procedure frees up the Logical Channel Descripter. */ void pk_freelcd(lcp) struct pklcd *lcp; { if (lcp == NULL) return; if (lcp->lcd_lcn > 0) lcp->lcd_pkp->pk_chan[lcp->lcd_lcn] = NULL; pk_flush(lcp); remque(&lcp->lcd_q); free((caddr_t) lcp, M_PCB); } static struct x25_ifaddr * pk_ifwithaddr(sx) struct sockaddr_x25 *sx; { struct ifnet *ifp; struct ifaddr *ifa; struct x25_ifaddr *ia; char *addr = sx->x25_addr; for (ifp = ifnet.tqh_first; ifp != 0; ifp = ifp->if_list.tqe_next) for (ifa = ifp->if_addrlist.tqh_first; ifa != 0; ifa = ifa->ifa_list.tqe_next) if (ifa->ifa_addr->sa_family == AF_CCITT) { ia = (struct x25_ifaddr *) ifa; if (bcmp(addr, ia->ia_xc.xc_addr.x25_addr, 16) == 0) return (ia); } return ((struct x25_ifaddr *) 0); } /* * Bind a address and protocol value to a socket. The important part is the * protocol value - the first four characters of the Call User Data field. */ #define XTRACTPKP(rt) ((rt)->rt_flags & RTF_GATEWAY ? \ ((rt)->rt_llinfo ? \ (struct pkcb *) ((struct rtentry *)((rt)->rt_llinfo))->rt_llinfo : \ (struct pkcb *) NULL) : \ (struct pkcb *)((rt)->rt_llinfo)) int pk_bind(lcp, nam) struct pklcd *lcp; struct mbuf *nam; { struct pklcd *pp; struct sockaddr_x25 *sa; if (nam == NULL) return (EADDRNOTAVAIL); if (lcp->lcd_ceaddr) /* XXX */ return (EADDRINUSE); if (pk_checksockaddr(nam)) return (EINVAL); sa = mtod(nam, struct sockaddr_x25 *); /* * If the user wishes to accept calls only from a particular * net (net != 0), make sure the net is known */ if (sa->x25_addr[0]) { if (!pk_ifwithaddr(sa)) return (ENETUNREACH); } else if (sa->x25_net) { if (!ifa_ifwithnet((struct sockaddr *) sa)) return (ENETUNREACH); } /* * For ISO's sake permit default listeners, but only one such . . . */ for (pp = pk_listenhead; pp; pp = pp->lcd_listen) { struct sockaddr_x25 *sa2 = pp->lcd_ceaddr; if ((sa2->x25_udlen == sa->x25_udlen) && (sa2->x25_udlen == 0 || (bcmp(sa2->x25_udata, sa->x25_udata, min(sa2->x25_udlen, sa->x25_udlen)) == 0))) return (EADDRINUSE); } lcp->lcd_laddr = *sa; lcp->lcd_ceaddr = &lcp->lcd_laddr; return (0); } /* * Include a bound control block in the list of listeners. */ int pk_listen(lcp) struct pklcd *lcp; { struct pklcd **pp; if (lcp->lcd_ceaddr == 0) return (EDESTADDRREQ); lcp->lcd_state = LISTEN; /* * Add default listener at end, any others at start. */ if (lcp->lcd_ceaddr->x25_udlen == 0) { for (pp = &pk_listenhead; *pp;) pp = &((*pp)->lcd_listen); *pp = lcp; } else { lcp->lcd_listen = pk_listenhead; pk_listenhead = lcp; } return (0); } /* * Include a listening control block for the benefit of other protocols. */ int pk_protolisten(spi, spilen, callee) int spi; int spilen; int (*callee)(struct mbuf *, void *); { struct pklcd *lcp = pk_attach((struct socket *) 0); struct mbuf *nam; struct sockaddr_x25 *sa; int error = ENOBUFS; if (lcp) { if ((nam = m_getclr(M_DONTWAIT, MT_SONAME)) != NULL) { sa = mtod(nam, struct sockaddr_x25 *); sa->x25_family = AF_CCITT; sa->x25_len = nam->m_len = sizeof(*sa); sa->x25_udlen = spilen; sa->x25_udata[0] = spi; lcp->lcd_upper = callee; lcp->lcd_flags = X25_MBS_HOLD; if ((error = pk_bind(lcp, nam)) == 0) error = pk_listen(lcp); (void) m_free(nam); } if (error) pk_freelcd(lcp); } return error; /* Hopefully Zero ! */ } /* * Associate a logical channel descriptor with a network. * Fill in the default network specific parameters and then * set any parameters explicitly specified by the user or * by the remote DTE. */ void pk_assoc(pkp, lcp, sa) struct pkcb *pkp; struct pklcd *lcp; struct sockaddr_x25 *sa; { lcp->lcd_pkp = pkp; lcp->lcd_packetsize = pkp->pk_xcp->xc_psize; lcp->lcd_windowsize = pkp->pk_xcp->xc_pwsize; lcp->lcd_rsn = MODULUS - 1; pkp->pk_chan[lcp->lcd_lcn] = lcp; if (sa->x25_opts.op_psize) lcp->lcd_packetsize = sa->x25_opts.op_psize; else sa->x25_opts.op_psize = lcp->lcd_packetsize; if (sa->x25_opts.op_wsize) lcp->lcd_windowsize = sa->x25_opts.op_wsize; else sa->x25_opts.op_wsize = lcp->lcd_windowsize; sa->x25_net = pkp->pk_xcp->xc_addr.x25_net; lcp->lcd_flags |= sa->x25_opts.op_flags; lcp->lcd_stime = time.tv_sec; } int pk_connect(lcp, sa) struct pklcd *lcp; struct sockaddr_x25 *sa; { struct pkcb *pkp; struct rtentry *rt; struct rtentry *nrt; if (sa->x25_addr[0] == '\0') return (EDESTADDRREQ); /* * Is the destination address known? */ if (!(rt = rtalloc1((struct sockaddr *) sa, 1))) return (ENETUNREACH); if (!(pkp = XTRACTPKP(rt))) pkp = pk_newlink((struct x25_ifaddr *) (rt->rt_ifa), (caddr_t) 0); /* * Have we entered the LLC address? */ if ((nrt = npaidb_enter((struct sockaddr_dl *) rt->rt_gateway, rt_key(rt), rt, 0)) != NULL) pkp->pk_llrt = nrt; /* * Have we allocated an LLC2 link yet? */ if (pkp->pk_llnext == (caddr_t) 0 && pkp->pk_llctlinput) { struct dll_ctlinfo ctlinfo; ctlinfo.dlcti_rt = rt; ctlinfo.dlcti_pcb = (caddr_t) pkp; ctlinfo.dlcti_conf = (struct dllconfig *) (&((struct x25_ifaddr *) (rt->rt_ifa))->ia_xc); pkp->pk_llnext = (*pkp->pk_llctlinput)(PRC_CONNECT_REQUEST, NULL, &ctlinfo); } if (pkp->pk_state != DTE_READY && pkp->pk_state != DTE_WAITING) return (ENETDOWN); if ((lcp->lcd_lcn = pk_getlcn(pkp)) == 0) return (EMFILE); lcp->lcd_faddr = *sa; lcp->lcd_ceaddr = &lcp->lcd_faddr; pk_assoc(pkp, lcp, lcp->lcd_ceaddr); /* * If the link is not up yet, initiate an X.25 RESTART */ if (pkp->pk_state == DTE_WAITING) { pkp->pk_dxerole |= DTE_CONNECTPENDING; pk_ctlinput(PRC_LINKUP, NULL, pkp); if (lcp->lcd_so) soisconnecting(lcp->lcd_so); return 0; } if (lcp->lcd_so) soisconnecting(lcp->lcd_so); lcp->lcd_template = pk_template(lcp->lcd_lcn, X25_CALL); pk_callrequest(lcp, lcp->lcd_ceaddr, pkp->pk_xcp); return (*pkp->pk_ia->ia_start) (lcp); } /* * Complete all pending X.25 call requests --- this gets called after * the X.25 link has been restarted. */ #define RESHUFFLELCN(maxlcn, lcn) ((maxlcn) - (lcn) + 1) void pk_callcomplete(pkp) struct pkcb *pkp; { struct pklcd *lcp; int i; int ni; if (pkp->pk_dxerole & DTE_CONNECTPENDING) pkp->pk_dxerole &= ~DTE_CONNECTPENDING; else return; if (pkp->pk_chan == 0) return; /* * We pretended to be a DTE for allocating lcns, if * it turns out that we are in reality performing as a * DCE we need to reshuffle the lcps. * * /+---------------+-------- - * / | a (maxlcn-1) | \ * / +---------------+ \ * +--- * | b (maxlcn-2) | \ * | \ +---------------+ \ * r | \ | c (maxlcn-3) | \ * e | \+---------------+ | * s | | . | * h | | . | m * u | | . | a * f | | . | x * f | | . | l * l | /+---------------+ | c * e | / | c' ( 3 ) | | n * | / +---------------+ | * +--> * | b' ( 2 ) | / * \ +---------------+ / * \ | a' ( 1 ) | / * \+---------------+ / * | 0 | / * +---------------+-------- - * */ if (pkp->pk_dxerole & DTE_PLAYDCE) { /* Sigh, reshuffle it */ for (i = pkp->pk_maxlcn; i > 0; --i) if (pkp->pk_chan[i]) { ni = RESHUFFLELCN(pkp->pk_maxlcn, i); pkp->pk_chan[ni] = pkp->pk_chan[i]; pkp->pk_chan[i] = NULL; pkp->pk_chan[ni]->lcd_lcn = ni; } } for (i = 1; i <= pkp->pk_maxlcn; ++i) if ((lcp = pkp->pk_chan[i]) != NULL) { /* * if (lcp->lcd_so) soisconnecting (lcp->lcd_so); */ lcp->lcd_template = pk_template(lcp->lcd_lcn, X25_CALL); pk_callrequest(lcp, lcp->lcd_ceaddr, pkp->pk_xcp); (*pkp->pk_ia->ia_start) (lcp); } } struct bcdinfo { octet *cp; unsigned posn; }; /* * Build the rest of the CALL REQUEST packet. Fill in calling address, * facilities fields and the user data field. */ void pk_callrequest(lcp, sa, xcp) struct pklcd *lcp; struct sockaddr_x25 *sa; struct x25config *xcp; { struct x25_calladdr *a; struct mbuf *m = lcp->lcd_template; struct x25_packet *xp = mtod(m, struct x25_packet *); struct bcdinfo b; if (lcp->lcd_flags & X25_DBIT) X25SBITS(xp->bits, d_bit, 1); a = (struct x25_calladdr *) & xp->packet_data; b.cp = (octet *) a->address_field; b.posn = 0; X25SBITS(a->addrlens, called_addrlen, to_bcd(&b, sa, xcp)); X25SBITS(a->addrlens, calling_addrlen, to_bcd(&b, &xcp->xc_addr, xcp)); if (b.posn & 0x01) *b.cp++ &= 0xf0; m->m_pkthdr.len = m->m_len += b.cp - (octet *) a; if (lcp->lcd_facilities) { m->m_pkthdr.len += (m->m_next = lcp->lcd_facilities)->m_pkthdr.len; lcp->lcd_facilities = 0; } else pk_build_facilities(m, sa, (int) xcp->xc_type); m_copyback(m, m->m_pkthdr.len, sa->x25_udlen, sa->x25_udata); } void pk_build_facilities(m, sa, type) struct mbuf *m; struct sockaddr_x25 *sa; int type; { octet *cp; octet *fcp; int revcharge; cp = mtod(m, octet *) + m->m_len; fcp = cp + 1; revcharge = sa->x25_opts.op_flags & X25_REVERSE_CHARGE ? 1 : 0; /* * This is specific to Datapac X.25(1976) DTEs. International * calls must have the "hi priority" bit on. */ if (type == X25_1976 && sa->x25_opts.op_psize == X25_PS128) revcharge |= 02; if (revcharge) { *fcp++ = FACILITIES_REVERSE_CHARGE; *fcp++ = revcharge; } switch (type) { case X25_1980: case X25_1984: *fcp++ = FACILITIES_PACKETSIZE; *fcp++ = sa->x25_opts.op_psize; *fcp++ = sa->x25_opts.op_psize; *fcp++ = FACILITIES_WINDOWSIZE; *fcp++ = sa->x25_opts.op_wsize; *fcp++ = sa->x25_opts.op_wsize; } *cp = fcp - cp - 1; m->m_pkthdr.len = (m->m_len += *cp + 1); } int to_bcd(b, sa, xcp) struct bcdinfo *b; struct sockaddr_x25 *sa; struct x25config *xcp; { char *x = sa->x25_addr; unsigned start = b->posn; /* * The nodnic and prepnd0 stuff looks tedious, * but it does allow full X.121 addresses to be used, * which is handy for routing info (& OSI type 37 addresses). */ if (xcp->xc_addr.x25_net && (xcp->xc_nodnic || xcp->xc_prepnd0)) { char dnicname[sizeof(long) * NBBY / 3 + 2]; char *p = dnicname; sprintf(p, "%d", xcp->xc_addr.x25_net & 0x7fff); for (; *p; p++) /* *p == 0 means dnic matched */ if ((*p ^ *x++) & 0x0f) break; if (*p || xcp->xc_nodnic == 0) x = sa->x25_addr; if (*p && xcp->xc_prepnd0) { if ((b->posn)++ & 0x01) (b->cp)++; else *(b->cp) = 0; } } while (*x) if ((b->posn)++ & 0x01) *(b->cp)++ |= *x++ & 0x0F; else *(b->cp) = *x++ << 4; return ((b->posn) - start); } /* * This routine gets the first available logical channel number. The search * is - from the highest number to lowest number if playing DTE, and - from * lowest to highest number if playing DCE. */ int pk_getlcn(pkp) struct pkcb *pkp; { int i; if (pkp->pk_chan == 0) return (0); if (pkp->pk_dxerole & DTE_PLAYDCE) { for (i = 1; i <= pkp->pk_maxlcn; ++i) if (pkp->pk_chan[i] == NULL) break; } else { for (i = pkp->pk_maxlcn; i > 0; --i) if (pkp->pk_chan[i] == NULL) break; } i = (i > pkp->pk_maxlcn ? 0 : i); return (i); } /* * This procedure sends a CLEAR request packet. The lc state is set to * "SENT_CLEAR". */ void pk_clear(lcp, diagnostic, abortive) struct pklcd *lcp; int diagnostic; int abortive; { struct mbuf *m = pk_template(lcp->lcd_lcn, X25_CLEAR); m->m_len += 2; m->m_pkthdr.len += 2; mtod(m, struct x25_packet *)->packet_data = 0; mtod(m, octet *)[4] = diagnostic; if (lcp->lcd_facilities) { m->m_next = lcp->lcd_facilities; m->m_pkthdr.len += m->m_next->m_len; lcp->lcd_facilities = 0; } if (abortive) lcp->lcd_template = m; else { struct socket *so = lcp->lcd_so; struct sockbuf *sb = so ? &so->so_snd : &lcp->lcd_sb; sbappendrecord(sb, m); } pk_output(lcp); } /* * This procedure generates RNR's or RR's to inhibit or enable * inward data flow, if the current state changes (blocked ==> open or * vice versa), or if forced to generate one. One forces RNR's to ack data. */ void pk_flowcontrol(lcp, inhibit, forced) struct pklcd *lcp; int inhibit; int forced; { inhibit = (inhibit != 0); if (lcp == 0 || lcp->lcd_state != DATA_TRANSFER || (forced == 0 && lcp->lcd_rxrnr_condition == inhibit)) return; lcp->lcd_rxrnr_condition = inhibit; lcp->lcd_template = pk_template(lcp->lcd_lcn, inhibit ? X25_RNR : X25_RR); pk_output(lcp); } /* * This procedure sends a RESET request packet. It re-initializes virtual * circuit. */ static void pk_reset(lcp, diagnostic) struct pklcd *lcp; int diagnostic; { struct mbuf *m; struct socket *so = lcp->lcd_so; if (lcp->lcd_state != DATA_TRANSFER) return; if (so) so->so_error = ECONNRESET; lcp->lcd_reset_condition = TRUE; /* Reset all the control variables for the channel. */ pk_flush(lcp); lcp->lcd_window_condition = lcp->lcd_rnr_condition = lcp->lcd_intrconf_pending = FALSE; lcp->lcd_rsn = MODULUS - 1; lcp->lcd_ssn = 0; lcp->lcd_output_window = lcp->lcd_input_window = lcp->lcd_last_transmitted_pr = 0; m = lcp->lcd_template = pk_template(lcp->lcd_lcn, X25_RESET); m->m_pkthdr.len = m->m_len += 2; mtod(m, struct x25_packet *)->packet_data = 0; mtod(m, octet *)[4] = diagnostic; pk_output(lcp); } /* * This procedure frees all data queued for output or delivery on a * virtual circuit. */ void pk_flush(lcp) struct pklcd *lcp; { struct socket *so; if (lcp->lcd_template) m_freem(lcp->lcd_template); if (lcp->lcd_cps) { m_freem(lcp->lcd_cps); lcp->lcd_cps = 0; } if (lcp->lcd_facilities) { m_freem(lcp->lcd_facilities); lcp->lcd_facilities = 0; } if ((so = lcp->lcd_so) != NULL) sbflush(&so->so_snd); else sbflush(&lcp->lcd_sb); } /* * This procedure handles all local protocol procedure errors. */ void pk_procerror(error, lcp, errstr, diagnostic) int error; struct pklcd *lcp; char *errstr; int diagnostic; { pk_message(lcp->lcd_lcn, lcp->lcd_pkp->pk_xcp, errstr); switch (error) { case PK_CLEAR: if (lcp->lcd_so) { lcp->lcd_so->so_error = ECONNABORTED; soisdisconnecting(lcp->lcd_so); } pk_clear(lcp, diagnostic, 1); break; case PK_RESET: pk_reset(lcp, diagnostic); } } /* * This procedure is called during the DATA TRANSFER state to check and * process the P(R) values received in the DATA, RR OR RNR packets. */ int pk_ack(lcp, pr) struct pklcd *lcp; unsigned pr; { struct socket *so = lcp->lcd_so; if (lcp->lcd_output_window == pr) return (PACKET_OK); if (lcp->lcd_output_window < lcp->lcd_ssn) { if (pr < lcp->lcd_output_window || pr > lcp->lcd_ssn) { pk_procerror(PK_RESET, lcp, "p(r) flow control error", 2); return (ERROR_PACKET); } } else { if (pr < lcp->lcd_output_window && pr > lcp->lcd_ssn) { pk_procerror(PK_RESET, lcp, "p(r) flow control error #2", 2); return (ERROR_PACKET); } } lcp->lcd_output_window = pr; /* Rotate window. */ if (lcp->lcd_window_condition == TRUE) lcp->lcd_window_condition = FALSE; if (so && sb_notify(&(so->so_snd))) sowwakeup(so); return (PACKET_OK); } /* * This procedure decodes the X.25 level 3 packet returning a code to be used * in switchs or arrays. */ int pk_decode(xp) struct x25_packet *xp; { int type; if (X25GBITS(xp->bits, fmt_identifier) != 1) return (PK_INVALID_PACKET); #ifdef ancient_history /* * Make sure that the logical channel group number is 0. This * restriction may be removed at some later date. */ if (xp->lc_group_number != 0) return (PK_INVALID_PACKET); #endif /* * Test for data packet first. */ if (!(xp->packet_type & DATA_PACKET_DESIGNATOR)) return (PK_DATA); /* * Test if flow control packet (RR or RNR). */ if (!(xp->packet_type & RR_OR_RNR_PACKET_DESIGNATOR)) switch (xp->packet_type & 0x1f) { case X25_RR: return (PK_RR); case X25_RNR: return (PK_RNR); case X25_REJECT: return (PK_REJECT); } /* * Determine the rest of the packet types. */ switch (xp->packet_type) { case X25_CALL: type = PK_CALL; break; case X25_CALL_ACCEPTED: type = PK_CALL_ACCEPTED; break; case X25_CLEAR: type = PK_CLEAR; break; case X25_CLEAR_CONFIRM: type = PK_CLEAR_CONF; break; case X25_INTERRUPT: type = PK_INTERRUPT; break; case X25_INTERRUPT_CONFIRM: type = PK_INTERRUPT_CONF; break; case X25_RESET: type = PK_RESET; break; case X25_RESET_CONFIRM: type = PK_RESET_CONF; break; case X25_RESTART: type = PK_RESTART; break; case X25_RESTART_CONFIRM: type = PK_RESTART_CONF; break; case X25_DIAGNOSTIC: type = PK_DIAG_TYPE; break; default: type = PK_INVALID_PACKET; } return (type); } /* * A restart packet has been received. Print out the reason for the restart. */ void pk_restartcause(pkp, xp) struct pkcb *pkp; struct x25_packet *xp; { struct x25config *xcp = pkp->pk_xcp; int lcn = LCN(xp); switch (xp->packet_data) { case X25_RESTART_LOCAL_PROCEDURE_ERROR: pk_message(lcn, xcp, "restart: local procedure error"); break; case X25_RESTART_NETWORK_CONGESTION: pk_message(lcn, xcp, "restart: network congestion"); break; case X25_RESTART_NETWORK_OPERATIONAL: pk_message(lcn, xcp, "restart: network operational"); break; default: pk_message(lcn, xcp, "restart: unknown cause"); } } #define MAXRESETCAUSE 7 int Reset_cause[] = { EXRESET, EXROUT, 0, EXRRPE, 0, EXRLPE, 0, EXRNCG }; /* * A reset packet has arrived. Return the cause to the user. */ void pk_resetcause(pkp, xp) struct pkcb *pkp; struct x25_packet *xp; { struct pklcd *lcp = pkp->pk_chan[LCN(xp)]; int code = xp->packet_data; if (code > MAXRESETCAUSE) code = 7; /* EXRNCG */ pk_message(LCN(xp), lcp->lcd_pkp->pk_xcp, "reset code 0x%x, diagnostic 0x%x", xp->packet_data, 4[(u_char *) xp]); if (lcp->lcd_so) lcp->lcd_so->so_error = Reset_cause[code]; } #define MAXCLEARCAUSE 25 int Clear_cause[] = { EXCLEAR, EXCBUSY, 0, EXCINV, 0, EXCNCG, 0, 0, 0, EXCOUT, 0, EXCAB, 0, EXCNOB, 0, 0, 0, EXCRPE, 0, EXCLPE, 0, 0, 0, 0, 0, EXCRRC }; /* * A clear packet has arrived. Return the cause to the user. */ void pk_clearcause(pkp, xp) struct pkcb *pkp; struct x25_packet *xp; { struct pklcd *lcp = pkp->pk_chan[LCN(xp)]; int code = xp->packet_data; if (code > MAXCLEARCAUSE) code = 5; /* EXRNCG */ if (lcp->lcd_so) lcp->lcd_so->so_error = Clear_cause[code]; } char * format_ntn(xcp) struct x25config *xcp; { return (xcp->xc_addr.x25_addr); } /* VARARGS1 */ void pk_message(int lcn, struct x25config * xcp, char * fmt,...) { va_list ap; if (lcn) { if (!PQEMPTY) printf("X.25(%s): lcn %d: ", format_ntn(xcp), lcn); else printf("X.25: lcn %d: ", lcn); } else if (!PQEMPTY) printf("X.25(%s): ", format_ntn(xcp)); else printf("X.25: "); va_start(ap, fmt); vprintf(fmt, ap); va_end(ap); printf("\n"); } int pk_fragment(lcp, m0, qbit, mbit, wait) struct mbuf *m0; struct pklcd *lcp; int qbit, mbit, wait; { struct mbuf *m = m0; struct x25_packet *xp; struct sockbuf *sb; struct mbuf *head = 0, *next, **mp = &head; int totlen, psize = 1 << (lcp->lcd_packetsize); if (m == 0) return 0; if ((m->m_flags & M_PKTHDR) == 0) panic("pk_fragment"); totlen = m->m_pkthdr.len; m->m_act = 0; sb = lcp->lcd_so ? &lcp->lcd_so->so_snd : &lcp->lcd_sb; do { if (totlen > psize) { if ((next = m_split(m, psize, wait)) == 0) goto abort; totlen -= psize; } else next = 0; M_PREPEND(m, PKHEADERLN, wait); if (m == 0) goto abort; *mp = m; mp = &m->m_act; *mp = 0; xp = mtod(m, struct x25_packet *); 0[(char *) xp] = 0; if (qbit) X25SBITS(xp->bits, q_bit, 1); if (lcp->lcd_flags & X25_DBIT) X25SBITS(xp->bits, d_bit, 1); X25SBITS(xp->bits, fmt_identifier, 1); xp->packet_type = X25_DATA; SET_LCN(xp, lcp->lcd_lcn); if (next || (mbit && (totlen == psize || (lcp->lcd_flags & X25_DBIT)))) SMBIT(xp, 1); } while ((m = next) != NULL); for (m = head; m; m = next) { next = m->m_act; m->m_act = 0; sbappendrecord(sb, m); } return 0; abort: if (wait) panic("pk_fragment null mbuf after wait"); if (next) m_freem(next); for (m = head; m; m = next) { next = m->m_act; m_freem(m); } return ENOBUFS; }