CSC209H Lecture 9. Dan Zingaro. March 11, 2015

Transcription

1 CSC209H Lecture 9 Dan Zingaro March 11, 2015

2 Socket Programming (Kerrisk Ch 56, 57, 59) Pipes and signals are only useful for processes communicating on the same machine Sockets are a general interprocess communication mechanism that can be used for processes on the same machine or on different machines Sockets let us create servers that accept clients, and clients that connect to servers Sockets are two-way channels, unlike pipes which are one-way

3 Types of Connection Two types of models for sending messages between computers Connectionless model Main example: UDP (user datagram protocol) Messages sent are not guaranteed to be received No error-correction Messages can be received multiple times or out-of-sequence Useful for multimedia transmission and online games

4 Types of Connection... Connection-oriented model Main example: TCP (transmission control protocol) Reliable, sequenced delivery of segments Each segment contains a sequence number that can be used by the receiver to assemble segments in the proper order For each segment that the receiver gets, the receiver sends back an acknowledgment (containing the sequence number) The sender has a timer for each acknowledgment; if the timer expires, the sender resends the same segment

5 More About TCP Flow control (sliding window) Along with the acknowledgment, the receiver can tell the sender how much more data it can take (including 0). This amount is the current size of the window If the receiver says that it has no room left, the sender is not allowed to send any more data Once the receiver catches up, it can send the same acknowledgment again along with a new window size

6 More About TCP... Congestion control (slow-start algorithm) TCP data is sent in segments, and the segment size depends on the network The sender starts by sending one maximum segment and waiting for the acknowledgment before sending another If the acknowledgment arrives before the timeout, the sender sends two segments before waiting for acknowledgment of both If this is successful, it sends four, eight,..., until It exceeds the size of the receiver s window, or It fails to get the acknowledgment back (i.e. it hit the network too hard) The sender then continues to send at this final size that worked

7 Internet (IP) Addressing IPV4 addresses are four numbers separated by dots e.g An IP address refers to a specific machine on a specific network In addition to an IP address, you must specify a port Servers can have multiple processes running, each monitoring a different port Ports up to 1024 are reserved for well-known purposes (HTTP, SMTP); don t set up servers on these ports

8 nc nc provides a nice way to mess around with connecting to ports. Here s how you could make an HTTP request to retrieve my homepage. nc danielzingaro.com 80 GET / HTTP/1.1 host: danielzingaro.com <blank line> You ll see a lot of HTML come back. This is what your browser gets when you go to my homepage.

9 Creating a Server To set up a (connection-oriented) server so that clients can connect, call the following, in order: socket: create a communication endpoint (like pipe) bind: take the FD from socket and associate it with a network address and port The client must know this address and port in order to connect listen: put the FD from socket into a mode where it listens for incoming connections accept: accept a connection from the client read, write: receive and send data with the connected client

10 socket The socket syscall allows you to create an endpoint for communication. int socket(int domain, int type, int protocol) domain: give value AF_INET type: SOCK_STREAM (connection-oriented) or SOCK_DGRAM (connectionless) protocol: give value 0 for default protocol (TCP for connection-oriented, UDP for connectionless) socket returns an FD (or -1 on error)

11 bind The bind syscall associates the FD from socket with an address and port. int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen); sockfd: the FD returned from socket addr: a struct with address and port information (next slide) addrlen: sizeof of the address struct (socklen_t is like size_t; just an int type) bind returns 0 for success, -1 for failure (e.g. address already in use)

