Distributed Programming Concepts

Computers communicate by sending network messages.

Programs send and receive messages using sockets.

One electrical circuit for each communication, like a phone call.

Messages divided into packets sent independently, like email.

The fundamental way computers exchange data through networks.

A unique numerical label assigned to each device on a network, like a house address for a computer.

A human-readable name that maps to an IP address, like a website's address.

Domain Name System, a distributed database that translates domain names to IP addresses.

A function in programming that converts a domain name into its corresponding IP address.

A data structure used to hold information related to a resolved host, including the IP address, aliases, and more.

A list of IP addresses associated with a specific host, often containing multiple addresses.

A function that converts a numerical IP address (in network byte order) into a printable string format.

gethostbyname() converts a domain name into its corresponding IP address by querying the Domain Name System (DNS). It returns a struct hostent containing information about the host, including its IP address and other related data.

TCP limits the number of connections waiting to be accepted, preventing a server from being overwhelmed by too many requests.

In TCP, a client starts a connection by using the connect() function to attempt to establish a communication link with a server.

The connect() function in TCP is used by a client to initiate a connection with a server. It takes the socket descriptor, server address, and address length as input.

TCP servers use the accept() function to wait for incoming connection requests from clients. When a request arrives, accept() creates a new socket for communication.

The accept() function in TCP is used by a server to accept an incoming connection from a client. It takes the socket descriptor, client address, and address length as input, and creates a new socket for that connection.

TCP communication involves two types of sockets: a server socket and a client socket. The server socket listens for connections, and the client socket initiates connections.

The listen() function in TCP is used by a server to prepare the server socket for accepting incoming connections. It takes as input the server socket descriptor and the maximum number of pending connections.

TCP connections are broken down into two stages: 1) the connect() function initializes a connection attempt by the client, and 2) the accept() function on the server side creates a new socket for communication.

TCP (Transmission Control Protocol) is a reliable, connection-oriented protocol that ensures data delivery in order. It uses a three-way handshake to establish a connection, handles data segmentation, and provides error checking. This protocol is central to many common internet applications, ensuring smooth and consistent communication.

Common protocols using TCP include: TELNET (remote login), FTP (file transfer), SMTP (email), HTTP (web), and SSH (secure shell). These protocols rely on TCP for reliable, ordered data delivery, making them suitable for various applications like web browsing, file sharing, and email communication.

The socket() function creates a socket object. This object represents a communication endpoint that can be used for sending and receiving data through TCP or other protocols.

The bind() function assigns a specific address and port to the created socket. This allows the server socket to accept incoming connections on that designated address and port.

A server socket is a TCP socket configured to receive and handle incoming connections. It establishes connections with clients using the three-way handshake and manages multiple client connections simultaneously. This role allows server applications to provide services to multiple clients.

The listen() function converts a client socket into a server socket, enabling it to accept incoming connections. It specifies the maximum number of pending connections that the server can handle at once.

The backlog parameter in listen() controls the maximum number of incoming connection requests that can be queued while waiting for the server to accept them. This parameter influences how promptly the server responds to incoming connections.

The listen() function returns 0 for successful execution, indicating that the socket has been designated as a server socket. A return value of -1 signifies an error during the process.

A function that waits for an incoming connection attempt from a client, and establishes a new socket connection if successful. It's used in server-side applications to accept incoming connections.

The new socket descriptor returned by accept() to represent the newly established connection between the server and the client.

A function that sends data to a socket. It's similar to writing data to a file, but instead of writing to a file, it's writing to a network connection.

When write() is called, it tries to send all the data in the buffer. However, if there's not enough space in the kernel's internal buffers, write() might only send a portion of the data. It returns the number of bytes actually sent, so you should check the return value and re-send any remaining data.

When read() returns 0, it indicates that the end of the data stream has been reached. It's like the other end of the connection has closed or stopped sending data.

Like write(), read() might only return the data already received from the socket. This doesn't mean the data stream is finished; there might be more data coming. You need to keep reading until read() returns 0 to indicate EOF.

The close() function is used to stop sending data to a TCP socket. It sends an EOF message to the other party, signaling the end of the connection. When the receiving party receives an EOF, read() returns 0 bytes, indicating the data stream is closed. Any subsequent read or write operations will then result in errors.

The close() function sends an EOF (End of File) message to the other end of the TCP connection, signaling that the sender has finished transmitting data. This message is usually received by the read() function on the receiving end, which then returns 0 bytes. Any subsequent read or write operations will then result in errors.

The shutdown() function allows you to partially close a TCP connection. You can choose to stop sending data (using SHUT_WR), stop receiving data (using SHUT_RD), or both. This enables you to gracefully end a connection while allowing the other party to finish sending or receiving data.

The SHUT_WR argument used with the shutdown() function instructs the TCP socket to stop sending data. This allows the other party to continue receiving data, potentially finishing any ongoing operations, until the connection is fully closed by the other party.

The SHUT_RD argument used with the shutdown() function instructs the TCP socket to stop receiving data. This allows the program to continue sending data, until the connection is fully closed by the other party.

I/O Multiplexing allows a program to handle multiple file descriptors (representing different connections) simultaneously. It provides a mechanism to efficiently wait for events (like incoming data or connections) on multiple sockets, without blocking the program for each individual socket. This helps to improve the application's efficiency and responsiveness.

There are several methods to deal with multiple file descriptors, each with its advantages and drawbacks: 1) Multiple Processes: Each process handles a separate file descriptor, but is resource-intensive. 2) Non-Blocking I/O: Programs can perform read operations without waiting, but it doesn't work for accept() functions. 3) select(): Blocks the program until one of the descriptors is ready, providing flexible monitoring. 4) poll(): Similar to select() but with additional information about the streams.

While using multiple processes to handle each file descriptor can be done, it tends to consume significant system resources, including memory and processor time. It also adds complexity to the program logic, making it harder to manage and debug. As a result, other methods like I/O Multiplexing are often preferred for their efficiency and scalability.