Category : Files from Magazines
Archive   : DDJ0892.ZIP
Filename : NETWORK.ASC

_HIGH-SPEED NETWORKING_
by William F. Jolitz

[LISTING ONE]

From file /sys/netinet/in_pcb.c:

/* Find a internet protocol control block associated with a given session.
* Session is determined as a match between foriegn (faddr, fport) and local
* (laddr, lport) source/destionation identifiers. Allows wildcard matches
* when some but not all of the parameters are known. */
struct inpcb *
in_pcblookup(head, faddr, fport, laddr, lport, flags)
struct inpcb *head;
struct in_addr faddr, laddr;
u_short fport, lport;
int flags;
{
register struct inpcb *inp, *match = 0;
int matchwild = 3, wildcard;

for (inp = head->inp_next; inp != head; inp = inp->inp_next) {
if (inp->inp_lport != lport)
continue;
wildcard = 0;
if (inp->inp_laddr.s_addr != INADDR_ANY) {
if (laddr.s_addr == INADDR_ANY)
wildcard++;
else if (inp->inp_laddr.s_addr != laddr.s_addr)
continue;
} else {
if (laddr.s_addr != INADDR_ANY)
wildcard++;
}
if (inp->inp_faddr.s_addr != INADDR_ANY) {
if (faddr.s_addr == INADDR_ANY)
wildcard++;
else if (inp->inp_faddr.s_addr != faddr.s_addr ||
inp->inp_fport != fport)
continue;
} else {
if (faddr.s_addr != INADDR_ANY)
wildcard++;
}
if (wildcard && (flags & INPLOOKUP_WILDCARD) == 0)
continue;
if (wildcard < matchwild) {
match = inp;
matchwild = wildcard;
if (matchwild == 0)
break;
}
}
return (match);
}



[LISTING TWO]

From file:/sys/netinet/tcp_input.c

...
/* * Locate pcb for segment. * */
findpcb:
inp = tcp_last_inpcb;
/* first, see if this segment looks familiar */
if (inp->inp_lport != ti->ti_dport ||
inp->inp_fport != ti->ti_sport ||
inp->inp_faddr.s_addr != ti->ti_src.s_addr ||
inp->inp_laddr.s_addr != ti->ti_dst.s_addr) {
inp = in_pcblookup(&tcb, ti->ti_src, ti->ti_sport,
ti->ti_dst, ti->ti_dport, INPLOOKUP_WILDCARD);
if (inp)
tcp_last_inpcb = inp;
++tcppcbcachemiss;
}
...


[LISTING THREE]

From file:/sys/netinet/tcp_input.c:

...
/* Header prediction: check for the two common cases of a unidirectional
* data xfer. If the packet has no control flags, is in-sequence, the window
* didn't change and we're not retransmitting, it's a candidate. If the length
* is zero and the ack moved forward, we're the sender side of the xfer. Just
* free the data acked & wake any higher level process that was blocked
* waiting for space. If length is non-zero and the ack didn't move, we're the
* receiver side. If we get packets in-order (the reassembly queue is empty),
* add data to the socket buffer and note that we need a delayed ack. */
if (tp->t_state == TCPS_ESTABLISHED &&
(tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) == TH_ACK &&
ti->ti_seq == tp->rcv_nxt &&
ti->ti_win && ti->ti_win == tp->snd_wnd &&
tp->snd_nxt == tp->snd_max) {
if (ti->ti_len == 0) {
if (SEQ_GT(ti->ti_ack, tp->snd_una) &&
SEQ_LEQ(ti->ti_ack, tp->snd_max) &&
tp->snd_cwnd >= tp->snd_wnd) {
/* this is a pure ack for outstanding data. */
++tcppredack;
/* need to update round trip timers */
if (tp->t_rtt && SEQ_GT(ti->ti_ack,tp->t_rtseq))
tcp_xmit_timer(tp);
/* free sent data that was acknowledged */
acked = ti->ti_ack - tp->snd_una;
tcpstat.tcps_rcvackpack++;
tcpstat.tcps_rcvackbyte += acked;
sbdrop(&so->so_snd, acked);
tp->snd_una = ti->ti_ack;
/* free this packet */
m_freem(m);
/* If all outstanding data are acked, stop
* retransmit timer, otherwise restart timer
* using current (possibly backed-off) value.
* If process is waiting for space,
* wakeup/selwakeup/signal. If data are ready
* to send, let tcp_output decide between more
* output or persist. */
if (tp->snd_una == tp->snd_max)
tp->t_timer[TCPT_REXMT] = 0;
else if (tp->t_timer[TCPT_PERSIST] == 0)
tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
if (so->so_snd.sb_flags & SB_NOTIFY)
sowwakeup(so);
if (so->so_snd.sb_cc)
(void) tcp_output(tp);
return;
}
} else
/* This is a pure, in-sequence data packet with nothing on the
* reassembly queue; we have enough buffer space to take it. */
if (ti->ti_ack == tp->snd_una &&
tp->seg_next == (struct tcpiphdr *)tp &&
ti->ti_len <= sbspace(&so->so_rcv)) {
/* update received state and statistics */
tp->rcv_nxt += ti->ti_len;
++tcppreddat;
tcpstat.tcps_rcvpack++;
tcpstat.tcps_rcvbyte += ti->ti_len;
/* Deliver data by dropping TCP and IP headers, then
* add data to application's socket buffer, and wakeup
* application if necessary. */
m->m_data += sizeof(struct tcpiphdr);
m->m_len -= sizeof(struct tcpiphdr);
sbappend(&so->so_rcv, m);
sorwakeup(so);
/* request that a acknowledgement be sent with next
* data packet outbound -- we delay in hopes of
* "piggy backing" on top of a data packet.
tp->t_flags |= TF_DELACK;
return;
}
}
...