12 bind... int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen); For the second parameter, we pass a pointer to a struct sockaddr_in: struct sockaddr_in { sa_family_t sin_family; //set to AF_INET in_port_t sin_port; //port number struct in_addr sin_addr; //IP address unsigned char sin_zero[8]; //padding };

13 bind... htons converts an integer from host byte order to network byte order. listenfd is the listening FD originally from socket. struct sockaddr_in r; //Zero the struct, because it is allowed to have //other members, which bind expects to be zeroed. memset(&r, \0, sizeof (r)); r.sin_family = AF_INET; r.sin_addr.s_addr = INADDR_ANY; //local address r.sin_port = htons(port); if (bind(listenfd, (struct sockaddr *)&r, sizeof(r)) == -1) { perror("bind"); exit(1); }

14 listen The listen syscall takes the now-bound fd from socket and lets it queue connections from clients. int listen(int sockfd, int queue_size); sockfd: the FD returned from socket queue_size: number of clients that can connect waiting to be accepted (set it to e.g. 50) listen returns 0 for success, -1 for failure

15 accept The accept syscall accepts a connection from a client, blocking until a client becomes available. int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); sockfd: the FD returned from socket addr: tells you address and port information of the client (if you don t care about this, set this to NULL and the next parameter to 0) addrlen: set to sizeof(addr) in the call; accept will set it to the actual length of the address it returned accept returns a new FD that can be used to read and write with the client (or -1 on error) Each connected client gets its own unique FD

16 accept... listenfd is the listening FD originally from socket. int fd; struct sockaddr_in r; socklen_t socklen = sizeof(r); if ((fd = accept(listenfd, (struct sockaddr *)&r, &socklen)) < 0) { perror("accept"); else //... read/write with fd

17 IP Address Conversions The socket API doesn t work with IP addresses in the standard aaa.bbb.ccc.ddd form Instead, it uses an in_addr type When clients want to connect to a certain IP address, the IP address has to be converted to an in_addr //Convert aaa.bbb.ccc.ddd form to internal form int inet_aton(const char *ip_address, struct in_addr *inp); //Convert internal form to aaa.bbb.ccc.ddd form char *inet_ntoa(struct in_addr in);

18 Example: Who is Connecting? We can write a small server that tells us the IP address and port used by each connecting client The server also sends each client a quick message Unrealistic: usually a client and server will communicate for much longer, reading and writing back and forth

19 Who is Connecting?... (whocon.c) #define PORT 7004 int listenfd; void setup (void) { struct sockaddr_in r; if ((listenfd = socket(af_inet, SOCK_STREAM, 0)) == -1) { perror("socket"); exit(1); } memset(&r, \0, sizeof (r)); r.sin_family = AF_INET; r.sin_addr.s_addr = INADDR_ANY; r.sin_port = htons(port);

20 Who is Connecting?... (whocon.c) if (bind(listenfd, (struct sockaddr *)&r, sizeof r) == -1) { perror("bind"); exit(1); } if (listen(listenfd, 5) == -1) { perror("listen"); exit(1); } }

21 Who is Connecting?... (whocon.c) int main(void) { int fd; struct sockaddr_in r; socklen_t socklen; char buf[300]; int num = 0; setup(); while (1) { socklen = sizeof (r); if ((fd = accept(listenfd, (struct sockaddr *)&r, &socklen)) < 0) { perror("accept"); } else { printf("connection from %s on port %d\n", inet_ntoa(r.sin_addr), ntohs(r.sin_port)); sprintf (buf, "Hello client %d!\r\n", ++num); write (fd, buf, strlen(buf)); close (fd); } } }

22 Network Newline Convention C lines end with \n When sending a line of text over the network, lines must end with \r\n C strings end with a \0 Don t send these \0 characters over the network When reading off the network, take \r, \n, or \r\n as a newline (not everyone else follows the newline convention!)

23 Reading From Clients When a server does a read, it is not guaranteed to get a complete line e.g. the client could be sending each character separately e.g. the client could send a line that gets split over several segments If you want to operate only on full lines, the server must keep each partial line in a buffer until it gets the newline from the client We ll mess around with the next example to see why it is dangerous to assume the retrieval of full lines

24 Example: Reading from Clients (readserver.c) while (1) { socklen = sizeof (r); if ((fd = accept(listenfd, (struct sockaddr *)&r, &socklen)) < 0) { perror("accept"); } else { //Print IP address and port printf("connection from %s on port %d\n", inet_ntoa(r.sin_addr), ntohs(r.sin_port)); // Receive messages while ((nbytes = read(fd, buf, sizeof (buf) - 1)) > 0) { buf[nbytes] = \0 ; printf ("Next line: %s\n", buf); } close (fd); } } }