Introduction CPSC-313: to Computer Systems
Networking Programming
Network Programming
Network Programming as Programming across Machine Boundaries The Sockets API Reliable Communication Channels: TCP Dangerous at any Speed; connectionless communication and UDP Server Design Reading: R&R, Ch 18
Naming in a Networked Environment
Reminder: Naming within a single address space? addresses, duh! Naming across address spaces? file descriptors filenames (use file system as name space) keys New: Naming across machine boundaries?
CPSC-313: Introduction to Computer Systems
Networking Programming
Naming in a Networked Environment (II)
what? how? who? where?
sshd telnet server HTTP 1.1
TCP
UDP
httpd web server
lpd printer server
hostX.cs.tamu.edu 128.144.xxx.yyy
Protocols for a Networked Environment
HTTP 1.1
application layer
UDP
TCP
sshd telnet server
httpd web server
lpd printer server
transport layer
hostX.cs.tamu.edu 128.144.xxx.yyy
network layer
link layer physical layer
CPSC-313: Introduction to Computer Systems
Networking Programming
The Socket API
What does an API need to support? [Comer&Stevens] allocate local resources (buffers) specify local and remote communication endpoints initiate a connection wait for an incoming connection send or receive data determine when data arrives generate urgent data handle incoming urgent data terminate a connection gracefully handle connection termination from the remote site abort communication handle error conditions or a connection abort release local resources when communication finishes
Existing TCP/IP APIs: Berkeley Socket API aka socket API, socket interface, sockets adapted by Linux and others Windows Sockets System V Unix TLI (Transport Layer Interface)
Specifying a Protocol Interface
Reality Check: All networks today are based on TCP/IP. How to define a network API, then?! Approach 1: Define functions that specifically support TCP/IP communication. e.g. makeTCPconnection(int32 host, int16 portno); Approach 2: Define functions that support network communication in general, and use parameters to handle TCP/IP as a special case.
The socket API provides generalized functions that support network communication using many possible protocols. The programmer specifies the type of service required rather than the name of a specific network protocol.
CPSC-313: Introduction to Computer Systems
Networking Programming
Sockets and File Descriptors
#include <sys/socket.h> int socket(int family, int type, int protocol) /* creates communication endpoint and returns file descriptor. */ internal data structure for file 0 internal data structure for file 1 internal data structure for file 2 internal data structure for file 3
family: AF_INET service: SOCK_STREAM local IP: remote IP: local port: remote port: ...
file descriptor table
[0] [1] [2] [3] [4]
newsocket 4
user space kernel space
Create new Socket Descriptor: int newsocket; newsocket = socket(AF_INET, SOCK_STREAM, 0);
TCP? UDP?!!
Connection-oriented Style (SOCK_STREAM) of communication Implemented in TCP/IP as the Transport Control Protocol (TCP). TCP provides full reliability: verifies that data arrives, with automatic retransmission computes checksums to detect corruption uses sequence numbers to guarantee ordering of received packets automatically eliminates duplicated packets provides flow control (ensures that sender does not send more packets than the receiver can handle) informs sender if network becomes inoperable for any reason TCP protects network resources: provides congestion control (throttles transmission when it detects that network is congested) What is the cost of all this?! Connection establishment overhead.
CPSC-313: Introduction to Computer Systems
Networking Programming
TCP? UDP?!!
Connectionless Style (SOCK_DGRAM) of communication Implemented in TCP/IP as the User Datagram Protocol (UDP). UDP provides no guarantee about reliable delivery: packets can be lost, duplicated, delayed, or delivered out of order UDP works well if the underlying network works well, e.g. local network In practice, programmers use UDP only when: 1. The application requires that UDP must be used. (The application has been designed to handle reliability and delivery errors.) 2. The application relies on hardware broadcast or multicast for delivery. 3. Application runs in reliable, local environment, and overhead for reliability is unnecessary.
The Sockets Local Address
#include <sys/socket.h> int socket(int family, int type, int protocol) /* creates communication endpoint and returns file descriptor. */ internal data structure for file 0 internal data structure for file 1 internal data structure for file 2 internal data structure for file 3
family: AF_INET service: SOCK_STREAM local IP: remote IP: local port: remote port: ...
file descriptor table
[0] [1] [2] [3] [4]
newsocket 4
user space kernel space
Create new Socket Descriptor: int newsocket; newsocket = socket(AF_INET, SOCK_STREAM, 0);
CPSC-313: Introduction to Computer Systems
Networking Programming
Defining the Sockets Local Address (server)
#include <sys/socket.h> int bind( int socket, const struct sockaddr * address, socketlen_t address_len); /* associates socket file descriptor with communication endpoint address. */
Generalized socket address:
(address family, endpoint address in that family)
Examples: Address family AF_UNIX has named pipes. Endpoint address of named pipes? Socket Addresses in AF_INET? struct sockaddr_in { u_char sin_len; u_short sin_family; u_short sin_port; struct in_addr sin_addr; char }; struct to hold an address */ total length */ type of address */ protocol port number */ IP address (declared to be*/ u_long in some systems) */ sin_zero[8]; /* unused (set to zero) */ /* /* /* /* /*
Host vs. Network Byte Order
Big-endian vs. Little-endian. Network representation requires big-endian. Portability?!
#include <arpa/inet.h> uint32_t uint32_t uint16_t uint16_t htonl(uint32_t ntohl(uint32_t htons(uint16_t ntohs(uint16_t hostlong); netlong); hostshort); netshort);
Associate port 8652 with a socket: struct sockaddr_in server;
int sock = socket(AF_INET, SOCK_STREAM, 0); server.sin_family = AF_INET; server.sin_addr.s_addr = htonl(INADDR_ANY); server.sin_port = htons((short)8652); bind(sock, &server, sizeof(server));
CPSC-313: Introduction to Computer Systems
Networking Programming
Prepare to Accept Incoming Connections
#include <sys/socket.h>
(server)
int listen(int socket, int backlog); /* specify willingness to accept incoming connections at given socket, with given queue limit. Connections are then accepted with accept(). */ When request for connection from client comes in, both client and server execute hand-shake procedure to set up the connection. When server is busy, two things can happen Connection request is queued (as long as backlog not exceeded) or Connection request is refused (client receives ECONNREFUSED error)
Handle Incoming Connections
#include <sys/socket.h>
(server)
int accept(int socket, struct sockaddr * address, socklen_t * address_len); /* Accept a connection on a socket. Create a new socket with same properties of socket and return new file descriptor. */ Extract first connection request on queue of pending connections. Create new socket with same properties of given socket. Returns new file descriptor for the socket. Blocks caller if no pending connections are present in queue. New socket may not be used to accept more connections. Original socket socket remains open. Argument address (result parameter) is filled in with the address of connecting entity. Argument address_len (value-result parameter) initially contains length of space pointed to by address. On return it contains length of actual length of space.
CPSC-313: Introduction to Computer Systems
Networking Programming
In the meantime, at the Clients End
#include <sys/socket.h> int connect(int socket, struct sockaddr * address, socklen_t address_len); /* Initiate a connection on a socket. Structure address specifies the other endpoint of the connection. */ Note difference between SOCK_DGRAM and SOCK_STREAM sockets:
(client)
For SOCK_STREAM sockets, connect attempts to establish connection with other socket. Generally, stream sockets may connect only once. For SOCK_DGRAM sockets, connect specifies the peer with which to associate socket. Datagram sockets may dissolve association by connecting to invalid address, such as null address. For address, fill in family, address, and port number.
Connection Establishment: Summary
client
socket()
server
socket() bind() listen()
connect() read() / write() close()
accept() read() / write() close()
CPSC-313: Introduction to Computer Systems
Networking Programming
Addressing: IP Address vs. Dotted vs. Name
Internet Address Dot Notation #include <arpa/inet.h> in_addr_t inet_addr(char * cp); /* return IP address from dot notation.*/ char * inet_ntoa(struct in); in_addr /* return dot notation from IP address */ Internal conversion
128.10.2.3
IP Address (IPv4) <some 32 bit number>
Host name resolution using Domain Name Service (DNS) Host Name
#include <netdb.h>
merlin.cs.purdue.edu
struct hostent * gethostbyname(char * name); struct hostent * gethostbyaddr(void * addr, socklen_t len, int type); /* return info about names and addresses */
Host Names and IP Addresses
Host Information: #include <netdb.h> struct hostent { char * h_name; char ** h_aliases; int h_addrtype; int h_length; char ** h_addr_list; } /* /* /* /* /* canonical name of alias list */ host address type length of address list of addresses host */ */ */ */
Example: Translate a host name into IP address for use in connect() call: struct hostent * hp; struct sockaddr_in the_server; if ((hp = gethostbyname(www.cs.tamu.edu)) == NULL) fprintf(stderr, Failed to resolve host name\n); else memcpy((char*)&the_server.sin_addr.s_addr, hp->h_addr_list[0], hp->h_length);
CPSC-313: Introduction to Computer Systems
Networking Programming
Example TCP Client: DAYTIME client [Comer]
#define LINELEN 128 /* forward */ int connectTCP(const char * host, const char * service); /* main program */ int main(argc, char * argv) { char * host = localhost;/* use local host if none supplied */ char * service = daytime; /* default service port */ if (argc > 1) host = argv[1]; if (argc > 2) service = argv[2]; int s = connectTCP(host, service); while ( (int n = read(s, buf, LINELEN)) > 0) { buf[n] = \0; /* ensure null terminated */ (void) fputs(buf, stdout); } }
Example TCP Client: (cont)
#define LINELEN 128 /* forward */struct sockaddr_in sin; /* Internet endpoint address */ memset(&sin, 0, sizeof(sin)); int connectTCP(const char * host, const char * service);
sin.sin_family = AF_INET; int connectTCP(const char * host , const char * service) {
/* main program Map service name to port number */ */ /* int main(argc, char * argv) {* pse = getservbyname(service, tcp) ) if (struct servent char * hostelse if localhost;/* htons((unsigned short)atoi(service))) */ 0) = ((sin.sin_port = use local host if none supplied == char * service errexit(cant get <%s> service entry\n, service); = daytime; /* default service port */ if (argc > 1) host = argv[1]; if (struct hostent * phe = gethostbyname(host) ) if (argc > 2) service = argv[2]; phe->h_addr, phe->h_length); memcpy(&sin.sin_addr, int s = connectTCP(host, service); host entry\n, host); errexit(cant get <%s>
/* Map host name to IP address, allowing for dotted decimal */ else if ( (sin.sin_addr.s_addr = inet_addr(host)) == INADDR_NONE ) sin.sin_port = pse->s_port;
}
/* Allocate socket */ while ( (int n = read(s, buf, LINELEN)) > 0) { int s = socket(AF_INET, SOCK_STREAM, 0); buf[n] = if (s < 0) errexit(cant create socket: terminated */ \0; /* ensure null %s\n, strerror(errno)); (void) fputs(buf, stdout); } /* Connect the socket */ if (connect(s, (struct sockaddr *)&sin, sizeof(sin)) < 0) errexit(cant connect to %s.%s: %s\n, host, service, strerror(errno)); return s; }
CPSC-313: Introduction to Computer Systems
Networking Programming
Server Software Design: Issues
[Comer]
Concurrent vs. Iterative Servers: The term concurrent server refers to whether the server permits multiple requests to proceed concurrently, not to whether the underlying implementation uses multiple, concurrent threads of execution. Iterative server implementations are easier to build and understand, but may result in poor performance because they make clients wait for service. Connection-Oriented vs. Connectionless Access: Connection-oriented (TCP, typically) servers are easier to implement, but have resources bound to connections. Reliable communication over UDP is not easy! Stateful vs. Stateless Servers: How much information should the server maintain about clients? (What if clients crash, and server does not know?)
Example: Iterative, Connection-Oriented Server
int passiveTCPsock(const char * service, int backlog) {
server
socket() bind() listen() accept() read() / write() close()
struct sockaddr_in sin; /* Internet endpoint address */ memset(&sin, 0, sizeof(sin)); /* Zero out address */ sin.sin_family = AF_INET; sin.sin_addr.s_addr = INADDR_ANY; /* Map service name to port number */ if (struct servent * pse = getservbyname(service, tcp) ) sin.sin_port = pse->s_port; else if ((sin.sin_port = htons((unsigned short)atoi(service))) == 0) errexit(cant get <%s> service entry\n, service); /* Allocate socket */ int s = socket(AF_INET, SOCK_STREAM, 0); if (s < 0) errexit(cant create socket: %s\n, strerror(errno)); /* Bind the socket */ if (bind(s, (struct sockaddr *)&sin, sizeof(sin)) < 0) errexit(cant bind to \n); /* Listen on socket */ if (listen(s, backlog) < 0) errexit(cant listen on \n) return s; }
CPSC-313: Introduction to Computer Systems
Networking Programming
Example: Iterative, Connection-Oriented Server
server
socket() bind() listen() accept() read() / write() close()
} } int main(int argc, char * argv[]) { char * service = daytime; /* service name or port number */ int m_sock, s_sock; /* master and slave socket */ service = argv[1]; int m_sock = passiveTCPsock(service, 32); for (;;) { s_sock = accept(m_sock,(struct sockaddr*)&fsin, sizeof(fsin)); if (s_sock < 0) errexit(accept failed: %s\n, strerror(errno)); time_t ...