[SOLVED] COSC328-Lab 2

Description

• SSL (and TSL) operates at the application layer. In order to implement it, a developer invokes an SSL (or TSL) library in both the client and server codebases. The client side will take clear text arguments, a password for example, and pass it to the SSL socket. The SSL socket will encrypt the data, send it to the server, then the server will use SSL code to decrypt the message.
• The TCP requires a socket on the server side to handle the handshake from the client, then all the data received from the client is routed to the connection socket. UDP does not require a handshake between client and server, so the data is sent directly to the server socket from the client socket. For a TCP server with n simultaneous connections, the server will require one handshake or welcome socket plus n connection sockets, so n+1 sockets in total.
• a) The average time to send an object over the access link is given by

Δ = L/R = 850,000bits/15,000,000 bps = 0.0567 s

This means the average access delay is given by

Δ/(1-Δβ) = 0.0567s/(1-0.0567s * 16 requests/s) = 0.607 s/request

The average time from the router on the internet side of the access link to a given server is 3 s, so the total access delay is given by

0.607 s + 3 s = 3.607 s

1. b) If 60% of the requests are satisfied by the cache, this means overal traffic intensity is reduced by 60% as well. The average access delay will decrease as such:

Δ/(1-0.4Δβ) + 3 s = 0.0567s/(1-0.4*0.0567s * 16 requests/s) + 3 s = 3.889 s/request

Cached responses happen near instantaneously, at a frequency of 60%. The requests that actually access the internet occur 40% of the time, so the total response time is given by

0.6 * 0 s + 0.4 * 3.889 s = 1.236 s a significant improvement over the 3.607 uncached response time.

4)

For client-server distribution, the time to distribute a file of size F to N clients is given by

D_c-s >= max{NF/u_s, F/d_min}

So the upload rate of peers u is irrelevant, and as an example, the total time to download for 10 clients is given by

D_c-s >= max{NF/u_s, F/d_min} = max{10*15Gbit/30Mbps, 15Gbit/2Mbps}

= max{10*15*1024 Mbit/30Mbps, 15 * 1024 Gbit / 2 Mbps} = max{5120s, 7680s}

= 7680s = 2 hr 8 min and similarly for the other three rows. max{512,000s, 7680s}

For peer-to-peer distribution, the time is given by

D_P2P >= max{F/u_s, F/d_min, NF/(u_s + Σu)}

As an example, the first row in the P2P table is calculated as:

D_P2P >= max{F/u_s, F/d_min, NF/(u_s + Σu)}

= max{15Gbit/30Mbps, 15Gbit/2Mbps, 10*15Gbit/(30Mbps + 10*300Kbps)}

= max{15*1024Mbit/30Mbps, 15*1024Mbit/2Mbps, 10*15*1024Mbit/(30Mbps +

10*300/1024Mbps)}

= max{512s, 7680s, 4664.48s} = 7680 s = 2 hr 8 min and similarly for the other three rows.

max{512s, 7680s, 47,558.78s}            max{512s, 7680s, 3072s}          max{512s, 7680s, 7566.50}

• a) TCP b) UDP c) UDP d) UDP e) TCP  f) UDP
• a) localhost/index.html

1. b) The browser is requesting a persistent connection; the Connection field of the request header indicates Keep-Alive, meaning keep the connection open until it times out.

7) a) Using non-persistent connections, the order of connections is as such: i) Client initiates TCP connection ii) Server acknowledges connection iii) Client requests HTML document

1. iv) Server acknowledges requests and begins sending HTML document v) Client receives HTML document vi) Server closes connection

• Client unpacks HTML document, sees reference to four image files
• Client repeats above for all four images

This means each object will involve two TCP connections and the file transfer time, so the total time is given by: t_tot = 0.1 s * 2 * 5 + 10,000bit / 10 * 1024² bps + 4 * 50,000bit / 10 * 1024² bps = 1.02 s

1. If the browser is able to open any number of parallel connections, the first step to obtain the HTML remains the same, but then all four images can be obtained concurrently. Hence t_tot = 0.1 s * 2 * 2 + 10,000bit / 10 * 1024² bps + 50,000bit / 10 * 1024² bps = 0.406 s
2. In a persistent connection with no pipelining and parallel connections, the client will require two RTT to initiate the TCP handshake with server 1, then transfer the HTML document, see the references to the images, begin the transfer of the three images from server 1 while concurrently setting up a TCP handshake with server 2 and transferring the image file from there. In other words, four RTT times will be necessary plus the HTML file transfer and one image transfer time, or t_tot = 0.1 s * 2 * 2 + 10,000bit / 10 * 1024² bps + 50,000bit / 10 * 1024² bps = 0.406 s

This is effectively the same result as a non-persistent connection with concurrency. However, with pipelining, the client will request the images as it encounters a reference to them in the HTML document. Unless the image on server 2 is at the very end of the HTML document, this means the TCP handshake will occur some time during the HTML document transfer. Assuming the image on server 2 is referenced at the very beginning of the HTML file, it will effectively negate the transfer time of the html file, or

t_tot = 0.1 s * 2 * 2 + 50,000bit / 10 * 1024² bps = 0.405 s which is the fastest of the four options (although only by one ms).

8) a)

b)