TCP/IP Model: Layers and Protocols

TCP/IP Model

• Comprises five layers that enable reliable communication over networks.

Application Layer

• Highest layer; provides network services to applications.
• Enables interaction between users, software, and the network.
• Protocols include HTTP/HTTPS (web browsing), FTP (file transfer), SMTP, IMAP, POP3 (email), DNS (domain name system), SSH, and Telnet (remote access).

Transport Layer

• Ensures reliable, end-to-end communication between devices.
• Uses port numbers to identify processes/services and enables communication channels.
• Supports segmentation, reassembly, and error handling.
• Key protocols include TCP (reliable, connection-oriented communication used in HTTP, FTP) and UDP (fast, connectionless communication used in VoIP, DNS).

Internet Layer

• Handles packet routing and addressing across different networks.
• Uses logical addressing (IP addresses) to identify source and destination hosts.
• Determines the optimal path for data transmission.
• Protocols are IP (IPv4, IPv6), ICMP, and RIP.

Network Layer

• Ensures reliable data transfer between adjacent network nodes, delivering messages.
• Follows the mesh-network concept, where data stations are typically not directly connected.
• Bridges the initial steps in message delivery across the network.

Physical Layer

• Lowest layer; responsible for physical connection between devices.
• Defines data transmission in terms of electrical signals, radio waves, or light pulses (signaling).
• Includes network hardware such as cables, switches, and NICs.
• Protocols include Ethernet, Wi-Fi (802.11), DSL, and Fiber Optics.

Procedure Call

• A procedure definition describes how the procedure operates within the computer.
• The definition includes the procedure name, parameters, return type, procedure body, procedure call, argument, and assignment.

Local Procedure Call

• Caller (client program) and callee (server program) run on the same machine.
• Data exchange (parameters and results) between programs on the same machine is straightforward.
• Typically uses a synchronous communication scheme.
• Data is exchanged via shared local memory in two primary ways.
  • Call by Value (CBV): Parameter values are copied, changes do not affect the original value; downside is higher memory usage; upside is the original value remains unchanged.
  • Call by Reference (CBR): Callee receives a pointer (memory address); changes affect the original data; downside is original values can be lost; benefit is efficient memory use.

Remote Procedure Call

• Caller and callee run on different machines.
• Appears identical to a local procedure call from a programmer's perspective.
• Slower than local calls and follows (or emulates) synchronous communication.
• RPC middleware hides distribution details via client and server interactions.
• Transparency aims to minimize complexities; due to network issues (failures, latency, security), RPCs can never be fully transparent.

Transparency Types for RPC

• Access Transparency: Enables accessing local and remote resources using identical operations via stubs.
• Location Transparency: Accessing resources without knowing their physical/network location, requires a binding mechanism.
• Failure Transparency: Conceals faults by providing different RPC semantics.
• Performance Transparency: System reconfigures to improve performance with varied loads.

RPC Middleware - Stubs and Skeletons

• Sits between two computers in a system, with a client component and a server component.
• Stubs provide transparency, with client stubs offering a local interface for RPCs and preparing requests.
• Server stubs receive RPCs and perform local procedure calls, hiding network complexity.

Parameter Passing

• Involves client and server components on different machines without shared local memory.
• Clients and servers might run on different software/hardware platforms.
• Requires agreement on data structures and exchange formats for RPC requests/replies.
• Stubs use an agreed format to assemble/disassemble RPC messages (marshalling).
• RPC parameter passing typically follows a call-by-value scheme, allowing a client to send a copy of the parameter values to the server.
• Simulating call-by-reference (CBR), or call-by-copy/restore (CBC/R), involves copying, modifying, and returning data.
• Client stub copies the CBR parameter(s) into the request message.
• Server stub rebuilds the memory structure.
• Server procedure can modify the memory structure.
• After the procedure, the server stub copies changes into the reply message.
• Client stub then updates its memory using the changed values.
• Marshalling: Converts a collection of data items into a format suitable for message transmission.
• Unmarshalling: Disassembles a message into a collection of data items.

RPC Binding

• Client components must be bound to the corresponding server component to invoke remote procedures.
• Includes the name and network address of the server component.
• RPC middleware establishes the binding.
• Static Binding: Compiled into the client stub and unchangeable; benefit is no time penalty.
• Dynamic Binding: Requires a global registry/discovery system where server components advertise bindings with a discovery service, benefit is changeable during runtime; downside is you wait longer.

RPC Semantics and Reliability

• Maybe: RPC may or may not be executed (one request message, client may or may not receive a reply).
• At-least-once: RPC is executed one or more times (client receives a reply or an exception if no reply is received).
• At-most-once: RPC is executed either once or not at all.
• Exactly-once: RPC is executed exactly once, and one corresponding reply message is received.

RPC Failures in Distributed Systems

• Distributed systems can experience independent hardware and software failures.
• Client-cannot-locate-server failure: The client stub cannot locate the server stub due to changed binding details.
• Lost Messages: Client cannot determine if a request or reply is lost; all lost messages are treated the same.
• The server sets a timeout and resubmits the request, with each message having a unique identifier (UID).
• Idempotent operation: Server can repeat the operation and submit a new reply message.
  • Non-idempotent operation: Server resubmits the reply without repeating the RPC and must store results and acknowledgement messages.
• Client crash: Server does not know, orphaned messages may exist. Solutions include client broadcasts or server timeouts.

Ensuring Liveliness

• Ping: A client repeatedly pings the server to check it is still running.
  • Benefit is it is adaptable to each client's situation, downside is you double the request for the data station.

Asynchronous RPC

• Client proceeds without waiting for an immediate result.
• Acknowledgment expected.
• Server 'directly' acknowledges the receipt of a request message.
• A middleware provides a corresponding synchronization option.

Callback RPC

• Server 'calls the client back' via an RPC request.
• Client provides the server with a binding for the callback RPC.
• Can simulate asynchronous RPCs or pass additional client information.

Context Handles

• Clients and servers may not have shared memory to maintain status.
• Data structure that stores state information between client/server sessions.
• Can be a structured document exchanged between client and server.
• If reference option is not feasible, the context handle can be protected cryptographically.

Remote Method Invocation (RMI)

• An RPC in the context of object-oriented programming languages and remote objects.
• A remote object (distributed object) can be accessed from other objects in another address space.
• RMI allows a call-by-reference for remote objects
• For homogenous systems, server stub can be downloaded or generated by the client.

TCP/IP Model Layers

• Physical Layer (Layer 1): Transmits raw bits over cables or wireless.
• Network Layer (Layer 2): Delivers frames locally using MAC addresses.
• Internet Layer (Layer 3): Routes datagrams using IP addresses to reach the correct destination.
• Transport Layer (Layer 4): Manages segmentation and ensures reliable or fast communication.
• Application Layer (Layer 5): Exchanges messages between applications using protocols like HTTP.