Review. Preview. Closing a TCP Connection. Closing a TCP Connection. Port Numbers 11/27/2017. Packet Exchange for TCP Connection

Transcription

1 Review Preview Algorithms and Issues in Client Software Design Client Architecture Identifying the Location of a Parsing an Address Argument Looking Up a Domain Name Looking Up a Well-Known Port by Name The TCP Algorithm Allocating a Socket by socket() system Call Choosing a Local Protocol Port Number Connecting a TCP Socket to a by connect() Call Closing a TCP connection Packet Exchange for TCP Connection Port Numbers Port Number and Concurrent TCP output Elementary Functions for TCP Socket The socket() function The connect() function The bind() function The listen() function The accept() function The function 1 2 Closing a TCP Connection Closing a TCP Connection To terminate TCP connection, need send and receive two segments between peers ( and ). 1. One application calls close (active close), and send a FIN segment.(usually ) 2. The other end TCP (receives the FIN segment) performs the passive close. Send FIN to application (that cause close socket) and send ACK to sender s TCP. 3. Sometimes later, application close socket, it causes its TCP send a FIN. 4. A pear received the final FIN send ACK to peer Close (active close) Read return 0 (passive close) close 3 4 Packet Exchange for TCP Connection Port Numbers socket(), connect() connect() return returns ACK K+1 ACK for reply socket(), bind(), listen() accept() Connection Established returns When a want to connect to a, the must identify the with a specific service request. TCP, UDP, SCTP defines a group of well known ports to identify well-known service. (ex FTP: 20 (data), 21 (control) All three transport layers (TCP, UDP, SCTP) use 16 bit port numbers. A does not need care about port number for itself. A use a unique ephemeral port number on the host provided by system. The IANA (Internet Assigned Numbers Authority) maintains a list of port number. ACK N+1 Connection Close 5 6 1

2 Port Numbers The Port numbers (0 ~ )are divided into three ranges. 0~1023 : controlled and assigned by IANA (RFC 1700) 1024 ~ 49151: not controlled by IANA but needed to be registered for specific. Ex) port 6000 ~ 6003 : for window XP ~ 65535: Dynamic ephemeral ports A concurrent must be able to serve more than one at a time. A concurrent create a child to take care of each. TCP can distinguish each child process in site with IP, ephemeral port number and service port number. 7 8 Socket pair information (IP:port, IP: port) Listening socket Connection request to Port 21 (, : 1500) Listening socket (: (, : 1500) Listening socket ( :1500 (, : 1500) Listening socket (:1501 (, : 1500) (:1500 (, : 1501) (:

3 TCP Output TCP Output Every TCP socket has a send buffer, the size of buffer can be changed with the SO_SNDBUF socket option. When application calls write, the kernel copies all the data from the application buffer into the socket send buffer. If there is no sufficient space in the socket buffer, the process change state to block state until enough space become available. The kernel will not return from the write until the entire data copy from application buffer to socket buffer. application TCP IP datalink Application buffer write() User process kernel Socket send buffer MSS sized TCP segment IPv4 or IPv6 packets TCP Output TCP TCP socket() TCP sends the data to IP in MSS-sized (or smaller) chucks prepending its TCP header for each segment. IP prepends IP header and search routing table to the destination IP address and passes data to datalink layer socket() connect() Connection established by TCP three-way handshake bind() listen() accept() The socket() Function int socket(int family, int type, int protocol); Return socket descriptor number if Ok, -1 error To create a socket, we call the socket function. The socket() function return a file descriptor that can be used in later function calls that operate on sockets. The family argument determines the nature of the communication. AF_INET : IPv4 Internet domain AF_INET6 : IPv9 Internet domain AF_LOCAL :Unix domain protocol AF_UNIX : Unix domain protocol AF_UNSPEC: the domain is not specified. The socket() Function int socket(int family, int type, int protocol); Return socket descriptor number if Ok, -1 error The type argument determines the type of the socket. SOCK_STREAM: stream socket (TCP) SOCK_DGRAM: datagram socket (UDP) SOCK_RAM: raw socket SOCK_SEQPACKET: sequined packet socket (SCTP) The protocol argument is usually 0, to select the default protocol type. When multiple protocols are supported for the same domain and socket type, we can use the protocol argument to select a particular protocol

4 socket() Function int socket(int family, int type, int protocol); Return socket descriptor number if Ok, -1 error The protocol argument is usually 0, to select the default protocol type. When multiple protocols are supported for the same domain and socket type, we can use the protocol argument to select a particular protocol. IPPROTO_TCP: TCP transport protocol IPPROTO_UDP: UDP transport protocol IPPROTO_SCTP: SCTP transport protocol socket() Function Not all combinations of socket family and type are valid. AF_INET AF_INET6 AF_LOCAL AF_ROUTE AF_KEY SOCK_STREAM O O O SOCK_DGRAM O O O SOCK_SEQPACKET O O O SOCK_RAW O O O O AF_ vs. PF_ AF_: Stand for address family Used in socket address structure PF_: Stand for protocol family Used to create a socket 21 The connect() Function #include <sys/types.h> int connect(int sockfd, const struct sockaddr *servaddr, socklen_t addrlen); The connect function is used by a TCP to establish a connection with a TCP. Since the s kernel choose both an ephemeral port number and source IP address, the socket does not need bind before connect For a TCP socket, the connect() initiates TCP s three-way handshake. sockfd is a socket descriptor returned by socket() servaddr is a pointer to socket address structure contains the IP address and port number addrlen is size of socket address connect() returns only when the connection is established or an error occurs. Return 0 if OK, -1 on error 22 The connect() Function The connect() Function socket(), connect() connect returns socket() bind() listen() (Passive Mode) accept() Different errors for connect() The TCP receive no response to SYN, ETIMEOUT is returned. Some system (4.4BSD) send one SYN, and another 6 second later, and 24 second later. If no response is received, the error returned. If the s response to the s SYN is a RST (reset sent by other side of kernel), this indicate that no process is waiting for connection on the at the port specified (hard error). If the SYN cannot reach to destination (soft error), intermediate router send ICMP. The kernel save the message and keep sending SYN. If it is not able to reach after fixed amount of time, return EHOSTUNREACH or ENETUNREACH

5 int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen); Return 0 if OK, -l on error int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen); Return 0 if OK, -l on error The bind() function assigns a local protocol address to a socket. The bind() function is usually used in a The local address is the combination of either 32bit (IPv4) or 128 bits (IPv6) IP address, along with a 16 bit port number. sockfd is a socket descriptor returned by socket() myaddr is a pointer to a protocol-specific socket address structure. addrlen is size of socket address With TCP, calling bind() lets us specify a port number and IP address or neither. s bind their well-known port number when they start. But, if a TCP or does not specify a port number, kernel choose an ephemeral port number for the socket when either connect or listen is called. It is unusual for a. A process can bind a specific IP to its socket. The IP address must belong to an interface on the host. For a TCP, this IP assigns the source IP address that will be used for IP datagram sent on the socket. For a TCP, this restricts the socket to receive incoming connections destined only to that IP address int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen); Return 0 if OK, -l on error Normally, a TCP does not bind and IP address to its socket. Instead, the kernel chooses the source IP address when the socket is connected, based on the outgoing interface that is used, which intern is based on the route required to reach the. If a TCP does not bind an IP address to its socket, the kernel use the destination IP address of the s SYN as the s source IP address. Process Specified IP address Port number Wild Card 0 Wild Card Nonzero 0 Nonzero Result Kernel choose IP and Port Kernel choose IP and process specifies Port Process specifies IP and kernel choose Port Process specifies IP and Port If we specify a port number of 0 kernel chooses an ephemeral port when bind() is called. But if we specify a wild card IP address, the kernel does not choose the local IP address until either the socket is connected (TCP) or a data is sent on the socket(udp) Process Specified IP address Port number Wildcard 0 Wildcard Nonzero 0 Nonzero Result Kernel choose IP and Port Kernel choose IP and process specifies Port Process specifies IP and kernel choose Port Process specifies IP and Port Process Specified IP address Port number Wildcard 0 Wildcard Nonzero 0 Nonzero Result Kernel choose IP and Port Kernel choose IP and process specifies Port Process specifies IP and kernel choose Port Process specifies IP and Port With IPv4 (32 bit), the wildcard is specified by the constant INADDR_ANY by kernel With IPv6 (128 bit), the wildcard is specified by the constant INADDR_ANY by kernel struct sockaddr_in servaddr /*clear struct sokaddr_in for */ bzero(&servaddr, sizeof(servaddr)); /* allow s to connect using any one of the host's IP addresses */ servaddr.sin_addr.s_addr = htonl(inaddr_any); struct sockaddr_in6 servaddr /*clear struct sokaddr_in for */ bzero(&servaddr, sizeof(servaddr)); /* allow s to connect using any one of the host's IP addresses */ servaddr.sin_addr.s_addr = in6addr_any;

6 #define SA struct sockaddr /* generic socket address */ int listenfd; /* socket scriptor numberr*/ struct sockaddr_in servaddr; /* for address */ /*create a socket for using IPv4 with TCP */ listenfd = socket(af_inet, SOCK_STREAM, 0); /*clear struct sokaddr_in for */ bzero(&servaddr, sizeof(servaddr)); /* use IPv4 */ servaddr.sin_family = AF_INET; /* allow s to connect using any one of the host's IP addresses */ servaddr.sin_addr.s_addr = htonl(inaddr_any); /* set port as htons function format port number to short*/ servaddr.sin_port = htons(1313); /* bind a space for request */ bind(listenfd, (SA *) &servaddr, sizeof(servaddr)); int listen(int sockfd, int backlog); Return 0 if OK, -1 on error The listen function is called only by a TCP and it performs two actions. The listen() function converts an unconnected socket into a passive socket (prepared by ), indicating that the kernel should accept incoming connection requests directed to this socket. The second argument specifies the maximum number of connections the kernel should queue for this socket int listen(int sockfd, int backlog); Return 0 if OK, -1 on error connect() called The kernel maintain two queues for a given listening socket. An incomplete connection queue: contains an entry for each SYN that has arrived from a for which the is waiting completion of the TCP three-way handshake. A complete connection queue: contains an entry for each with whom the TCP three-way handshake has completed. connect returns Create entry on incomplete queue Entry moved from incomplete queue to completed queue, accept can return The accept() Function When SYN J arrive from a, TCP kernel create a new entry on the incomplete queue. And then send ACK J+1 and SYN K. When ACK K+1 arrive from the (three-way handshake complete), the entry from incomplete queue to complete queue. When the process calls accept(), the first entry on the completed queue is returned to the process or if queue is empty, the process is put to sleep until an entry is placed onto the complete queue. int accept(int sockfd, const struct sockaddr *cliaddr, socklen_t *addrlen); Return non-negative descriptor if OK, -1 on error The accept is called by a TCP to return the next complete connection from the front of the completed connection queue. If the queue is empty, the process is put to sleep (block state). If accept() is successful, it returns a new scripter. This scripter refers to the TCP connection with the

7 The Function #include <unistd.h> int close(int sockdes); /* return 0 for OK, -1 for error */ Probably one of the easiest things to do with a socket, is close it. This is done using closes the socket descriptor indicated by sockets. 37 7