Homework 7 Solution
Problem 1 (5)
A process on host 1 has been assigned port p, and a process on host 2
has been assigned port q. Is it possible for there to be two or more
TCP connections between these two ports at the same time?
No. A pair of ports uniquely sets up
Problem 2 (40)
TCP provides reliable transfer through a mixture of
sequence number, receiver buffer, cumulative acknowledgement, and fast
retransmission. Answer the following True or False problems. If it's
False, explain why.
- a) Host A is sending host B a large file over a TCP
connection. Assume host B has no data to send to A. Host B will not
send acknowledgements to host A because host B cannot piggyback the
acknowledgement on data.
False. Piggyback is only for efficiency. If
there's no data packet to be piggybacked to, then B will just send the
- b) The size of the TCP advertised window (RcvWindow) never changes
throughout the duration of the connection.
False. It is the size of the receiver's buffer
that's never changed. RcvWindow is the part of the receiver's buffer
that's changing all the time depending on the processing capability at
the receiver's side and the network traffic.
- c) Suppose host A is sending host B a large file over a TCP
connection. The number of unacknowledged bytes that A sends cannot
exceed the size of the receiver's buffer.
False and True. The number of unacknowleged
bytes that A sends cannot exceed the size of the receiver's window.
But if it can't exceed the receiver's window, then it surely has no
way to exceed the receiver's buffer as the window size is always less
than or equal to the buffer size. On the other hand, for urgent
messages, the sender CAN send it in even though the receiver's buffer
- d) Suppose host A is sending host B a large file over a TCP
connection. If the sequence number for a segment of this connection is
m, then the sequence number for the subsequent segment will
necessarily be m+1.
False. The sequence number of the subsequent
segment depends on the number of 8-byte characters in the current
- e) Suppose host A sends host B one segment with sequence number 38
and 4 bytes of data. Then in the same segment the acknowledgement
number is necessarily 42.
False. The acknowledgement number has nothing to
do with the sequence number. The ack. number indicates the next
sequence number A is expecting from B.
- f) Suppose that the last sampleRTT in a TCP connection is equal to
1 second. Then timeout for the connection will necessarily be set to a
value >= 1 second.
False. Next_RTT = alpha * last_estimated_RTT +
(1-alpha)*newly_collected_RTT_sample. In this case even though the
last sampleRTT which is the newly_collected_RTT_sample is 1sec, the
next_RTT still depends on alpha and last_estimated_RTT. Therefore, the
next_RTT is not necessarily greater than 1sec.
- g) With the selective repeat protocol, it is possible for the
sender to receive an ACK for a packet that falls outside of its
False. SR uses selective acknowlegement. The
ack. number has no way to fall outside the current window.
- h) With the Go-Back-N, it is possible for the sender to receive an
ACK for a packet that falls outside of its current window.
True. GBN uses cumulative acknowlegement.
Imagine a scenario where ACK1 arrives AFTER ACK2. Once the sender
receives ACK2, it would know that both packet1 and 2 were received
correctly. So it can remove packet1 and 2 from its window. Now if ACK1
arrives, then ACK1 actually falls outside the current window.
Problem 3 (10)
TCP provides congestion control through slow start and AIMD (
increase and multiplicative decrease). Answer the following True or
False problems. If it's False, explain why.
Problem 4 (10)
- Consider the effect of using slow start on a line with a 10-msec
round-trip time and no congestion. The receive window is 24KB and the
maximum segment size is 2KB. How long does it take before the first
full window can be sent?
With slow start, the first RTT sends out 1
segment (or 2KB), the 2nd RTT sends out 2 segments (or 4KB), the 3rd 4
segments (or 8KB), the 4th 8 segments (or 16KB). The 5th RTT would
have sent out 16 segments (or 32KB), however, it'll exceed the
receiver's window. Therefore, the amont of time it takes BEFORE the
5th RTT (or full window, that is, 24KB) is 4*10=40msec.
- Suppose the TCP congestion window is set to 18KB and a timeout occurs.
How big will the window be if the next four transmission bursts are
all successful? Assume that the maximum segment size is 1KB.
When a timeout occurs, three things happend.
First, slow start will be initiated. Second, the congestion window
would start at 1. Third, the threshold will be reset to 18KB/2=9KB. If
the next four transmission are all successful, then
After these four successful transmissions, the window size is supposed
to be 16. However, since the threshold is 9KB, the window size can
only be 9KB.
- 1st transmission: 1 segment, 1KB
- 2nd transmission: 2 segments, 2KB
- 3rd transmission: 4 segments, 4KB
- 4th transmission: 8 segments, 8KB
Problem 5 (20)
- Based on the sample codes given in class,
write a client and server "echo" program which uses UDP and TCP. You need to turn in the following codes
It is important to understand what qualifies a
REAL server. Following is a list of criteria,
Given the above criteria, the way you know that you have a perfect
server is that open three windows. In one window, run the server
program, in the other two windows, run two client program. Write
messages in each of the client windows and see if the server can
respond correctly. Then close one client connection, see if the server
can server the other client correctly.
- When only one client is connected, the server should be able to
echo back multiple messages sent by the client.
- The server should be able to server more than one client
- When one client disconnects, the server should be able to server
other clients with normal condition.
In the following, I've provided different versions of
- Non-iterative server and client using TCP: servertcp.c, clienttcp.c (The server and the client can only
exchange ONE message, then both exit. This is the sample code I posted
- Non-iterative server and client using UDP: serverudp.c, clientudp.c (To modify TCP to UDP, three
components are needed
- change from SOCK_STREAM to SOCK_DGRAM (all of you did this right
- no need for listen(), accept() at the server's side, and no need
for connect() at the client side
- change from read()/write() to recvfrom()/sendto(). Many of you
didn't have this part correct. Pay special attention to the arguments
used, the socket ID used, etc. I used the original TCP code and
commented in detail the changes.
- Iterative server and client using UDP: iserverudp.c, iclientudp.c (this is a lot easier than the
- Iterative server and client using TCP. I provided three versions:
tar file with all the codes: socket.tar
- (+10)Design and develop an application
scenario that tests the effect of having more requests than the
allowed queuing length in "listen()". You need to turn in the code as
well as the output
To be added.
Problem 6 (15)
Refresh concepts on ``big endian'' and ``little endian''
Problem 7 (10 - check for completion but not correctness): Task 1 of project 4
Write a server for node0 and call it node0.c. Write a client for node1 and call it node1.c. Initially, prepare the initial DV table for both node0 and node1. Let node1 send its DV to node0. Upon receiving node1's DV, node0 will modify its DV according to node1's input. Then it'll reply node1 with the updated DV.