Network Programming: Sockets Overview

TCP Programming Overview

• TCP programming involves creating network connections and sending/receiving data.
• Sockets are used as programming abstractions that represent endpoints of network communications.
• Sockets encapsulate network and transport layer protocols.
• Programs use sockets API to create objects and send/receive data.
• They were developed by Bill Joy for Berkeley UNIX, often referred to as Berkeley(BSD) Sockets.
• Socket programming is used extensively nowadays.

Sockets in Python

• Python's socket module provides functions for creating and managing sockets.
• Python programs use the socket module to create sockets and interact with network protocols, like TCP, UDP, etc.
• The socket object itself acts as a bridge between the application and the network protocol.

Datagram vs. Stream

• Datagram (connectionless): Communication doesn't involve setting up a dedicated connection beforehand. Data is sent as individual packets (datagram/packet) and each message is independent of others.
• Stream (connection-based): Requires establishing a connection, then data is transmitted as a continuous stream. TCP is an example of a stream protocol.

Port Addressing

• Port addresses offer a way to distinguish between different services running on the same host.
• Each network service is associated with a unique port, or range of ports.
• To contact a service, a client needs both the server's IP address and port number.

Port Assignment

• Well-known port numbers are used by internet services to avoid the need for a port directory service.
• Each standard internet application must request a port number from IANA.
• Specific examples of protocols and their assigned ports are available (FTP, SMTP, SNMP, DNS, HTTP).

Stream Sockets

• Detailed process and steps for creating a TCP connection are provided in the form of a diagram.
• A client establishes a connection to a server which starts listening for incoming connections.

TCP Socket Flow

• The diagram illustrates the process for establishing and closing a TCP connection between a client and a server.
• Steps involve connecting, sending, receiving, and closing the TCP connection.

Python Socket Basics

• Python code for creating various socket types and examples are provided in code form.
• socket.socket() is the function used for creating sockets.
• socket.AF_INET and socket.AF_INET6 specify IPv4 and IPv6 addresses, respectively.
• socket.SOCK_STREAM and socket.SOCK_DGRAM denote whether the connection is based on the TCP stream or UDP datagram protocol.

Socket Types

• The way you create sockets in Python is largely determined by the use case
• TCP connections are commonly created using import socket; s = socket.socket(socket.AF_INET,socket.SOCK_STREAM).

Using a Socket

• Creating a socket is the first step.
• The subsequent steps depend on the application type- whether you are acting as a client or a server.
• A server must listen for incoming connections, while a client makes an outgoing connection.

TCP Client

• Python code is provided for creating a TCP client , including connecting to a server, sending a request, receiving a response, and closing the connection.
• Client sends data, the server receives, and sends a reponse back to the client.

TCP Client (Details)

• connect() establishes a connection to a server at a given address.
• send() sends data to the server.
• recv() receives data from the server.
• close() closes the connection.

Socket Functions

• Detailed list of socket functions offered by the socket module.
• Examples of socket() , getaddrinfo(), getfqdn(), gethostname(), and gethostbyaddr()

Socket Functions(additional details)

• getprotobyname(), getservbyname(), getservbyport(), getdefaulttimeout(), setdefaulttimeout(), sethostname()

TCP Server

• Network servers are more complex than clients.
• They need to listen for connections on a pre-determined port.
• Servers often run continuously listening for connections.

TCP Server (Simplified)

• Python code demonstrates how to start a TCP server, listen for connections accept a connection, send hello message and close.

Address Binding

• The server's socket needs to be bound to a specific IP address and port number.
• This allows clients to connect to the server.

Listening for Connection

• Once bound, the server can listen for incoming connections.
• The backlog value specifies the maximum number of clients waiting to connect.

Server Loop & Accept New Connections

• The server uses a loop to handle client connections continuously.
• accept() blocks until a new connection arrives.

Client Socket & Address

• accept() returns the client socket and address.
• The client socket is used for communicating with the client.
• Client addresses include the IP and port number.

Sending Data

• The server uses the client socket to transmit data, sending information back to the client.

Closing the Connection

• The server should close the connection when the service is completed to release resources.
• The server can keep the client connection alive as long as needed, sending and receiving data as necessary.

Wait for the next Connection

• The server loop continuously awaits new connections in a continuous loop, accepting, and handling new client connections.

TCPEchoServer

• Python code for creating an echo server.
• The server listens for incoming connections and echoes back data it receives.

TCPEchoClient

• Python code for creating an echo client.
• The client connects to the echo server and sends data, expecting the echo to be returned.

Advanced Sockets

• Socket programming can be complex.
• There are many possible configurations and error handling needs to be considered.
• Critical issues like partial reads/writes, timeouts, and non-blocking sockets must be handled appropriately.

Partial Reads/Writes

• Reading from or writing to a TCP socket may involve partial read/writes.
• Read/write operations don't always complete in a single step.
• The amount returned or written may be less than the requested max size.

Partial Reads/Writes(advanced)

• The data stream is continuous, no concept of records.
• A lot depends on OS buffers, network bandwidth, and congestion.
• Using sendall() sends entire messages and recv() continues receiving till the entire message is received

Sending All Data

• sendall() ensures all data is sent. This is usually the recommended approach for most normal applications.
• This is particularly crucial when sending larger amounts of data.

End of Data

• Receivers need a mechanism to determine if the sender has closed the connection.
• A recv() operation that returns an empty string signals the end of the connection.

Data Reassembly

• Receivers often receive messages that are a series of small chunks, which require reassembling.
• This template provides a method of reassembling complete messages.

Timeouts

• Sockets can be set to time out after a given amount of time.
• This prevents indefinite blocking if there's a network issue.

Non-blocking Sockets

• Socket operations can be set to be non-blocking.
• This allows for polling for data and dealing with network glitches immediately.

Socket Options

• Sockets have many options, one option is to reuse port number.
• Consult the socket module documentation for more advanced options.

This quiz covers the fundamental concepts of sockets in network programming. It includes the main purposes of sockets, types of sockets for communication, the function of the 'sendall' method, and the significance of port addressing. Additionally, it addresses the valid port number ranges for both UDP and TCP protocols.