diff options
Diffstat (limited to 'sys/netccitt/pk_input.c')
-rw-r--r-- | sys/netccitt/pk_input.c | 1119 |
1 files changed, 1119 insertions, 0 deletions
diff --git a/sys/netccitt/pk_input.c b/sys/netccitt/pk_input.c new file mode 100644 index 000000000000..1f8f0bc71277 --- /dev/null +++ b/sys/netccitt/pk_input.c @@ -0,0 +1,1119 @@ +/* + * 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. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. 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_input.c 8.1 (Berkeley) 6/10/93 + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/mbuf.h> +#include <sys/socket.h> +#include <sys/protosw.h> +#include <sys/socketvar.h> +#include <sys/errno.h> + +#include <net/if.h> +#include <net/if_dl.h> +#include <net/if_llc.h> +#include <net/route.h> + +#include <netccitt/dll.h> +#include <netccitt/x25.h> +#include <netccitt/pk.h> +#include <netccitt/pk_var.h> +#include <netccitt/llc_var.h> + +struct pkcb_q pkcb_q = {&pkcb_q, &pkcb_q}; + +/* + * ccittintr() is the generic interrupt handler for HDLC, LLC2, and X.25. This + * allows to have kernel running X.25 but no HDLC or LLC2 or both (in case we + * employ boards that do all the stuff themselves, e.g. ADAX X.25 or TPS ISDN.) + */ +void +ccittintr () +{ + extern struct ifqueue pkintrq; + extern struct ifqueue hdintrq; + extern struct ifqueue llcintrq; + +#ifdef HDLC + if (hdintrq.ifq_len) + hdintr (); +#endif +#ifdef LLC + if (llcintrq.ifq_len) + llcintr (); +#endif + if (pkintrq.ifq_len) + pkintr (); +} + +struct pkcb * +pk_newlink (ia, llnext) +struct x25_ifaddr *ia; +caddr_t llnext; +{ + register struct x25config *xcp = &ia -> ia_xc; + register struct pkcb *pkp; + register struct pklcd *lcp; + register struct protosw *pp; + unsigned size; + + pp = pffindproto (AF_CCITT, (int) xcp -> xc_lproto, 0); + if (pp == 0 || pp -> pr_output == 0) { + pk_message (0, xcp, "link level protosw error"); + return ((struct pkcb *)0); + } + /* + * Allocate a network control block structure + */ + size = sizeof (struct pkcb); + pkp = (struct pkcb *) malloc (size, M_PCB, M_WAITOK); + if (pkp == 0) + return ((struct pkcb *)0); + bzero ((caddr_t) pkp, size); + pkp -> pk_lloutput = pp -> pr_output; + pkp -> pk_llctlinput = (caddr_t (*)()) pp -> pr_ctlinput; + pkp -> pk_xcp = xcp; + pkp -> pk_ia = ia; + pkp -> pk_state = DTE_WAITING; + pkp -> pk_llnext = llnext; + insque (pkp, &pkcb_q); + + /* + * set defaults + */ + + if (xcp -> xc_pwsize == 0) + xcp -> xc_pwsize = DEFAULT_WINDOW_SIZE; + if (xcp -> xc_psize == 0) + xcp -> xc_psize = X25_PS128; + /* + * Allocate logical channel descriptor vector + */ + + (void) pk_resize (pkp); + return (pkp); +} + + +pk_dellink (pkp) +register struct pkcb *pkp; +{ + register int i; + register struct protosw *pp; + + /* + * Essentially we have the choice to + * (a) go ahead and let the route be deleted and + * leave the pkcb associated with that route + * as it is, i.e. the connections stay open + * (b) do a pk_disconnect() on all channels associated + * with the route via the pkcb and then proceed. + * + * For the time being we stick with (b) + */ + + for (i = 1; i < pkp -> pk_maxlcn; ++i) + if (pkp -> pk_chan[i]) + pk_disconnect (pkp -> pk_chan[i]); + + /* + * Free the pkcb + */ + + /* + * First find the protoswitch to get hold of the link level + * protocol to be notified that the packet level entity is + * dissolving ... + */ + pp = pffindproto (AF_CCITT, (int) pkp -> pk_xcp -> xc_lproto, 0); + if (pp == 0 || pp -> pr_output == 0) { + pk_message (0, pkp -> pk_xcp, "link level protosw error"); + return (EPROTONOSUPPORT); + } + + pkp -> pk_refcount--; + if (!pkp -> pk_refcount) { + struct dll_ctlinfo ctlinfo; + + remque (pkp); + if (pkp -> pk_rt -> rt_llinfo == (caddr_t) pkp) + pkp -> pk_rt -> rt_llinfo = (caddr_t) NULL; + + /* + * Tell the link level that the pkcb is dissolving + */ + if (pp -> pr_ctlinput && pkp -> pk_llnext) { + ctlinfo.dlcti_pcb = pkp -> pk_llnext; + ctlinfo.dlcti_rt = pkp -> pk_rt; + (pp -> pr_ctlinput)(PRC_DISCONNECT_REQUEST, + pkp -> pk_xcp, &ctlinfo); + } + free ((caddr_t) pkp -> pk_chan, M_IFADDR); + free ((caddr_t) pkp, M_PCB); + } + + return (0); +} + + +pk_resize (pkp) +register struct pkcb *pkp; +{ + struct pklcd *dev_lcp = 0; + struct x25config *xcp = pkp -> pk_xcp; + if (pkp -> pk_chan && + (pkp -> pk_maxlcn != xcp -> xc_maxlcn)) { + pk_restart (pkp, X25_RESTART_NETWORK_CONGESTION); + dev_lcp = pkp -> pk_chan[0]; + free ((caddr_t) pkp -> pk_chan, M_IFADDR); + pkp -> pk_chan = 0; + } + if (pkp -> pk_chan == 0) { + unsigned size; + pkp -> pk_maxlcn = xcp -> xc_maxlcn; + size = (pkp -> pk_maxlcn + 1) * sizeof (struct pklcd *); + pkp -> pk_chan = + (struct pklcd **) malloc (size, M_IFADDR, M_WAITOK); + if (pkp -> pk_chan) { + bzero ((caddr_t) pkp -> pk_chan, size); + /* + * Allocate a logical channel descriptor for lcn 0 + */ + if (dev_lcp == 0 && + (dev_lcp = pk_attach ((struct socket *)0)) == 0) + return (ENOBUFS); + dev_lcp -> lcd_state = READY; + dev_lcp -> lcd_pkp = pkp; + pkp -> pk_chan[0] = dev_lcp; + } else { + if (dev_lcp) + pk_close (dev_lcp); + return (ENOBUFS); + } + } + return 0; +} + +/* + * This procedure is called by the link level whenever the link + * becomes operational, is reset, or when the link goes down. + */ +/*VARARGS*/ +caddr_t +pk_ctlinput (code, src, addr) + struct sockaddr *src; + caddr_t addr; +{ + register struct pkcb *pkp = (struct pkcb *) addr; + + switch (code) { + case PRC_LINKUP: + if (pkp -> pk_state == DTE_WAITING) + pk_restart (pkp, X25_RESTART_NETWORK_CONGESTION); + break; + + case PRC_LINKDOWN: + pk_restart (pkp, -1); /* Clear all active circuits */ + pkp -> pk_state = DTE_WAITING; + break; + + case PRC_LINKRESET: + pk_restart (pkp, X25_RESTART_NETWORK_CONGESTION); + break; + + case PRC_CONNECT_INDICATION: { + struct rtentry *llrt; + + if ((llrt = rtalloc1(src, 0)) == 0) + return 0; + else llrt -> rt_refcnt--; + + pkp = (((struct npaidbentry *) llrt -> rt_llinfo) -> np_rt) ? + (struct pkcb *)(((struct npaidbentry *) llrt -> rt_llinfo) -> np_rt -> rt_llinfo) : (struct pkcb *) 0; + if (pkp == (struct pkcb *) 0) + return 0; + pkp -> pk_llnext = addr; + + return ((caddr_t) pkp); + } + case PRC_DISCONNECT_INDICATION: + pk_restart (pkp, -1) ; /* Clear all active circuits */ + pkp -> pk_state = DTE_WAITING; + pkp -> pk_llnext = (caddr_t) 0; + } + return (0); +} +struct ifqueue pkintrq; +/* + * This routine is called if there are semi-smart devices that do HDLC + * in hardware and want to queue the packet and call level 3 directly + */ +pkintr () +{ + register struct mbuf *m; + register struct ifaddr *ifa; + register struct ifnet *ifp; + register int s; + + for (;;) { + s = splimp (); + IF_DEQUEUE (&pkintrq, m); + splx (s); + if (m == 0) + break; + if (m -> m_len < PKHEADERLN) { + printf ("pkintr: packet too short (len=%d)\n", + m -> m_len); + m_freem (m); + continue; + } + pk_input (m); + } +} +struct mbuf *pk_bad_packet; +struct mbuf_cache pk_input_cache = {0 }; +/* + * X.25 PACKET INPUT + * + * This procedure is called by a link level procedure whenever + * an information frame is received. It decodes the packet and + * demultiplexes based on the logical channel number. + * + * We change the original conventions of the UBC code here -- + * since there may be multiple pkcb's for a given interface + * of type 802.2 class 2, we retrieve which one it is from + * m_pkthdr.rcvif (which has been overwritten by lower layers); + * That field is then restored for the benefit of upper layers which + * may make use of it, such as CLNP. + * + */ + +#define RESTART_DTE_ORIGINATED(xp) (((xp) -> packet_cause == X25_RESTART_DTE_ORIGINATED) || \ + ((xp) -> packet_cause >= X25_RESTART_DTE_ORIGINATED2)) + +pk_input (m) +register struct mbuf *m; +{ + register struct x25_packet *xp; + register struct pklcd *lcp; + register struct socket *so = 0; + register struct pkcb *pkp; + int ptype, lcn, lcdstate = LISTEN; + + if (pk_input_cache.mbc_size || pk_input_cache.mbc_oldsize) + mbuf_cache (&pk_input_cache, m); + if ((m -> m_flags & M_PKTHDR) == 0) + panic ("pkintr"); + + if ((pkp = (struct pkcb *) m -> m_pkthdr.rcvif) == 0) + return; + xp = mtod (m, struct x25_packet *); + ptype = pk_decode (xp); + lcn = LCN(xp); + lcp = pkp -> pk_chan[lcn]; + + /* + * If the DTE is in Restart state, then it will ignore data, + * interrupt, call setup and clearing, flow control and reset + * packets. + */ + if (lcn < 0 || lcn > pkp -> pk_maxlcn) { + pk_message (lcn, pkp -> pk_xcp, "illegal lcn"); + m_freem (m); + return; + } + + pk_trace (pkp -> pk_xcp, m, "P-In"); + + if (pkp -> pk_state != DTE_READY && ptype != RESTART && ptype != RESTART_CONF) { + m_freem (m); + return; + } + if (lcp) { + so = lcp -> lcd_so; + lcdstate = lcp -> lcd_state; + } else { + if (ptype == CLEAR) { /* idle line probe (Datapac specific) */ + /* send response on lcd 0's output queue */ + lcp = pkp -> pk_chan[0]; + lcp -> lcd_template = pk_template (lcn, X25_CLEAR_CONFIRM); + pk_output (lcp); + m_freem (m); + return; + } + if (ptype != CALL) + ptype = INVALID_PACKET; + } + + if (lcn == 0 && ptype != RESTART && ptype != RESTART_CONF) { + pk_message (0, pkp -> pk_xcp, "illegal ptype (%d, %s) on lcn 0", + ptype, pk_name[ptype / MAXSTATES]); + if (pk_bad_packet) + m_freem (pk_bad_packet); + pk_bad_packet = m; + return; + } + + m -> m_pkthdr.rcvif = pkp -> pk_ia -> ia_ifp; + + switch (ptype + lcdstate) { + /* + * Incoming Call packet received. + */ + case CALL + LISTEN: + pk_incoming_call (pkp, m); + break; + + /* + * Call collision: Just throw this "incoming call" away since + * the DCE will ignore it anyway. + */ + case CALL + SENT_CALL: + pk_message ((int) lcn, pkp -> pk_xcp, + "incoming call collision"); + break; + + /* + * Call confirmation packet received. This usually means our + * previous connect request is now complete. + */ + case CALL_ACCEPTED + SENT_CALL: + MCHTYPE(m, MT_CONTROL); + pk_call_accepted (lcp, m); + break; + + /* + * This condition can only happen if the previous state was + * SENT_CALL. Just ignore the packet, eventually a clear + * confirmation should arrive. + */ + case CALL_ACCEPTED + SENT_CLEAR: + break; + + /* + * Clear packet received. This requires a complete tear down + * of the virtual circuit. Free buffers and control blocks. + * and send a clear confirmation. + */ + case CLEAR + READY: + case CLEAR + RECEIVED_CALL: + case CLEAR + SENT_CALL: + case CLEAR + DATA_TRANSFER: + lcp -> lcd_state = RECEIVED_CLEAR; + lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_CLEAR_CONFIRM); + pk_output (lcp); + pk_clearcause (pkp, xp); + if (lcp -> lcd_upper) { + MCHTYPE(m, MT_CONTROL); + lcp -> lcd_upper (lcp, m); + } + pk_close (lcp); + lcp = 0; + break; + + /* + * Clear collision: Treat this clear packet as a confirmation. + */ + case CLEAR + SENT_CLEAR: + pk_close (lcp); + break; + + /* + * Clear confirmation received. This usually means the virtual + * circuit is now completely removed. + */ + case CLEAR_CONF + SENT_CLEAR: + pk_close (lcp); + break; + + /* + * A clear confirmation on an unassigned logical channel - just + * ignore it. Note: All other packets on an unassigned channel + * results in a clear. + */ + case CLEAR_CONF + READY: + case CLEAR_CONF + LISTEN: + break; + + /* + * Data packet received. Pass on to next level. Move the Q and M + * bits into the data portion for the next level. + */ + case DATA + DATA_TRANSFER: + if (lcp -> lcd_reset_condition) { + ptype = DELETE_PACKET; + break; + } + + /* + * Process the P(S) flow control information in this Data packet. + * Check that the packets arrive in the correct sequence and that + * they are within the "lcd_input_window". Input window rotation is + * initiated by the receive interface. + */ + + if (PS(xp) != ((lcp -> lcd_rsn + 1) % MODULUS) || + PS(xp) == ((lcp -> lcd_input_window + lcp -> lcd_windowsize) % MODULUS)) { + m_freem (m); + pk_procerror (RESET, lcp, "p(s) flow control error", 1); + break; + } + lcp -> lcd_rsn = PS(xp); + + if (pk_ack (lcp, PR(xp)) != PACKET_OK) { + m_freem (m); + break; + } + m -> m_data += PKHEADERLN; + m -> m_len -= PKHEADERLN; + m -> m_pkthdr.len -= PKHEADERLN; + + lcp -> lcd_rxcnt++; + if (lcp -> lcd_flags & X25_MBS_HOLD) { + register struct mbuf *n = lcp -> lcd_cps; + int mbit = MBIT(xp); + octet q_and_d_bits; + + if (n) { + n -> m_pkthdr.len += m -> m_pkthdr.len; + while (n -> m_next) + n = n -> m_next; + n -> m_next = m; + m = lcp -> lcd_cps; + + if (lcp -> lcd_cpsmax && + n -> m_pkthdr.len > lcp -> lcd_cpsmax) { + pk_procerror (RESET, lcp, + "C.P.S. overflow", 128); + return; + } + q_and_d_bits = 0xc0 & *(octet *) xp; + xp = (struct x25_packet *) + (mtod (m, octet *) - PKHEADERLN); + *(octet *) xp |= q_and_d_bits; + } + if (mbit) { + lcp -> lcd_cps = m; + pk_flowcontrol (lcp, 0, 1); + return; + } + lcp -> lcd_cps = 0; + } + if (so == 0) + break; + if (lcp -> lcd_flags & X25_MQBIT) { + octet t = (X25GBITS(xp -> bits, q_bit)) ? t = 0x80 : 0; + + if (MBIT(xp)) + t |= 0x40; + m -> m_data -= 1; + m -> m_len += 1; + m -> m_pkthdr.len += 1; + *mtod (m, octet *) = t; + } + + /* + * Discard Q-BIT packets if the application + * doesn't want to be informed of M and Q bit status + */ + if (X25GBITS(xp -> bits, q_bit) + && (lcp -> lcd_flags & X25_MQBIT) == 0) { + m_freem (m); + /* + * NB. This is dangerous: sending a RR here can + * cause sequence number errors if a previous data + * packet has not yet been passed up to the application + * (RR's are normally generated via PRU_RCVD). + */ + pk_flowcontrol (lcp, 0, 1); + } else { + sbappendrecord (&so -> so_rcv, m); + sorwakeup (so); + } + break; + + /* + * Interrupt packet received. + */ + case INTERRUPT + DATA_TRANSFER: + if (lcp -> lcd_reset_condition) + break; + lcp -> lcd_intrdata = xp -> packet_data; + lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_INTERRUPT_CONFIRM); + pk_output (lcp); + m -> m_data += PKHEADERLN; + m -> m_len -= PKHEADERLN; + m -> m_pkthdr.len -= PKHEADERLN; + MCHTYPE(m, MT_OOBDATA); + if (so) { + if (so -> so_options & SO_OOBINLINE) + sbinsertoob (&so -> so_rcv, m); + else + m_freem (m); + sohasoutofband (so); + } + break; + + /* + * Interrupt confirmation packet received. + */ + case INTERRUPT_CONF + DATA_TRANSFER: + if (lcp -> lcd_reset_condition) + break; + if (lcp -> lcd_intrconf_pending == TRUE) + lcp -> lcd_intrconf_pending = FALSE; + else + pk_procerror (RESET, lcp, "unexpected packet", 43); + break; + + /* + * Receiver ready received. Rotate the output window and output + * any data packets waiting transmission. + */ + case RR + DATA_TRANSFER: + if (lcp -> lcd_reset_condition || + pk_ack (lcp, PR(xp)) != PACKET_OK) { + ptype = DELETE_PACKET; + break; + } + if (lcp -> lcd_rnr_condition == TRUE) + lcp -> lcd_rnr_condition = FALSE; + pk_output (lcp); + break; + + /* + * Receiver Not Ready received. Packets up to the P(R) can be + * be sent. Condition is cleared with a RR. + */ + case RNR + DATA_TRANSFER: + if (lcp -> lcd_reset_condition || + pk_ack (lcp, PR(xp)) != PACKET_OK) { + ptype = DELETE_PACKET; + break; + } + lcp -> lcd_rnr_condition = TRUE; + break; + + /* + * Reset packet received. Set state to FLOW_OPEN. The Input and + * Output window edges ar set to zero. Both the send and receive + * numbers are reset. A confirmation is returned. + */ + case RESET + DATA_TRANSFER: + if (lcp -> lcd_reset_condition) + /* Reset collision. Just ignore packet. */ + break; + + pk_resetcause (pkp, xp); + lcp -> lcd_window_condition = lcp -> lcd_rnr_condition = + lcp -> lcd_intrconf_pending = FALSE; + lcp -> lcd_output_window = lcp -> lcd_input_window = + lcp -> lcd_last_transmitted_pr = 0; + lcp -> lcd_ssn = 0; + lcp -> lcd_rsn = MODULUS - 1; + + lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_RESET_CONFIRM); + pk_output (lcp); + + pk_flush (lcp); + if (so == 0) + break; + wakeup ((caddr_t) & so -> so_timeo); + sorwakeup (so); + sowwakeup (so); + break; + + /* + * Reset confirmation received. + */ + case RESET_CONF + DATA_TRANSFER: + if (lcp -> lcd_reset_condition) { + lcp -> lcd_reset_condition = FALSE; + pk_output (lcp); + } + else + pk_procerror (RESET, lcp, "unexpected packet", 32); + break; + + case DATA + SENT_CLEAR: + ptype = DELETE_PACKET; + case RR + SENT_CLEAR: + case RNR + SENT_CLEAR: + case INTERRUPT + SENT_CLEAR: + case INTERRUPT_CONF + SENT_CLEAR: + case RESET + SENT_CLEAR: + case RESET_CONF + SENT_CLEAR: + /* Just ignore p if we have sent a CLEAR already. + */ + break; + + /* + * Restart sets all the permanent virtual circuits to the "Data + * Transfer" stae and all the switched virtual circuits to the + * "Ready" state. + */ + case RESTART + READY: + switch (pkp -> pk_state) { + case DTE_SENT_RESTART: + /* + * Restart collision. + * If case the restart cause is "DTE originated" we + * have a DTE-DTE situation and are trying to resolve + * who is going to play DTE/DCE [ISO 8208:4.2-4.5] + */ + if (RESTART_DTE_ORIGINATED(xp)) { + pk_restart (pkp, X25_RESTART_DTE_ORIGINATED); + pk_message (0, pkp -> pk_xcp, + "RESTART collision"); + if ((pkp -> pk_restartcolls++) > MAXRESTARTCOLLISIONS) { + pk_message (0, pkp -> pk_xcp, + "excessive RESTART collisions"); + pkp -> pk_restartcolls = 0; + } + break; + } + pkp -> pk_state = DTE_READY; + pkp -> pk_dxerole |= DTE_PLAYDTE; + pkp -> pk_dxerole &= ~DTE_PLAYDCE; + pk_message (0, pkp -> pk_xcp, + "Packet level operational"); + pk_message (0, pkp -> pk_xcp, + "Assuming DTE role"); + if (pkp -> pk_dxerole & DTE_CONNECTPENDING) + pk_callcomplete (pkp); + break; + + default: + pk_restart (pkp, -1); + pk_restartcause (pkp, xp); + pkp -> pk_chan[0] -> lcd_template = pk_template (0, + X25_RESTART_CONFIRM); + pk_output (pkp -> pk_chan[0]); + pkp -> pk_state = DTE_READY; + pkp -> pk_dxerole |= RESTART_DTE_ORIGINATED(xp) ? DTE_PLAYDCE : + DTE_PLAYDTE; + if (pkp -> pk_dxerole & DTE_PLAYDTE) { + pkp -> pk_dxerole &= ~DTE_PLAYDCE; + pk_message (0, pkp -> pk_xcp, + "Assuming DTE role"); + } else { + pkp -> pk_dxerole &= ~DTE_PLAYDTE; + pk_message (0, pkp -> pk_xcp, + "Assuming DCE role"); + } + if (pkp -> pk_dxerole & DTE_CONNECTPENDING) + pk_callcomplete (pkp); + } + break; + + /* + * Restart confirmation received. All logical channels are set + * to READY. + */ + case RESTART_CONF + READY: + switch (pkp -> pk_state) { + case DTE_SENT_RESTART: + pkp -> pk_state = DTE_READY; + pkp -> pk_dxerole |= DTE_PLAYDTE; + pkp -> pk_dxerole &= ~DTE_PLAYDCE; + pk_message (0, pkp -> pk_xcp, + "Packet level operational"); + pk_message (0, pkp -> pk_xcp, + "Assuming DTE role"); + if (pkp -> pk_dxerole & DTE_CONNECTPENDING) + pk_callcomplete (pkp); + break; + + default: + /* Restart local procedure error. */ + pk_restart (pkp, X25_RESTART_LOCAL_PROCEDURE_ERROR); + pkp -> pk_state = DTE_SENT_RESTART; + pkp -> pk_dxerole &= ~(DTE_PLAYDTE | DTE_PLAYDCE); + } + break; + + default: + if (lcp) { + pk_procerror (CLEAR, lcp, "unknown packet error", 33); + pk_message (lcn, pkp -> pk_xcp, + "\"%s\" unexpected in \"%s\" state", + pk_name[ptype/MAXSTATES], pk_state[lcdstate]); + } else + pk_message (lcn, pkp -> pk_xcp, + "packet arrived on unassigned lcn"); + break; + } + if (so == 0 && lcp && lcp -> lcd_upper && lcdstate == DATA_TRANSFER) { + if (ptype != DATA && ptype != INTERRUPT) + MCHTYPE(m, MT_CONTROL); + lcp -> lcd_upper (lcp, m); + } else if (ptype != DATA && ptype != INTERRUPT) + m_freem (m); +} + +static +prune_dnic (from, to, dnicname, xcp) +char *from, *to, *dnicname; +register struct x25config *xcp; +{ + register char *cp1 = from, *cp2 = from; + if (xcp -> xc_prepnd0 && *cp1 == '0') { + from = ++cp1; + goto copyrest; + } + if (xcp -> xc_nodnic) { + for (cp1 = dnicname; *cp2 = *cp1++;) + cp2++; + cp1 = from; + } +copyrest: + for (cp1 = dnicname; *cp2 = *cp1++;) + cp2++; +} +/* static */ +pk_simple_bsd (from, to, lower, len) +register octet *from, *to; +register len, lower; +{ + register int c; + while (--len >= 0) { + c = *from; + if (lower & 0x01) + *from++; + else + c >>= 4; + c &= 0x0f; c |= 0x30; *to++ = c; lower++; + } + *to = 0; +} + +/*static octet * */ +pk_from_bcd (a, iscalling, sa, xcp) +register struct x25_calladdr *a; +register struct sockaddr_x25 *sa; +register struct x25config *xcp; +{ + octet buf[MAXADDRLN+1]; + octet *cp; + unsigned count; + + bzero ((caddr_t) sa, sizeof (*sa)); + sa -> x25_len = sizeof (*sa); + sa -> x25_family = AF_CCITT; + if (iscalling) { + cp = a -> address_field + (X25GBITS(a -> addrlens, called_addrlen) / 2); + count = X25GBITS(a -> addrlens, calling_addrlen); + pk_simple_bsd (cp, buf, X25GBITS(a -> addrlens, called_addrlen), count); + } else { + count = X25GBITS(a -> addrlens, called_addrlen); + pk_simple_bsd (a -> address_field, buf, 0, count); + } + if (xcp -> xc_addr.x25_net && (xcp -> xc_nodnic || xcp -> xc_prepnd0)) { + octet dnicname[sizeof (long) * NBBY/3 + 2]; + + sprintf ((char *) dnicname, "%d", xcp -> xc_addr.x25_net); + prune_dnic ((char *) buf, sa -> x25_addr, dnicname, xcp); + } else + bcopy ((caddr_t) buf, (caddr_t) sa -> x25_addr, count + 1); +} + +static +save_extra (m0, fp, so) +struct mbuf *m0; +octet *fp; +struct socket *so; +{ + register struct mbuf *m; + struct cmsghdr cmsghdr; + if (m = m_copy (m, 0, (int)M_COPYALL)) { + int off = fp - mtod (m0, octet *); + int len = m -> m_pkthdr.len - off + sizeof (cmsghdr); + cmsghdr.cmsg_len = len; + cmsghdr.cmsg_level = AF_CCITT; + cmsghdr.cmsg_type = PK_FACILITIES; + m_adj (m, off); + M_PREPEND (m, sizeof (cmsghdr), M_DONTWAIT); + if (m == 0) + return; + bcopy ((caddr_t)&cmsghdr, mtod (m, caddr_t), sizeof (cmsghdr)); + MCHTYPE(m, MT_CONTROL); + sbappendrecord (&so -> so_rcv, m); + } +} + +/* + * This routine handles incoming call packets. It matches the protocol + * field on the Call User Data field (usually the first four bytes) with + * sockets awaiting connections. + */ + +pk_incoming_call (pkp, m0) +struct mbuf *m0; +struct pkcb *pkp; +{ + register struct pklcd *lcp = 0, *l; + register struct sockaddr_x25 *sa; + register struct x25_calladdr *a; + register struct socket *so = 0; + struct x25_packet *xp = mtod (m0, struct x25_packet *); + struct mbuf *m; + struct x25config *xcp = pkp -> pk_xcp; + int len = m0 -> m_pkthdr.len; + unsigned udlen; + char *errstr = "server unavailable"; + octet *u, *facp; + int lcn = LCN(xp); + + /* First, copy the data from the incoming call packet to a X25 address + descriptor. It is to be regretted that you have + to parse the facilities into a sockaddr to determine + if reverse charging is being requested */ + if ((m = m_get (M_DONTWAIT, MT_SONAME)) == 0) + return; + sa = mtod (m, struct sockaddr_x25 *); + a = (struct x25_calladdr *) &xp -> packet_data; + facp = u = (octet *) (a -> address_field + + ((X25GBITS(a -> addrlens, called_addrlen) + X25GBITS(a -> addrlens, calling_addrlen) + 1) / 2)); + u += *u + 1; + udlen = min (16, ((octet *) xp) + len - u); + if (udlen < 0) + udlen = 0; + pk_from_bcd (a, 1, sa, pkp -> pk_xcp); /* get calling address */ + pk_parse_facilities (facp, sa); + bcopy ((caddr_t) u, sa -> x25_udata, udlen); + sa -> x25_udlen = udlen; + + /* + * Now, loop through the listen sockets looking for a match on the + * PID. That is the first few octets of the user data field. + * This is the closest thing to a port number for X.25 packets. + * It does provide a way of multiplexing services at the user level. + */ + + for (l = pk_listenhead; l; l = l -> lcd_listen) { + struct sockaddr_x25 *sxp = l -> lcd_ceaddr; + + if (bcmp (sxp -> x25_udata, u, sxp -> x25_udlen)) + continue; + if (sxp -> x25_net && + sxp -> x25_net != xcp -> xc_addr.x25_net) + continue; + /* + * don't accept incoming calls with the D-Bit on + * unless the server agrees + */ + if (X25GBITS(xp -> bits, d_bit) && !(sxp -> x25_opts.op_flags & X25_DBIT)) { + errstr = "incoming D-Bit mismatch"; + break; + } + /* + * don't accept incoming collect calls unless + * the server sets the reverse charging option. + */ + if ((sxp -> x25_opts.op_flags & (X25_OLDSOCKADDR|X25_REVERSE_CHARGE)) == 0 && + sa -> x25_opts.op_flags & X25_REVERSE_CHARGE) { + errstr = "incoming collect call refused"; + break; + } + if (l -> lcd_so) { + if (so = sonewconn (l -> lcd_so, SS_ISCONNECTED)) + lcp = (struct pklcd *) so -> so_pcb; + } else + lcp = pk_attach ((struct socket *) 0); + if (lcp == 0) { + /* + * Insufficient space or too many unaccepted + * connections. Just throw the call away. + */ + errstr = "server malfunction"; + break; + } + lcp -> lcd_upper = l -> lcd_upper; + lcp -> lcd_upnext = l -> lcd_upnext; + lcp -> lcd_lcn = lcn; + lcp -> lcd_state = RECEIVED_CALL; + sa -> x25_opts.op_flags |= (sxp -> x25_opts.op_flags & + ~X25_REVERSE_CHARGE) | l -> lcd_flags; + pk_assoc (pkp, lcp, sa); + lcp -> lcd_faddr = *sa; + lcp -> lcd_laddr.x25_udlen = sxp -> x25_udlen; + lcp -> lcd_craddr = &lcp -> lcd_faddr; + lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_CALL_ACCEPTED); + if (lcp -> lcd_flags & X25_DBIT) { + if (X25GBITS(xp -> bits, d_bit)) + X25SBITS(mtod (lcp -> lcd_template, + struct x25_packet *) -> bits, d_bit, 1); + else + lcp -> lcd_flags &= ~X25_DBIT; + } + if (so) { + pk_output (lcp); + soisconnected (so); + if (so -> so_options & SO_OOBINLINE) + save_extra (m0, facp, so); + } else if (lcp -> lcd_upper) { + (*lcp -> lcd_upper) (lcp, m0); + } + (void) m_free (m); + return; + } + + /* + * If the call fails for whatever reason, we still need to build a + * skeleton LCD in order to be able to properly receive the CLEAR + * CONFIRMATION. + */ +#ifdef WATERLOO /* be explicit */ + if (l == 0 && bcmp (sa -> x25_udata, "ean", 3) == 0) + pk_message (lcn, pkp -> pk_xcp, "host=%s ean%c: %s", + sa -> x25_addr, sa -> x25_udata[3] & 0xff, errstr); + else if (l == 0 && bcmp (sa -> x25_udata, "\1\0\0\0", 4) == 0) + pk_message (lcn, pkp -> pk_xcp, "host=%s x29d: %s", + sa -> x25_addr, errstr); + else +#endif + pk_message (lcn, pkp -> pk_xcp, "host=%s pid=%x %x %x %x: %s", + sa -> x25_addr, sa -> x25_udata[0] & 0xff, + sa -> x25_udata[1] & 0xff, sa -> x25_udata[2] & 0xff, + sa -> x25_udata[3] & 0xff, errstr); + if ((lcp = pk_attach ((struct socket *)0)) == 0) { + (void) m_free (m); + return; + } + lcp -> lcd_lcn = lcn; + lcp -> lcd_state = RECEIVED_CALL; + pk_assoc (pkp, lcp, sa); + (void) m_free (m); + pk_clear (lcp, 0, 1); +} + +pk_call_accepted (lcp, m) +struct pklcd *lcp; +struct mbuf *m; +{ + register struct x25_calladdr *ap; + register octet *fcp; + struct x25_packet *xp = mtod (m, struct x25_packet *); + int len = m -> m_len; + + lcp -> lcd_state = DATA_TRANSFER; + if (lcp -> lcd_so) + soisconnected (lcp -> lcd_so); + if ((lcp -> lcd_flags & X25_DBIT) && (X25GBITS(xp -> bits, d_bit) == 0)) + lcp -> lcd_flags &= ~X25_DBIT; + if (len > 3) { + ap = (struct x25_calladdr *) &xp -> packet_data; + fcp = (octet *) ap -> address_field + (X25GBITS(ap -> addrlens, calling_addrlen) + + X25GBITS(ap -> addrlens, called_addrlen) + 1) / 2; + if (fcp + *fcp <= ((octet *) xp) + len) + pk_parse_facilities (fcp, lcp -> lcd_ceaddr); + } + pk_assoc (lcp -> lcd_pkp, lcp, lcp -> lcd_ceaddr); + if (lcp -> lcd_so == 0 && lcp -> lcd_upper) + lcp -> lcd_upper (lcp, m); +} + +pk_parse_facilities (fcp, sa) +register octet *fcp; +register struct sockaddr_x25 *sa; +{ + register octet *maxfcp; + + maxfcp = fcp + *fcp; + fcp++; + while (fcp < maxfcp) { + /* + * Ignore national DCE or DTE facilities + */ + if (*fcp == 0 || *fcp == 0xff) + break; + switch (*fcp) { + case FACILITIES_WINDOWSIZE: + sa -> x25_opts.op_wsize = fcp[1]; + fcp += 3; + break; + + case FACILITIES_PACKETSIZE: + sa -> x25_opts.op_psize = fcp[1]; + fcp += 3; + break; + + case FACILITIES_THROUGHPUT: + sa -> x25_opts.op_speed = fcp[1]; + fcp += 2; + break; + + case FACILITIES_REVERSE_CHARGE: + if (fcp[1] & 01) + sa -> x25_opts.op_flags |= X25_REVERSE_CHARGE; + /* + * Datapac specific: for a X.25(1976) DTE, bit 2 + * indicates a "hi priority" (eg. international) call. + */ + if (fcp[1] & 02 && sa -> x25_opts.op_psize == 0) + sa -> x25_opts.op_psize = X25_PS128; + fcp += 2; + break; + + default: +/*printf("unknown facility %x, class=%d\n", *fcp, (*fcp & 0xc0) >> 6);*/ + switch ((*fcp & 0xc0) >> 6) { + case 0: /* class A */ + fcp += 2; + break; + + case 1: + fcp += 3; + break; + + case 2: + fcp += 4; + break; + + case 3: + fcp++; + fcp += *fcp; + } + } + } +} |