/* $OpenBSD: pk_output.c,v 1.7 2003/12/10 07:22:43 itojun Exp $ */ /* $NetBSD: pk_output.c,v 1.7 1996/02/13 22:05:30 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_output.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/socketvar.h> #include <sys/protosw.h> #include <sys/errno.h> #include <net/if.h> #include <netccitt/x25.h> #include <netccitt/pk.h> #include <netccitt/pk_var.h> #include <netccitt/pk_extern.h> struct mbuf_cache pk_output_cache = {0}, pk_input_cache; void pk_output(lcp) struct pklcd *lcp; { struct x25_packet *xp; struct mbuf *m; struct pkcb *pkp = lcp->lcd_pkp; if (lcp == 0 || pkp == 0) { printf("pk_output: zero arg\n"); return; } while ((m = nextpk(lcp)) != NULL) { xp = mtod(m, struct x25_packet *); switch (pk_decode(xp) + lcp->lcd_state) { /* * All the work is already done - just set the state * and pass to peer. */ case PK_CALL + READY: lcp->lcd_state = SENT_CALL; lcp->lcd_timer = pk_t21; break; /* * Just set the state to allow packet to flow and send the * confirmation. */ case PK_CALL_ACCEPTED + RECEIVED_CALL: lcp->lcd_state = DATA_TRANSFER; break; /* * Just set the state. Keep the LCD around till the * clear confirmation is returned. */ case PK_CLEAR + RECEIVED_CALL: case PK_CLEAR + SENT_CALL: case PK_CLEAR + DATA_TRANSFER: lcp->lcd_state = SENT_CLEAR; lcp->lcd_retry = 0; /* fall through */ case PK_CLEAR + SENT_CLEAR: lcp->lcd_timer = pk_t23; lcp->lcd_retry++; break; case PK_CLEAR_CONF + RECEIVED_CLEAR: case PK_CLEAR_CONF + SENT_CLEAR: case PK_CLEAR_CONF + READY: lcp->lcd_state = READY; break; case PK_DATA + DATA_TRANSFER: SPS(xp, lcp->lcd_ssn); lcp->lcd_input_window = (lcp->lcd_rsn + 1) % MODULUS; SPR(xp, lcp->lcd_input_window); lcp->lcd_last_transmitted_pr = lcp->lcd_input_window; lcp->lcd_ssn = (lcp->lcd_ssn + 1) % MODULUS; if (lcp->lcd_ssn == ((lcp->lcd_output_window + lcp->lcd_windowsize) % MODULUS)) lcp->lcd_window_condition = TRUE; break; case PK_INTERRUPT + DATA_TRANSFER: #ifdef ancient_history xp->packet_data = 0; #endif lcp->lcd_intrconf_pending = TRUE; break; case PK_INTERRUPT_CONF + DATA_TRANSFER: break; case PK_RR + DATA_TRANSFER: case PK_RNR + DATA_TRANSFER: lcp->lcd_input_window = (lcp->lcd_rsn + 1) % MODULUS; SPR(xp, lcp->lcd_input_window); lcp->lcd_last_transmitted_pr = lcp->lcd_input_window; break; case PK_RESET + DATA_TRANSFER: lcp->lcd_reset_condition = TRUE; break; case PK_RESET_CONF + DATA_TRANSFER: lcp->lcd_reset_condition = FALSE; break; /* * A restart should be only generated internally. * Therefore all logic for restart is in the * pk_restart routine. */ case PK_RESTART + READY: lcp->lcd_timer = pk_t20; break; /* * Restarts are all handled internally. Therefore * all the logic for the incoming restart packet is * handled in the pk_input routine. */ case PK_RESTART_CONF + READY: break; default: m_freem(m); return; } /* Trace the packet. */ pk_trace(pkp->pk_xcp, m, "P-Out"); /* Pass the packet on down to the link layer */ if (pk_input_cache.mbc_size || pk_input_cache.mbc_oldsize) { m->m_flags |= 0x08; mbuf_cache(&pk_input_cache, m); } (*pkp->pk_lloutput) (m, pkp->pk_llnext, pkp->pk_rt); } } /* * This procedure returns the next packet to send or null. A packet is * composed of one or more mbufs. */ struct mbuf * nextpk(lcp) struct pklcd *lcp; { struct mbuf *m, *n; struct socket *so = lcp->lcd_so; struct sockbuf *sb = (so ? &so->so_snd : &lcp->lcd_sb); if (lcp->lcd_template) { m = lcp->lcd_template; lcp->lcd_template = NULL; } else { if (lcp->lcd_rnr_condition || lcp->lcd_window_condition || lcp->lcd_reset_condition) return (NULL); if ((m = sb->sb_mb) == 0) return (NULL); sb->sb_mb = m->m_nextpkt; SB_EMPTY_FIXUP(sb); m->m_nextpkt = 0; for (n = m; n; n = n->m_next) sbfree(sb, n); } return (m); }