Transcript Recitation 2 slides

EECS340 Recitation 2:
Very helpful to your project
Hongyu Gao
1
Warming-up Questions
If you don’t know your IP address,
dig into the old announcement in the
newsgroup
2
Roadmap
 How to run Minet stack
 Hints for project 2
3
Need X-server if running remotely
Xming for Windows
4
Script to run Minet
start_minet.sh somehow
doesn’t work properly for
me.
Use run_modules.sh
instead.
Remember to set variable
MINET_IPADDR and
MINET_ETHERNETADD
R in minet.cfg or
run_modules.sh,
depending on which script
you use.
5
Connect to tcp_server with nc
6
Script to stop Minet
./stop_minet.sh
7
Roadmap
 How to run Minet stack
 Hints for project 2
8
File to Modify
src/core/tcp_module.cc
Implement your TCP in this file
9
Refer to udp_module.cc
How to pass data to application layer
(sockets)?
How to receive data from application layer
(sockets)?
How to pass data to IP layer?
How to receive data from IP layer?
MinetSend() and MinetReceive()
10
Understand TCP Protocol!
11
Sneak Peek: Talk with IP Layer
pt2DFIPFunction DFIPFuncArray[NUM_TCP_STATES] =
{ &DFIPNull,
// CLOSED
&DFIPNull,
// LISTEN *DFIPListen is not dispatched from
this table*
&DFIPSynRcvd,
// SYN_RCVD
&DFIPSynSent,
// SYN_SENT
&DFIPSynSent1, // SYN_SENT1
&DFIPEstablished, // ESTABLISHED
&DFIPSendData, // SEND_DATA
&DFIPCloseWait, // CLOSE_WAIT
&DFIPFinWait1, // FIN_WAIT1
&DFIPClosing,
// CLOSING
&DFIPLastAck,
// LAST_ACK
&DFIPFinWait2, // FIN_WAIT2
&DFIPTimeWait
// TIME_WAIT };
12
Sneak Peek: Talk with Sockets
pt2DFSOCKFunction
DFSOCKFuncArray[NUM_SOCK_TYPES] =
{ &DFSOCKConnect, // CONNECT
&DFSOCKAccept, // ACCEPT
&DFSOCKWrite, // WRITE
&DFSOCKForward, // FORWARD
&DFSOCKClose, // CLOSE
&DFSOCKStatus // STATUS
};
13
Please make your code wellcommented
Next, some slides that previous TAs gave to the previous
students…
14
From Anonymous TA1
What to do in muxHandler()?
(starting from line 50)
Get the headers
 Use function MinetReceive to get the
packet p.
 Get the TCPHeader and IPHeader of p.
You can use the function in class Packet.
For example, FindHeader function. You can
get the Tcpheader by using
p.FindHeader(Headers::TCPHeader);
Find the connections
 Extract information from the IPHeaders and
TCPHeaders. For example, src ip & port and
dest ip &port. For example, using
iph.GetDestIP function.(suppose iph is the ip
header)
 Use the information above to find the
connection the packet belongs in Clist.
Clist is used for keeping all connections built.
For example, using
ConnectionList<TCPState>::iterator cs =
clist.FindMatching(c);// Specify c with src &
dest information
Parse tcp header
 Get the state of current connection. You
may need to modify it based on the packet
received. For example, using
(*cs).state.GetState();
 Get the flags of TCP header, using
tcph.GetFlags(f). Then check whether it is
SYN, ACK, FIN.. And do corresponding
action based on current state.
For Example




























if( IS_ACK(f) && IS_SYN(f) )
{
cout<<"SYN ACK packet Received. will have to send ACK packet"<<endl;
p.Print(cout);
if( state == SYN_SENT )
{
connstate.state.SetState(ESTABLISHED);
unsigned int newack,last_recvd;
tcph.GetAckNum(newack);
tcph.GetSeqNum(last_recvd);
connstate.state.SetLastAcked( newack );
connstate.state.SetLastRecvd( last_recvd );
connstate.timeout=Time() + ACK_TIMEOUT;
}
}
char *data1 = "ACTIVE:in active connection\n";
Buffer b(data1,strlen(data1));
Packet psh;
unsigned int old_time;
TCPOptions opt;
tcph.GetOptions(opt);
old_time = ntohl(*(int *)(opt.data+8));
craftSynPacket(&psh,connstate,PSH_ACK_HEADER,0,old_time);
psh.Print(cout);
MinetSend(mux,psh);
connstate.state.SetLastSent(connstate.state.GetLastSent());
status=STATUS;
MinetSend(sock,write);
From Anonymous TA2
TCP Details
Introduction to
Networking
Netprog: TCP Details
21
The TCP Project
Important Handouts:
 Minet


The Minet Technical Report
The Minet Socket Interface
 TCP Guides





RFC 793 http://www.freesoft.org/CIE/RFC/793/ (in
convenient HTML format), RFC 1122
http://www.faqs.org/rfcs/rfc1122.html
A very useful summary and picture of the TCP State diagram
(TCP_IP_State_Transition_Diagram.pdf)
TCP, UDP and IP pocket guide (TCP_UDP_IP_packet_guide.pdf)
includes header details
Brief overview of TCP
(http://www.freesoft.org/CIE/Topics/83.htm) contains a nice
summary of the essentials
Here is a page with nice TCP animations
(http://www.netbook.cs.purdue.edu/). They explain TCP
connection startup, termination, data flow and flow control and
cumulative ack concepts.
Netprog: TCP Details
22
TCP Lingo
 When a client requests a connection, it
sends a “SYN” segment (a special TCP
segment) to the server port.
 SYN stands for synchronize. The SYN
message includes the client’s ISN.
 ISN is Initial Sequence Number.
Netprog: TCP Details
23
More...
 Every TCP segment includes a
Sequence
Number that refers to the first byte of
data included in the segment.
 Every TCP segment includes a Request
Number (Acknowledgement Number) that
indicates the byte number of the next data
that is expected to be received.

All bytes up through this number have already
been received.
Netprog: TCP Details
24
And more...
 There are a bunch of control flags:
URG: urgent data included.
 ACK: this segment is (among other things) an
acknowledgement.
 RST: error - abort the session.
 SYN: synchronize Sequence Numbers (setup)
 FIN: polite connection termination.

Netprog: TCP Details
25
And more...
 MSS: Maximum segment size (A TCP
option)
 Window: Every ACK includes a Window
field that tells the sender how many bytes
it can send before the receiver will have to
toss it away (due to fixed buffer size,
“flow control”).
Netprog: TCP Details
26
TCP Connection Creation
A

A

server accepts a connection.
Must be looking for new connections!
client requests a connection.
Must know where the server is!
Netprog: TCP Details
27
Client Starts
 A client starts by sending a SYN segment
with the following information:
Client’s ISN (generated pseudo-randomly)
 Maximum Receive Window for client.
 Optionally (but usually) MSS (largest datagram
accepted).
 No payload! (Only TCP headers)

Netprog: TCP Details
28
Sever Response
 When a waiting server sees a new
connection request, the server sends back
a SYN segment with:
Server’s ISN (generated pseudo-randomly)
 Request Number is Client ISN+1
 Maximum Receive Window for server.
 Optionally (but usually) MSS
 No payload! (Only TCP headers)

Netprog: TCP Details
29
Finally
 When the Server’s SYN is received, the
client sends back an ACK with:

Request Number is Server’s ISN+1
Netprog: TCP Details
30
Server
Client
SYN
ISN=X
1
time
SYN
2
ISN=Y ACK=X+1
ACK=Y+1
3
Netprog: TCP Details
31
Why 3-Way?
 Why is the third message necessary?
 HINTS:
 TCP is a reliable service.
 IP delivers each TCP segment.
 IP is not reliable.
Netprog: TCP Details
32
TCP Data and ACK
 Once the connection is established, data
can be sent.
 Each data segment includes a sequence
number identifying the first byte in the
segment.
 Each segment (data or empty) includes a
request number indicating what data has
been received.
Netprog: TCP Details
33
TCP Buffers
 Both the client and server allocate buffers
to hold incoming and outgoing data

The TCP layer does this.
 Both the client and server announce with
every ACK how much buffer space remains
(the Window field in a TCP segment).
Netprog: TCP Details
34
Send Buffers
 The application gives the TCP layer some
data to send.
 The data is put in a send buffer, where it
stays until the data is ACK’d.

it has to stay, as it might need to be sent again!
 The TCP layer won’t accept data from the
application unless (or until) there is buffer
space.
Netprog: TCP Details
35
ACKs
 A receiver doesn’t have to ACK every
segment (it can ACK many segments with a
single ACK segment).
 Each ACK can also contain outgoing data
(piggybacking).
 If a sender doesn’t get an ACK after some
time limit (MSL) it resends the data.
Netprog: TCP Details
36
Termination
 The TCP layer can send a RST segment
that terminates a connection if something
is wrong.
 Usually the application tells TCP to
terminate the connection politely with a
FIN segment.
Netprog: TCP Details
37
FIN
 Either end of the connection can initiate
termination.
 A FIN is sent, which means the application
is done sending data.
 The FIN is ACK’d.
 The other end must now send a FIN.
 That FIN must be ACK’d.
Netprog: TCP Details
38
App2
App1
FIN
SN=X
2
...
ACK=X+1
1
FIN
SN=Y
3
ACK=Y+1
4
Netprog: TCP Details
39