Embed Size (px)
Citation preview
Ipv4 Socket Address Structure
struct in_addr { in_addr_t s_addr; /* 32-bit IPv4 address */
/* network byte ordered */ };
struct sockaddr_in { uint8_t sin_len; /* length of structure (16) */ sa_family_t sin_family; /* AF_INET */ in_port_t sin_port; /* 16-bit TCP/UDP port number
*/ /* network byte ordered */ struct in_addr sin_addr; /* 32-bit IPv4 address */
/*network byte ordered*/ char sin_zero[8]; /* unused */ };
data structure – not exchanged between hosts<netinet/in.h>
struct in_addr { in_addr_t s_addr; /* 32-bit IPv4 address */
/* network byte ordered */ };
struct sockaddr_in { uint8_t sin_len; /* length of structure (16) */ sa_family_t sin_family; /* AF_INET */ in_port_t sin_port; /* 16-bit TCP/UDP port number
*/ /* network byte ordered */ struct in_addr sin_addr; /* 32-bit IPv4 address */
/*network byte ordered*/ char sin_zero[8]; /* unused */ };
Generic Socket Address Structure Passed as reference Prior to void definition
Generic Socket Address Structure
int bind(int, struct sockaddr *, sock_len_t);
Ipv6 Socket Address Structure
struct in6_addr { uint8_t s6_addr[16]; /* 128-bit IPv6 address */
/* network byte ordered */ };
#define SIN6_LEN /* required for compile-time tests */
struct sockaddr_in6 { uint8_t sin6_len; /* length of this struct (28) */ sa_family_t sin6_family; /* AF_INET6 */ in_port_t sin6_port; /* transport layer port# */
/* network byte ordered */ uint32_t sin6_flowinfo; /* flow information, undefined */ struct in6_addr sin6_addr; /* IPv6 address */
/* network byte ordered */ uint32_t sin6_scope_id; /* set of interfaces for a scope */ };
Value-Results arguments bind, connect, sento
Value-Result arguments Kernel to the process, size can change accept, recvfrom, getsockname,
getpeername
Fixed size data structure Kernel informs how
much information was
stored
Socket Address Structures
Byte ordering functions
Internet Protocols
Network byte order → big-endian TCP Port: 16 bits Ipv4 address: 32 bits
# include <netinet/in.h>uint16_t htons(uint16_t host16bitvalue) ;uint32_t htonl(uint32_t host32bitvalue) ;
Both return: value in network byte order
uint16_t ntohs(uint16_t net16bitvalue) ;uint32_t ntohl(uint32_t net32bitvalue) ;
Both return: value in host byte order
Byte manipulation function
Operates on multibyte fileds, without interpreting the data, and without asuming that the data is a null-terminated C string
bzero, bcopy, bcmp memset, memcpy, memcmp
Address convertion function
Converts an ASCII string into network byte ordered binary values
#include <arpa/inet.h>
int inet_aton(const char *strptr, struct in_addr *addrptr);Returns: 1 if string was valid, 0 on error
in_addr_t inet_addr(const char *strptr);Returns: 32-bit binary network byte ordered IPv4 address;
INADDR_NONE if error
char *inet_ntoa(struct in_addr inaddr);Returns: pointer to dotted-decimal string
Address convertion function
read, write
It may read/write less than needed due to finite buffer → call function
Only if write is nonblocking
read, writelib/readn.c 1 #include "unp.h" 2 ssize_t /* Read "n" bytes from a descriptor. */ 3 readn(int fd, void *vptr, size_t n) 4 { 5 size_t nleft; 6 ssize_t nread; 7 char *ptr; 8 ptr = vptr; 9 nleft = n; 10 while (nleft > 0) { 11 if ( (nread = read(fd, ptr, nleft)) < 0) { 12 if (errno == EINTR) 13 nread = 0; /* and call read() again */ 14 else 15 return (-1); 16 } else if (nread == 0) 17 break; /* EOF */ 18 nleft -= nread; 19 ptr += nread; 20 } 21 return (n - nleft); /* return >= 0 */ 22 }
read, writelib/writen.c1 #include "unp.h" 2 ssize_t /* Write "n" bytes to a descriptor. */ 3 writen(int fd, const void *vptr, size_t n) 4 { 5 size_t nleft; 6 ssize_t nwritten; 7 const char *ptr; 8 ptr = vptr; 9 nleft = n; 10 while (nleft > 0) { 11 if ( (nwritten = write(fd, ptr, nleft)) <= 0) { 12 if (nwritten < 0 && errno == EINTR) 13 nwritten = 0; /* and call write() again */ 14 else 15 return (-1); /* error */ 16 } 17 nleft -= nwritten; 18 ptr += nwritten; 19 } 20 return (n); 21 }
read, write1 # include "unp.h" 2 static int read_cnt; 3 static char *read_ptr; 4 static char read_buf[MAXLINE]; 5 static ssize_t 6 my_read(int fd, char *ptr) 7 { 8 if (read_cnt <= 0) { 9 again: 10 if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) { 11 if (errno == EINTR) 12 goto again; 13 return (-1); 14 } else if (read_cnt == 0) 15 return (0); 16 read_ptr = read_buf; 17 } 18 read_cnt--; 19 *ptr = *read_ptr++; 20 return (1); 21 }
22 ssize_t 23 readline(int fd, void *vptr, size_t maxlen) 24 { 25 ssize_t n, rc; 26 char c, *ptr; 27 ptr = vptr; 28 for (n = 1; n < maxlen; n++) { 29 if ( (rc = my_read(fd, &c)) == 1) { 30 *ptr++ = c; 31 if (c == '\n') 32 break; /* newline is stored, like fgets() */ 33 } else if (rc == 0) { 34 *ptr = 0; 35 return (n - 1); /* EOF, n - 1 bytes were read */ 36 } else 37 return (-1); /* error, errno set by read() */ 38 } 39 *ptr = 0; /* null terminate like fgets() */ 40 return (n); 41 } 42 ssize_t 43 readlinebuf(void **vptrptr) 44 { 45 if (read_cnt) 46 *vptrptr = read_ptr; 47 return (read_cnt); 48 }
read, write
isfdtype It checks whether the descriptor is a socket
descriptor
Socket functions for elementary TCP client-server
The socket API
Function socket
int socket ( int family, int type, int protocol) return > 0 if OK, -1 if error
Returns socket descriptor (small positive integer), similar to UNIX file descriptor, to be used perform functions on the socket such as read, write and close
socket
#include <sys/socket.h>
int socket (int family, int type, int protocol);Returns: non-negative descriptor if OK, -1 on error
Socket Function
Parameters:
family: specifies the protocol family:
AF_INET – for IPv4
AF_INET6 – for IPv6
AF_UNIX ou AF_LOCAL - Unix domain socket
type: specifies transport protocol:
SOCK_STREAM: stream socket for TCP
SOCK_DGRAM: datagram socket for UDP
protocol: usually set to zero
Combination of interest
Family Type
AF_INET SOCK_STREAM SOCK_DGRAM
AF_UNIX SOCK_STREAM SOCK_DGRAM
Exemple: sockfd = socket(AF_INET, SOCK_STREAM, 0),
creates an IPv4 socket to be used by TCP
socket Function
int connect ( int sockfd, const struct sockaddr *servaddr, int addrlen)
return 0 if OK, -1 if error, Used for establishing a connection:three-way
handshake sockfd: return parameter of socket() servaddr: data structure initiated with remote socket
identifications (remote IP address, remote port number) For a client TCP, it is not necessary to perform bind: the
kernel chooses the local port ephemeral port number and the source IP number if necessary
Chosen in a way to avoid conflict of use of port number
Connect Function
connect
errors timeout – erro ETIMEDOUT, 75 seconds,
configurable If the answer to a SYN segment is an RST one
– error ECONNREFUSED – no process listening to the port
Destination unreachable (ICMP), soft error, tries for 75 seconds (4.4 BSD)
#include <sys/socket.h>
int connect(int sockfd, const struct sockaddr *servaddr, socklen_t addrlen);Returns: 0 if OK, -1 on error
int bind(int sockfd, (struct sockaddr)* myaddr, int socklen)
return 0 if OK, -1 if error
bind a local protocol address given by the structure myaddr to a socket (sockfd)
The application can let the kernel chooses the IP address and the port number;
Bind Function
If a host has more than one IP, then the kernel can choose one
Ephemeral port numbers are chosen to avoid conflict with other socket
To let the kernel chooses the IP address the constant INADDR_ANY should be assigned to the IP address myaddr
To let the kernel chooses an ephemeral port number the constant zero should be set to the corresponding field of myaddr:*myaddr.sin_port = 0;*myaddr.sin_addr.s_addr = INADDR_ANY
bind
Bind performed by TCP server restricts the socket to receiving incoming client connection destined only to that IP address
#include <sys/socket.h>
int bind (int sockfd, const struct sockaddr *myaddr, socklen_t addrlen);Returns: 0 if OK, -1 on error
bind
No cliente, kernel faz o bind com o endereço IP da interface
Listen Function
An active (client) socket is one that called connect com o socket, starting a 3-way handshake with a remote host;
An applications (server) which calls listen, makes an unconnected socket a passive one meaning that the kernel must accept incoming connection requests directed to this socket.
CLOSED → LISTEN
Clients call connect while servers call listen followed by accept The backlog parameter indicates the total size of two queues: the complete queue
(ESTABLISHED state) and the incomplete connection queue (SYN_RVCD state)
int listen (int sockfd, (struct sockaddr) * myaddr, int backlog)
return 0 if OK, -1 if error
listen
listen
listen
listen
accept Function
Called by a TCP server to return the next completed connection from the front of the completed connection queue. If the queue is empty the process is oput to sleep
int accept (int sockfd, (struct sockaddr) * cliaddr, int * socklen)
returns nonnegative descriptor if OK, -1 if error
aadrlen is a value-result argument and it returns the size of the structure pointed to by cliaddr, i.e., the number of bytes stored by the kernel in the socket address structure.
fork - exec
Fork is called once but it returns twice. The return value tell the process whether it is a parent or a child
It returns once to the calling process (parent) with a return value that is the process ID of the newly created process (child)
It returns once in the child, with a return value of zero (0) All the descriptors opened by the parent before the fork
are shared with the child after the fork. connected sockts aer an accept and a fork is shared with
the Two uses of fork: a process makes a copy of itself (fork)
and a process executes another program (fork e exec)
# include <unistd.h>pid_t fork(void);
Returns: 0 in child, process ID of child in parent, -1 on error
fork - exec
#include <unistd.h>
int execl (const char *pathname, const char *arg0, ... /* (char *) 0 */ );
int execv (const char *pathname, char *const argv[ ]);
int execle (const char *pathname, const char *arg0, .../* (char *) 0, char *const envp[ ] */ );
int execve (const char *pathname, char *const argv[ ], char *const envp[ ]);
int execlp (const char *filename, const char *arg0, ... /* (char *) 0 */ );
int execvp (const char *filename, char *const argv[ ]);
All six return: -1 on error, no return on success
fork - exec
Concurrent server
Concurrent server (iterative server) – one server, several connections. Concurrent server serves several active connections.
Server performers a fork to create a child to handle the client request
After accept, the server calls fork and the child serves the client (on connfd, the connected socket) and the parent waits for another connection (on listenfd, the listening socket)
Concurrent server
Connect returns a brand new socket descriptor for the connection to be established with the TCP client.
The return of a connect makes a socket a connected socket.
On closing a socket only the specific connection (socket) is closed, the server remains listening to new socket connection request
Concurrent server
A close performed by the server does not imply in terminating the connection, a FYN is sent only when the number of reference to the descriptor in the file table is zero – when a child is created the number of reference is incremented by one.
If a server does not close the socket none of the children connections will be closed since the number of reference will never be zero and server runs out of descriptor
Concurrent server
pid_t pid; int listenfd, connfd;
listenfd = Socket( ... ); /* fill in sockaddr_in{ } with server's well-known port */
Bind(listenfd, ... ); Listen(listenfd, LISTENQ);
for ( ; ; ) { connfd = Accept (listenfd, ... ); /* probably blocks */
if( (pid = Fork()) == 0) { Close(listenfd); /* child closes listening socket */ doit(connfd); /* process the request */ Close(connfd); /* done with this client */ exit(0); /* child terminates */
}
Close(connfd); /* parent closes connected socket */ }
Concurrent server
Concurrent server
Concurrent server
close
SHUTDOWN used instead to force the termination of a connection
#include <unistd.h>
int close (int sockfd);Returns: 0 if OK, -1 on error
getsockname and getpeername
Returns the protocol address either local or remote
usos: connect not followed by bind After calling bind with 0 srgument TCP server performs a bind in a wildcard port
#include <sys/socket.h>
int getsockname(int sockfd, struct sockaddr *localaddr, socklen_t *addrlen);
int getpeername(int sockfd, struct sockaddr *peeraddr, socklen_t *addrlen);Returns: 0 if OK, -1 on error
getsocketname and getpeername
lib/sockfd_to_family.c1 #include "unp.h" 2 int 3 sockfd_to_family(int sockfd) 4 { 5 struct sockaddr_storage ss; 6 socklen_t len; 7 len = sizeof(ss); 8 if (getsockname(sockfd, (SA *) &ss, &len) < 0) 9 return (-1); 10 return (ss.ss_family); 11 }
TCP ports and concurrent servers
multihomed – one-or-any any-wildcard
TCP ports and concurrent servers
