projects / unix-history / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fixes for range locking
[unix-history] / usr / src / sys / deprecated / bbnnet / tcp_usrreq.c
#ifdef RCSIDENT
static char rcsident[] = "$Header: tcp_usrreq.c,v 1.30 85/07/31 09:43:43 walsh Exp $";
#endif RCSIDENT
#include "../h/param.h"
#include "../h/systm.h"
#include "../h/mbuf.h"
#include "../h/socket.h"
#include "../h/socketvar.h"
#include "../h/protosw.h"
#include "../h/errno.h"
#include "../h/ioctl.h"
#include "../h/time.h"
#include "../h/kernel.h"
#include "../net/if.h"
#include "../net/route.h"
#include "../bbnnet/in.h"
#include "../bbnnet/in_var.h"
#include "../bbnnet/in_pcb.h"
#include "../bbnnet/net.h"
#include "../bbnnet/fsm.h"
#include "../bbnnet/tcp.h"
#include "../bbnnet/ip.h"
#include "../bbnnet/icmp.h"
#include "../bbnnet/macros.h"
#include "../bbnnet/sws.h"
/*
* TCP protocol interface to socket abstraction.
*/
#ifdef GPROF
int tcp_acounts[TCP_NSTATES][PRU_NREQ];
#endif
extern tcp_pcbdisconnect();
extern tcp_binding_used();
struct inpcb tcp;
struct tcp_stat tcpstat;
sequence tcp_iss; /* tcp initial send seq # */
struct dfilter tcp_dfilter;
struct pr_advice tcp_advice =
{
TCP_RESERVED, /* application reserved */
TCP_USERRESERVED, /* user reserved */
TCP_MAXPORT, /* max port */
TCP_USERRESERVED+1, /* random last used */
sizeof(u_short), /* port size */
tcp_binding_used, /* confirmation routine */
} ;
dowedebug(inp, so, filter)
register struct inpcb *inp;
struct socket *so;
register struct dfilter *filter;
{
register int count;
count = 0;
if (inp->inp_faddr.s_addr == filter->foreign_host.s_addr)
count ++;
if (inp->inp_fport == filter->foreign_port)
count ++;
if (inp->inp_laddr.s_addr == filter->local_host.s_addr)
count ++;
if (inp->inp_lport == filter->local_port)
count ++;
if (count >= filter->matches)
so->so_options |= SO_DEBUG;
}
int tcp_noact = 0; /* patchable */
/*
* Allocate and initialize a new TCB
* tcp_usrreq calls tcp_attach calls us. tcp_usrreq splnet()'s
*/
struct tcpcb *tcp_newtcpcb(inp)
register struct inpcb *inp;
{
register struct tcpcb *tp;
register struct mbuf *m;
m = m_getclr(M_WAIT, MT_PCB);
if (m == NULL)
return(NULL);
tp = mtod(m, struct tcpcb *);
/* initialize non-zero tcb fields */
tp->t_rcv_next = (struct th *)tp;
tp->t_rcv_prev = (struct th *)tp;
/*
* Don't start off assuming minimum srtt/rxmitime. If we do, and
* TCP_tvRXMIN is small and we decide to communicate over a
* reliable, but slow, network then we may not find true values for
* these. We may assume an ACK was for a retransmission that
* we're measuring the srtt of, not the original packet.
*
* Instead, start high and approach from above in a deterministic
* fashion. We should get close to the right values fairly rapidly.
*
* 7/85: start from above by special casing first round trip time
* measurement. If srtt == 0, do not reset rtt, and do not use
* weighted averaging. srtt starts as time to ack(xmit [+ rxmit...])
* and then gets smoothed with new round trip times. This compromise
* for getting to long-term srtt more quickly on LANs should work
* on the Internet as well. It will only hurt Internet connections
* if packet loss is high, and even then would only slow getting
* to long term srtt.
* This method can be turned off by initializing srtt with a non-zero
* value.
*/
/* tp->t_srtt = TCP_tvMAXSRTT; */
tp->t_rxmitime = TCP_tvMAXSRTT + 1;
tp->t_rttltimeo = TCP_tvRTTL;
tp->t_xmt_val = tp->snd_end = tp->seq_fin = tp->snd_nxt =
tp->snd_hi = tp->snd_una = tp->iss = tcp_iss;
tcp_iss += ISSINCR;
/*
* Imitate Berkeley code by setting push as a default. This should
* increase compatibility at the user code level.
*/
tp->t_push = TRUE;
/*
* Berkeley 4.2 code sends a data byte beyond the window's edge to see
* if the other end is up. If other end does not respond, connection
* times out and aborts. This is dangerous since the byte may make its
* way into the input stream if the recipient is coded keeping in mind
* how expensive packets are.
*
* We'll provide for an optional method to send a well formed ack that
* will catch remote failure and generate a tcp reset. Note that we
* don't care if the other end ignores the ack; we only hope for a well
* coded tcp to respond with a reset in the right circumstances. This
* sort of handshaking/probing should really be done at the application
* level, but not all specs (eg., SMTP) provide for such a noop.
*
* Optional, since some networks charge for packets and since some might
* see this as unecessary traffic.
*
* also see tcp_ioctl()
*/
if (tp->t_noact = tcp_noact)
tp->t_noactprobe = TRUE;
/* attach the tcpcb to the in_pcb */
inp->inp_ppcb = (caddr_t)tp;
tp->t_in_pcb = inp;
return(tp);
}
/*
* Is a tcp port/address pair already in use by some socket on this machine?
* Passed to in_pcbbind() to help it find a port/address binding
* that is unique for tcp.
*/
int tcp_binding_used(inp, lport, lsaddr, reuselocal)
struct inpcb *inp;
u_short lport;
u_long lsaddr;
{
register struct inpcb *i;
for (i = tcp.inp_next; i != &tcp; i = i->inp_next)
{
/*
* Since our inpcb is in this linked list, don't want to know
* if we, ourselves, are already using this binding.
*/
if (i != inp)
if (i->inp_lport == lport)
/*
* Our/His address is unbound (INADDR_ANY) iff
* not yet connected to foreign host.
*/
if ((i->inp_laddr.s_addr == lsaddr) ||
(i->inp_laddr.s_addr == INADDR_ANY) ||
(lsaddr == INADDR_ANY))
{
if (!reuselocal)
break;
if (i->inp_faddr.s_addr == INADDR_ANY)
/*
* We're both waiting for foreign
* connection. Could only re-use if
* he was already connected.
*/
break;
}
}
return (i != &tcp);
}
/*
* returns a (struct tcpcb *) cast to a (char *). This is
* so in_pcbconnect() can correctly handle return value. All
* other uses promptly cast back.
*/
char *tcp_conn_used(inp, lport, lsaddr, fport, fsaddr)
struct inpcb *inp;
u_short lport;
u_long lsaddr;
u_short fport;
u_long fsaddr;
{
register struct inpcb *i;
for (i = tcp.inp_next; i != &tcp; i = i->inp_next)
{
/*
* Since our inpcb is in this linked list, don't want to know
* if we, ourselves, are already using this connetion.
*/
if (i != inp)
if ((i->inp_lport == lport) &&
(i->inp_fport == fport) &&
(i->inp_laddr.s_addr == lsaddr) &&
(i->inp_faddr.s_addr == fsaddr))
return((char *)i->inp_ppcb);
}
return ((char *) NULL);
}
tcp_ioctl (tp, command, data)
struct tcpcb *tp;
int command;
caddr_t data;
{
switch (command)
{
/* push */
case SIOCSPUSH:
tp->t_push = TRUE;
break;
case SIOCCPUSH:
tp->t_push = FALSE;
break;
/* no activity timer */
case SIOCSNOACT:
{
u_long value;
value = *((u_long *) data);
/*
* A shutdown socket should still be able to request some sort of
* check on the status of the remote end. Also see tcp_newtcpcb().
*/
tp->t_noactprobe = (value & TCP_NOACTPROBE) ? TRUE : FALSE;
tp->t_noactsig = (value & TCP_NOACTSIG) ? TRUE : FALSE;
if ((tp->t_state <= ESTAB) || (tp->t_state == CLOSE_WAIT))
{
/* don't interfere with system use of timer */
value &= ~(TCP_NOACTPROBE|TCP_NOACTSIG);
tp->t_noact = MIN (MAX_TCPTIMERVAL, value);
tp->t_timers[TNOACT] = tp->t_noact;
}
}
break;
case SIOCGNOACT:
{
u_long value;
value = tp->t_noact;
if (tp->t_noactprobe)
value |= TCP_NOACTPROBE;
if (tp->t_noactsig)
value |= TCP_NOACTSIG;
*((u_long *) data) = value;
}
break;
/* init timer */
case SIOCSINIT:
tp->t_itimeo = MIN (MAX_TCPTIMERVAL, *((unsigned *) data));
break;
case SIOCGINIT:
*((int *) data) = tp->t_itimeo;
break;
/* retransmit took too long timer */
case SIOCSRTTL:
tp->t_rttltimeo = MIN (MAX_TCPTIMERVAL, *((unsigned *) data));
break;
case SIOCGRTTL:
*((int *) data) = tp->t_rttltimeo;
break;
case SIOCABORT:
{
struct socket *so;
/* there really should be a generic way for
* a user to get to soabort()
*/
tp->usr_abort = TRUE;
/*
* Just in case asked to abort a LISTENing socket,
* Don't leave unattached, unaccepted connections.
*/
so = tp->t_in_pcb->inp_socket;
while (so->so_q0 && (so->so_q0 != so))
(void) soabort(so->so_q0);
while (so->so_q && (so->so_q != so))
(void) soabort(so->so_q);
w_alloc(IUABORT, 0, tp, tp->t_in_pcb);
}
break;
default:
/* not our ioctl, let lower level try ioctl */
return ip_ioctl (tp->t_in_pcb, command, data);
}
return (0);
}
/*
* Process a TCP user request for TCP tb. If this is a send request
* then m is the mbuf chain of send data. If this is a timer expiration
* (called from the software clock routine), then timertype tells which timer.
*/
/*ARGSUSED*/
tcp_usrreq(so, req, m, nam, rights)
struct socket *so;
int req;
struct mbuf *m, *nam, *rights;
{
register struct inpcb *inp;
register struct tcpcb *tp;
register int s;
register int act, newstate;
int error = 0;
s = splnet();
inp = sotoinpcb(so);
/* keep in mind call from ifioctl() */
if (rights && req != PRU_CONTROL)
{
if (rights->m_len)
{
splx(s);
return (EINVAL);
}
}
/*
* When a TCP is attached to a socket, then there will be
* a (struct inpcb) pointed at by the socket, and this
* structure will point at a subsidary (struct tcpcb).
*/
if (inp == NULL && req != PRU_ATTACH)
{
splx(s);
return (EINVAL); /* XXX */
}
if (inp)
{
tp = inptotcpcb(inp);
/* WHAT IF TP IS 0? */
#ifdef GPROF
tcp_acounts[tp->t_state][req]++;
#endif
}
/*
* This switch becomes a 'caseb', so put common ones at top.
*/
switch (req)
{
case PRU_RCVD:
/*
* After a receive, possibly send window update to peer.
*/
W_ALLOC(IURECV, 0, tp, NULL, so, act, newstate);
break;
case PRU_SEND:
/*
* Do a send by initiating the proper entry to the FSM.
* Don't let urgent continue.
*/
tp->t_urg = FALSE;
W_ALLOC(IUSEND, 0, tp, m, so, act, newstate);
break;
/*
* TCP attaches to socket via PRU_ATTACH, reserving space,
* and an internet control block.
*/
case PRU_ATTACH:
if (inp)
{
error = EISCONN;
break;
}
error = tcp_attach(so);
if (error)
break;
if ((so->so_options & SO_LINGER) && so->so_linger == 0)
so->so_linger = T_LINGERTIME;
tp = sototcpcb(so);
break;
/*
* PRU_DETACH detaches the TCP protocol from the socket.
* This is only done after SO_ISCONNECTED has been cleared.
*/
case PRU_DETACH:
tcp_disconnect(tp);
break;
/*
* Give the socket an address.
*/
case PRU_BIND:
error = in_pcbbind(inp, nam, &tcp_advice);
break;
/*
* Prepare to accept connections.
*/
case PRU_LISTEN:
if (inp->inp_lport == 0)
error = in_pcbbind(inp, (struct mbuf *)0, &tcp_advice);
if (error == 0)
w_alloc(IUOPENA, 0, tp, NULL);
break;
/*
* Initiate connection to peer.
* Bind the local end if not already.
* Set the routing.
* Crank up the TCP state machine.
*/
case PRU_CONNECT:
{
struct in_addr laddr;
laddr = inp->inp_laddr;
if (inp->inp_lport == 0)
{
error = in_pcbbind(inp, (struct mbuf *)0, &tcp_advice);
if (error)
break;
}
error = in_pcbconnect(inp, nam, tcp_conn_used);
if (error)
break;
if (in_broadcast(inp->inp_faddr))
{
in_pcbdisconnect (inp, tcp_pcbdisconnect);
inp->inp_laddr = laddr;
error = EADDRNOTAVAIL;
break;
}
if (! (tp->t_template = tcp_template(tp)))
{
in_pcbdisconnect (inp, tcp_pcbdisconnect);
inp->inp_laddr = laddr;
error = ENOBUFS;
break;
}
tp->sws_qff = SWS_QFF_DEF;
/*
* So can debug connection problems without having to change
* every program or apply debugging flag to each program every
* time run it.
*/
dowedebug(inp, so, &tcp_dfilter);
soisconnecting(so);
w_alloc(IUOPENR, 0, tp, NULL);
}
break;
/*
* Create a TCP connection between two sockets.
*/
case PRU_CONNECT2:
error = EOPNOTSUPP;
break;
/*
* Initiate disconnect from peer.
* If connection never passed embryonic stage, just drop;
* else if don't need to let data drain, then can just drop anyways,
* else have to begin TCP shutdown process: mark socket disconnecting,
* drain unread data, state switch to reflect user close, and
* send segment (e.g. FIN) to peer. Socket will be really disconnected
* when peer sends FIN and acks ours.
*/
case PRU_DISCONNECT:
tcp_disconnect(tp);
break;
/*
* Accept a connection. Essentially all the work is
* done at higher levels; just return the address
* of the peer, storing through addr.
*
* BBN-NOTE: upper levels do all the waiting; this stays the same.
*/
case PRU_ACCEPT:
{
struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *);
nam->m_len = sizeof (struct sockaddr_in);
sin->sin_family = AF_INET;
sin->sin_port = inp->inp_fport;
sin->sin_addr = inp->inp_faddr;
break;
}
/*
* Mark the connection as being incapable of further output.
*/
case PRU_SHUTDOWN:
socantsendmore(so);
if (! tp->usr_closed)
w_alloc(IUCLOSE, 0, tp, inp);
break;
/*
* Abort the TCP.
*/
case PRU_ABORT:
w_alloc(IUABORT, 0, tp, inp);
break;
case PRU_CONTROL:
error = tcp_ioctl(tp, (int) m, (caddr_t) nam);
break;
/* SOME AS YET UNIMPLEMENTED HOOKS */
case PRU_SENSE:
error = EOPNOTSUPP;
break;
/* END UNIMPLEMENTED HOOKS */
case PRU_RCVOOB:
{
int desired;
if (so->so_oobmark == 0 && (so->so_state & SS_RCVATMARK) == 0)
{
error = EINVAL;
break;
}
if (tp->oob_data == NULL)
{
error = EWOULDBLOCK;
break;
}
desired = *(mtod(m, int *));
while ((desired > 0) && (tp->oob_data))
{
char *p;
unsigned count;
p = mtod(m, caddr_t);
count = MIN(desired, tp->oob_data->m_len);
count = MIN(count, MLEN);
bcopy(mtod(tp->oob_data, caddr_t), p, count);
m->m_len = count;
desired -= count;
tp->oob_data->m_len -= count;
tp->oob_data->m_off += count;
if (tp->oob_data->m_len <= 0)
tp->oob_data = m_free(tp->oob_data);
if ((desired > 0) && (tp->oob_data))
{
m->m_next = m_get(M_WAIT, MT_DATA);
m = m->m_next;
}
}
}
break;
case PRU_SENDOOB:
/*
* allows up to MAX_TCPOOB bytes of out of band data
* even if user has used up all his allocated space.
*/
if (sbspace(&so->so_snd) < (- MAX_TCPOOB))
{
m_freem(m);
error = ENOBUFS;
break;
}
tp->t_urg = TRUE;
w_alloc(IUSEND, 0, tp, m);
break;
/*
* Return the address of this socket (local-side binding)
*/
case PRU_SOCKADDR:
in_setsockaddr(inp, nam);
break;
case PRU_PEERADDR:
in_setpeeraddr(inp, nam);
break;
/*
* TCP slow timer went off; run down all those timers.
*/
case PRU_SLOWTIMO:
tcp_timeo();
break;
default:
panic("tcp_usrreq");
}
splx(s);
return (error);
}
/*
* getsockopt() / setsockopt()
*/
tcp_ctloutput (req,so,level,optname,optval)
int req;
struct socket *so;
int level, optname;
struct mbuf **optval;
{
int s = splnet(); /* like PRU/packet/timer entry into net code */
int error;
struct inpcb *inp;
/*
* possibly for us?
* Follow Berkeley methods: level is protocol number if meant for the
* protocol layer. (Why not say if=0, arp=1, ip=2, udp/tcp/rdp=3....?)
*
* Problem: tcp needs to know about IP options in order to use right
* maxseg. This doesn't quite work with the layering.
*
* Why not combine ioctl/setsockopt/getsockopt paths, since ioctl can be
* seen as fixed size sockopt- tried at BBN; removed for 4.3
*/
/* should be "mature" socket so pointers all valid... */
inp = sotoinpcb(so);
switch(req)
{
case PRCO_GETOPT:
error = tcp_getopt (inp, optname, optval);
break;
case PRCO_SETOPT:
error = tcp_setopt (inp, optname, optval);
break;
default:
panic("tcp_ctloutput");
}
splx(s);
return (error);
}
tcp_getopt (inp, command, data)
struct inpcb *inp;
struct mbuf **data;
{
/*
* no TCP specific options accessed by getsockopt() as yet.
* let lower level at cmd
*/
return ip_getopt (inp, command, data);
}
tcp_setopt (inp, command, data)
struct inpcb *inp;
struct mbuf **data;
{
int error;
struct tcpcb *tp;
/* no TCP specific options accessed by setsockopt() as yet */
tp = inptotcpcb(inp);
if (command == SO_IPROUTE)
tp->t_maxseg += inp->inp_optlen;
error = ip_setopt(inp, command, data);
if (command == SO_IPROUTE)
tp->t_maxseg -= inp->inp_optlen;
return (error);
}
/*
* These numbers come from measurements described in the paper
* "Converting the BBN TCP/IP to 4.2BSD" (S.L.C. USENIX)
* If your network handles packets larger than an ethernet frame, you
* could change tcp_init back to determine the largest net's packet size,
* multiply that by some number, and round up to a multiple of a CLSIZE.
*/
int tcp_recvspace = 4096;
int tcp_sendspace = 4096;
/*
* Attach TCP protocol to socket, allocating
* internet protocol control block, tcp control block, buffer space.
*/
tcp_attach(so)
struct socket *so;
{
register struct tcpcb *tp;
struct inpcb *inp;
int error;
if (! (error = soreserve(so, tcp_sendspace, tcp_recvspace)))
{
if (! (error = in_pcballoc(so, &tcp)))
{
inp = sotoinpcb(so);
if (tp = tcp_newtcpcb(inp))
{
/*
* Should change state tables to have an UNOPENED state like
* the butterfly's which is different from SAME.
*/
tp->t_state = 0;
return (0);
}
error = ENOBUFS;
in_pcbdetach(inp, (int (*)())0);
}
}
return (error);
}
/*
* Initiate (or continue) disconnect.
* If embryonic state, just send reset (once).
* If not in ``let data drain'' option, just drop.
* Otherwise (hard), mark socket disconnecting and drop
* current input data; switch states based on user close, and
* send segment to peer (with FIN).
*/
tcp_disconnect(tp)
register struct tcpcb *tp;
{
struct socket *so = tp->t_in_pcb->inp_socket;
soisdisconnecting(so);
sbflush(&so->so_rcv);
tp->usr_abort = TRUE;
if (!tp->usr_closed)
w_alloc(IUCLOSE, 0, tp, tp->t_in_pcb);
}
tcp_init()
{
/*
* Leave these checks in! It's a pain in the ass to find out
* problems caused by too small mbufs if someone changes the
* size of an mbuf.
*/
if (sizeof(struct inpcb) > MLEN)
panic("inpcb too big");
if (sizeof(struct socket) > MLEN)
panic("socket too big");
if (sizeof(struct th) > MLEN)
panic("th too big");
if (sizeof(struct tcpcb) > MLEN)
panic("tcpcb too big");
if (sizeof(struct t_debug) > MLEN)
panic("t_debug too big");
/* init queue */
tcp.inp_next = tcp.inp_prev = &tcp;
/* are only 4 things to match. turn off for now */
tcp_dfilter.matches = 5;
tcp_iss = time.tv_sec;
ipsw[IPPROTO_TCP].ipsw_hlen = sizeof(struct th);
}
tcp_ctlinput (prc_code, arg)
caddr_t arg;
{
int error;
error = inetctlerrmap[prc_code];
switch (prc_code)
{
case PRC_UNREACH_PROTOCOL: /* icmp message */
case PRC_UNREACH_PORT:
case PRC_MSGSIZE:
{
register struct th *tp;
struct tcpcb *t;
tp = (struct th *) (&((struct icmp *) arg)->ic_iphdr);
t = (struct tcpcb *)tcp_conn_used ((struct inpcb *) 0,
tp->t_src, tp->t_s.s_addr,
tp->t_dst, tp->t_d.s_addr);
if (t)
t_close(t, error);
}
break;
case PRC_UNREACH_NET:
case PRC_UNREACH_HOST:
{
register struct th *tp;
struct tcpcb *t;
tp = (struct th *) (&((struct icmp *) arg)->ic_iphdr);
t = (struct tcpcb *)tcp_conn_used ((struct inpcb *) 0,
tp->t_src, tp->t_s.s_addr,
tp->t_dst, tp->t_d.s_addr);
if (t)
{
struct socket *so;
so = t->t_in_pcb->inp_socket;
if ((so->so_state & SS_NOFDREF) == 0)
advise_user(so, error);
else
t_close(t, error);
}
}
break;
case PRC_GWDOWN:
in_gdown (&tcp, (u_long) arg);
break;
case PRC_REDIRECT_NET: /* icmp message */
case PRC_REDIRECT_HOST:
{
struct tcpcb *t;
register struct th *tp;
tp = (struct th *) (&((struct icmp *) arg)->ic_iphdr);
t = (struct tcpcb *)tcp_conn_used ((struct inpcb *) 0,
tp->t_src, tp->t_s.s_addr,
tp->t_dst, tp->t_d.s_addr);
if (t)
icmp_redirect_inp(t->t_in_pcb, (struct icmp *) arg,
prc_code == PRC_REDIRECT_NET ? rtnet : rthost);
}
break;
case PRC_TIMXCEED_INTRANS: /* icmp message */
case PRC_TIMXCEED_REASS:
case PRC_PARAMPROB:
break;
case PRC_QUENCH: /* icmp message */
/*
* See RFC 896. The idea is, when we get a source quench message on
* a connection we should send fewer packets. This ties in with the
* silly window syndrome whose solution is to send fewer, larger packets.
* Deal with quenches by altering threshold used by silly window
* syndrome. This is similar to acting as if the window is smaller
* than it actually is for deciding when to send, except that when we
* do, we use as much as there really is.
*/
{
register struct th *tp;
struct tcpcb *t;
tp = (struct th *) (&((struct icmp *) arg)->ic_iphdr);
t = (struct tcpcb *)tcp_conn_used ((struct inpcb *) 0,
tp->t_src, tp->t_s.s_addr,
tp->t_dst, tp->t_d.s_addr);
if (t)
{
t->sws_qff -= SWS_QFF_DEC;
if (t->sws_qff < SWS_QFF_MIN)
t->sws_qff = SWS_QFF_MIN;
}
}
break;
case PRC_IFDOWN:
{
u_long addr;
addr = ((struct sockaddr_in *)(arg))->sin_addr.s_addr;
inpcb_notify(&tcp, addr, (u_long) 0, error);
inpcb_notify(&tcp, (u_long) 0, addr, error);
}
break;
case PRC_HOSTDEAD: /* from imp interface */
case PRC_HOSTUNREACH:
/*
* get same message for destination hosts and gateways.
*/
{
u_long addr;
addr = ((struct sockaddr_in *)arg)->sin_addr.s_addr;
in_gdown (&tcp, addr);
inpcb_notify(&tcp, (u_long) 0, addr, error);
}
break;
default:
panic("tcp_ctlinput");
}
}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.