1. Figure 2-17 Relationship of layers and addresses in TCP/IP Example: web browser implementing HTTP Implemented in TCP and UDP software. HTTP uses TCP. Interface. Eg. WINSOCK on PCs Implemented in IP software Eg. Ethernet Medium Access Control (MAC) implemented in NIC card (Network Interface Card) and driver software Eg. Ethernet PHY layer. Implemented in NIC card Eg. TCP port 80 for web server Eg. 140.192.33.37 (32- bit) Eg. Ethernet address (48-bit)

2. Figure 2-19 IP addresses (A logical address necessary for universal communication over the internet, and is independent of the underlying physical networks) Note: We commonly uses names such as www.cs.depaul.edu (called Domain Names). To translate from names to IP addresses, needs to use DNS (Domain Name Service) implemented at the Application level.

3. BBridge/switch 10 20 99 95

4. IP Addressing

5. Figure 4.1 Dotted Decimal Notation Figure 4.6 Classful IP Addresses Class A: Large networks Class B: Medium networks Class C: Small networks Hostid with all 0’s or all 1’s are special.

6. Similar to Figure 5.2 subnetting (Three levels of hierarchy) Usable addresses: 141.14.2.1 to 141.14.2. 254

7. Similar to Figure 5.12 Subnet mask vs Supernet mask

9. Classless Interdomain Routing (CIDR)

10. ARP RARP IP ICMP BOOTP DHCP

11. Figure 7.1ARP and RARP

12. Figure 8.2 IP Datagram HLEN: Actual number of bytes in header / 4 Version = 4 Total number of bytes (header + data) Actually count hops. Decremented by one each time the packet is routed

13. Figure 8.9 Detailed fragmentation example (note: the diagram in the book is incorrect)

14. Transport Layer - UDP

15. Figure 11-6 Socket Address Figure 11-7 UDP datagram format

16. Transport Layer - TCP

17. Sliding window protocol: window management

18. Implementation issue: Silly window syndrome A small amount of data. For example: 1 byte It comes to a point when the sender naturally sends small amount of data  inefficient Nagle’s solution: collect enough data before sending Clark’s solution: only advertise window sizes that are reasonably large

19. Figure 12-13 Corrupted segment Error Control: Example – corrupted segment. Other examples in the text.

20. TCP timer management What is a reasonable timeout period? RTT: the best current estimate of the round-trip time to the destination in question RTT =  RTT + (1-  )M where M is the current measured time for the ack to get back before the timer expires;  is a smoothing factor that determines how much weight is given to the old value. Typically = 7/8

21. TCP timer management Karn's alogirthm When retransmission occurs, one cannot tell which transmission an Ack corresponds to, and the estimate of RRT will not be accurate. Karn proposed that RTT not updated, but timeout doubled, until you send a segment and receive an acknowledgment without the need for retransmission. (Note: Recall that RTT  timeout) Persistence Timer For zero-window probe: Whenever a window closes completely, the sender periodically probes the receiver with small amount to data (because a lost window update may cause a deadlock.) Keepalive Timer When a connection has been idle for a long time, check to see if the other side is still there. Time-Waited Timer During connection termination. A connection is not considered really closed until the end of a time-waited period. Usually two times the expected lifetime of a segment

22. Figure 12-17 Slow Start and Congestion Avoidance

23. Figure 12-19 TCP Segment Format Valid only if urg bit is set. Urgent data always appear in the beginning of the data, and the pointer point to the first byte of the normal data after the urgent data. Number of bytes / 4 Buffers available

24. Figure 12-28 Connection Establishment :Three-way handshake

25. Figure 12-23 Connection Release: Four-way handshake Closing data stream in this direction only

26. Routing

27. Figure 13-2 Autonomous system (AS) concepts Figure 13-1 AS = a group of networks and routers under the authority of a single administration EGP

28. Distance Vector Routing Dynamic Sharing knowledge about the entire AS Sharing only with neighbors Sharing at regular interval Sharing the distance vector: a router’s distance to all other routers within the AS Routes are calculated based on the distance vectors received from the neighbors. RIP (Routing Information Protocol) – the older Internet routing protocol, is an example –encapsulated in UDP: Well known port 520.( –RFC 1058 (RIPv1); RFC 1388 (RIPv2)

29. Figure 13-3 Examples of RIP updates (done at the current router.)

30. Figure 13-14 Remedies for instability Triggered updates: Sending a change immediately Split horizons: a router that receives updates from an interface must not send back the same information through this interface. Poison reverse: a variation of split horizons. Lie by advertising infinity (16) Figure 13-15

31. Link State Routing Dynamic Sharing knowledge about the neighborhood- link states: who I am directly connected to and the distance (based on minimum delay, maximum throughput, cost, hop counts etc.) Sharing with every other router – broadcast by flooding Sharing when there is a change OSPF (Open Shortest Path First), the newer Internet routing protocol is an example. General steps –Hello: discovering reachability –Build link state packets (advertisements) –Broadcast the link state packets: initially and when there are changes –Build a map from the received link state packets –From the map calculate the shortest path

32. Dijkstra Algorithm: for calculating shortest paths 1.Start with the local node (router): the root of the tree 2.Assign a cost of 0 to this node and make it the first permanent node. 3.Examine each non-permanent neighbor node of the node that was the last permanent node. 4.Assign a cumulative cost to each node and make it tentative 5.Among the list of tentative nodes 1.Find the node with the smallest cumulative cost and make it permanent 2.If a node can be reached from more than one direction 1.Select the direction with the shortest cumulative cost. 6.Repeat steps 3 to 5 until every node becomes permanent

33. Figure 13-50 Path vector packets