Berkeley Sockets An example

Transcription

1 Berkeley Sockets An example Carsten Griwodz (adapted from lecture by Olav Lysne) Socket example 1

2 Transport layer: TCP Connection-oriented service TCP Transmission Control Protocol Connection-oriented service of the Internet RFC 793 TCP offers: Connections Handshake, end-system state, teardown Reliable, ordered, streamoriented data transfer Loss: acknowledgements and retransmissions Flow control: Send not faster than receiver can receive Congestion control: Send slower when the network is congested. Socket example 2

3 Transport layer: UDP Connectionless service UDP User Datagram Protocol Connectionless service of the Internet RFC 768 UDP offers: No connections Send immediately Unreliable, unordered, packetoriented data transfer Loss: messages are simply lost Messages arrive exactly as send No flow control Send as fast as programs want to No congestion control Ignore network problems Socket example 3

4 Reading and writing function calls int read( int sock, void* buffer, int n) sock must be connected int recv( int sock, void* buffer, int n, int options ) sock must be connected Sometimes useful option MSG_PEEK: read packet but leave it in the queue int recvfrom( int sock, void* buffer, int n, int options, struct sockaddr* src, int* srclen ) Meant for unconnected sockets If sock is connected, src is identical to sockaddr from accept Socket example 4

5 Reading and writing function calls int write( int sock, void* buffer, int n) sock must be connected int send( int sock, void* buffer, int n, int options ) sock must be connected int sendto( int sock, void* buffer, int n, int options, struct sockaddr* dest, int destlen ) Meant for unconnected sockets If sock is connected, dest address must refer to the other side Socket example 5

6 Read and Write in UDP Problem 1 UDP sender char buffer[20]; buffer[0] = a ; buffer[1] = b ; buffer[2] = c ; UDP receiver possibilities /* write abcdefghij */ sendto( sock, buffer, 10, 0, (struct sockaddr*)&dest, destlen ); /* write klmnopqrst */ sendto( sock, &buffer[10], 10, 0, (struct sockaddr*)&dest, destlen ); char buffer[21]; memset( buffer, 0, 21 ); struct sockaddr_in who; int wholen; wholen = sizeof(struct sockaddr_in); recvfrom( sock, &buffer[0], 5, 0, (struct sockaddr*)&who, &wholen ); /* buffer: abcde */ wholen = sizeof(struct sockaddr_in); recvfrom( sock, &buffer[5], 5, 0, (struct sockaddr*)&who, &wholen ); /* buffer: abcdeklmno */ wholen = sizeof(struct sockaddr_in); recvfrom( sock, &buffer[10], 5, 0, (struct sockaddr*)&who, &wholen ); /* waits forever -- no more data coming */ Socket example 6

7 Read and Write in UDP Problem 2 UDP sender char buffer[20]; buffer[0] = a ; buffer[1] = b ; buffer[2] = c ; UDP receiver possibilities /* write abcdefghij */ sendto( sock, buffer, 10, 0, (struct sockaddr*)&dest, destlen ); /* write klmnopqrst */ sendto( sock, &buffer[10], 10, 0, (struct sockaddr*)&dest, destlen ); char buffer[31]; memset( buffer, x, 30 ); struct sockaddr_in who; int wholen; buffer[30] = 0; wholen = sizeof(struct sockaddr_in); recvfrom( sock, &buffer[0], 15, 0, (struct sockaddr*)&who, &wholen ); /* buffer: abcdefghijxxxx */ wholen = sizeof(struct sockaddr_in); recvfrom( sock, &buffer[15], 15, 0, (struct sockaddr*)&who, &wholen ); /* buffer: abcdefghijxxxxxklmnopqrstxxxxx */ Socket example 7

8 Read and Write in UDP Problem 3 UDP sender char buffer[20]; buffer[0] = a ; buffer[1] = b ; buffer[2] = c ; UDP receiver possibilities /* write abcdefghij */ sendto( sock, buffer, 10, 0, (struct sockaddr*)&dest, destlen ); /* write klmnopqrst */ sendto( sock, &buffer[10], 10, 0, (struct sockaddr*)&dest, destlen ); char buffer[21]; memset( buffer, \0, 21 ); struct sockaddr_in who; int wholen; /* first datagram is lost */ wholen = sizeof(struct sockaddr_in); recvfrom( sock, &buffer[0], 10, 0, (struct sockaddr*)&who, &wholen ); /* buffer: klmnopqrst */ wholen = sizeof(struct sockaddr_in); recvfrom( sock, &buffer[10], 10, 0, (struct sockaddr*)&who, &wholen ); /* waits forever -- no more data coming */ Socket example 8

9 Read and Write in TCP TCP sender char buffer[2000]; int retval; buffer[0] = a ; buffer[1] = b ; buffer[2] = c ; /* write abcdefghij */ retval = write( sock, buffer, 2000 ); Typical retval == -1 Some kind of error, look at errno Retval == 0 The connection has been closed Retval n < 2000 You tried to send too fast Only n bytes have been sent Try sending the rest later Retval == 2000 All bytes have been sent Very untypical Retval < -1 Retval > 2000 Both cases: Have you used char retval instead of int retval? Socket example 9

10 Read and Write in TCP TCP receiver char buffer[2000]; int retval; /* write abcdefghij */ retval = read( sock, buffer, 2000 ); Typical retval == -1 Some kind of error, look at errno Retval == 0 The connection has been closed Retval n < 2000 Only n bytes have been received No new data has arrived recently Try reading the rest later Retval == 2000 All bytes have been received Very untypical Retval < -1 Retval > 2000 Both cases: Have you used char retval instead of int retval? Socket example 10

11 Chatting Most of you know that there are programs in the Internet that allow you to talk or chat with each other by means of your computers When two chat programs are connected, all that is shown on one screen will also be shown by the other program and vice versa One problem in connection with chatting is the program start: it is necessary that someone at the other ends is prepared to accept a call Socket example 11

12 Goal: Connection service We will write a network service that everyone can connect to, and which offers a connecting user a random chat partner For this, we need a chat server with the following capabilities: It must offer the server that all who want to chat with someone can connect to a known port number on a known computer When the server has two chat clients, these two chat clients are connected so that they can start chatting This connection is made by telling the two client how they can contact each other All communication with the chat server uses TCP Socket example 12

13 Goal: cntd. This require also that we write a client that is able to contact the server is table to tell the server where itself can be contacted can be told by the server about a chat partner, and how to contact the chat partner can be contacted by another chat client can chat with another chat client as soon as a connection is made Socket example 13

14 Application protocol towards the server Chat client 1 Chat server Chat client 2 connection L. Hostname 1 Hostname 1 Port number 1 connection L. Hostname 2 Hostname 2 Port number 2 You are the server You are the client L. Hostname 1 Hostname 1 Port number 1 disconnection disconnection Socket example 14

15 Application protocol chatting Chat client 1 Chat server Chat client 2 connection chat chat chat # disconnection Socket example 15

16 Some detail Port numbers are sent as 4 ASCII characters Machine names are sent as First 2 ASCII characters as a two digits decimal number indicating the number of bytes in the name Then the name, in the number of bytes indicated before A chatted line is sent as 80 ASCII characters When a user chats a line that starts with the character # the chat session ends Socket example 16

17 Helper function for communication It is worthwhile to put some socket functions into functions calls such that it becomes easier to use them A call that provides a socket that listens to a given port Hides bind, listen, struct sockaddr_in A call that provides a socket that is connection to a given hostname and port number Hides connect, name resolution, etc. Several read and write operations Socket example 17

18 Creation of a listen socket int TCPListenSocket(int port_number) struct sockaddr_in serveraddr, clientaddr; int clientaddrlen; int request_sock; int i; /* Allow that the socket to reuse a port that the server * has also used when it was started before. Otherwise * TCP waits for a few minutes before allowing reuse. */ i = 1; setsockopt( request_sock, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)); /* Create the request socket. */ request_sock = socket(af_inet, SOCK_STREAM, IPPROTO_TCP); if (request_sock < 0) printf("creation of a socket failed.\n"); exit(1); /* Fill in the address structure */ bzero((void *) &serveraddr, sizeof(serveraddr)); serveraddr.sin_family = AF_INET; serveraddr.sin_addr.s_addr = INADDR_ANY; serveraddr.sin_port = htons(port_number); /* Bind the address to the socket. */ if (bind(request_sock, (struct sockaddr *)&serveraddr, sizeof serveraddr) < 0) printf("binding address to socket failed\n"); exit(1); /* Start listening to the socket */ if (listen(request_sock, SOMAXCONN) < 0) printf("can't listen to the socket\n"); exit(1); return request_sock; Socket example 18

19 Connection from the client side int TCPClientSocket(char machine[], int port_number) struct hostent *hostp; struct sockaddr_in serveraddr; int sock; /* Create a socket */ if ((sock = socket(af_inet, SOCK_STREAM, IPPROTO_TCP)) < 0) printf("creation of a socket failed.\n"); exit(1); /* Clean the serveraddr structure */ bzero((void *) &serveraddr, sizeof(serveraddr)); /* Initialize the serveraddr structure for the machine and port */ serveraddr.sin_family = AF_INET; /* Look in DNS for the IP address of the name */ if ((hostp = gethostbyname(machine)) == 0) fprintf(stderr,"ukjent machine %s\n",machine); exit(1); /* Put the address into the serveraddr structure */ memcpy(&serveraddr.sin_addr, hostp->h_addr, hostp->h_length); /* Add the port number */ serveraddr.sin_port = htons(port_number); /* Connect to the other machine */ if (connect(sock, (struct sockaddr *)&serveraddr, sizeof serveraddr) < 0) close(sock); printf("can't connect to %s\n",machine); exit(1); return sock; Socket example 19

20 Safe reading and writing /* Reads exactly l bytes from the socket */ int saferead(int so, char buf[], int l) int i; for (i=0; i<l; i++) buf[i]=safereadbyte(so); return l; /* Write to a socket in the same way as write, but returns an error message if the socket has been closed in the meantime */ int safewrite(int so, char buf[], int l) int i; if (i=write(so, buf, l)==0) printf("can't write to socket, connection is closed" ); exit(1); return i; /* Reads exactly one byte from a socket connection */ char safereadbyte(int so) int bytes; char buf[1]; bytes = read(so, buf, 1); /* Check whether the read worked */ if (bytes<0) perror("error in saferead"); if (close(so)) perror("close"); exit(1); /* Check whether the connection is still open */ if (bytes==0) printf("server: end of file on %d\n",so); if (close(so)) perror("close"); exit(1); return buf[0]; Socket example 20

21 Server: connecting two clients int connect_two_clients(int listen_socket) int client_socket1, client_socket2; struct sockaddr_in clientaddr1, clientaddr2; int clientaddrlen1, clientaddrlen2; char client_name1[80], client_name2[80]; char client_port1[5], client_port2[5]; char name_length1[3], name_length2[3]; memset( client_name1, 0, 80 ); memset( client_name2, 0, 80 ); memset( client_port1, 0, 5 ); memset( client_port2, 0, 5 ); memset( name_length1, 0, 3 ); memset( name_length2, 0, 3 ); /* Accept a connection from a first client */ clientaddrlen1 = sizeof(clientaddr1); client_socket1 = accept(listen_socket, (struct sockaddr *)&clientaddr1, &clientaddrlen1); if (client_socket1 < 0) perror("can't accept connection from a first chat client\n" ); /* Read machine name and port number that client sends * as its contact information */ saferead(client_socket1, name_length1, 2); saferead(client_socket1, client_name1, atoi(name_length1)); saferead(client_socket1, client_port1, 4); /* Accept a connection from second client */ clientaddrlen2 = sizeof(clientaddr2); client_socket2 = accept(listen_socket, (struct sockaddr *)&clientaddr2, &clientaddrlen2); if (client_socket2 < 0) perror("can't accept connection from a second chat client\n" ); /* Read machine name and port number that client sends * as its contact information */ saferead(client_socket2, name_length2, 2); saferead(client_socket2, client_name2, atoi(name_length2)); saferead(client_socket2, client_port2, 4); Socket example 21

22 Server: connecting two clients cntd. /* Tell the first client that it is the server in the chat * connection, and to wait for connection by a chat partner */ safewrite(client_socket1, "T", 1); /* Tell the second client that it is the client in the chat * connection, and to connect to the given name and port */ safewrite(client_socket2, "K", 1); safewrite(client_socket2, name_length1, 2); safewrite(client_socket2, client_name1, atoi(name_length1)); safewrite(client_socket2, client_port1, 4); /* Close the sockets for both clients */ close(client_socket1); close(client_socket2); return 0; Socket example 22

23 Server s main function int main(int argc, char *argv[]) int listen_socket; if( argc!= 2 ) fprintf(stderr,"usage: %s <port number>\n", argv[0]); exit(1); /* Start listening to the port number from the command * line */ listen_socket = TCPListenSocket(atoi(argv[1])); /* Connect pairs of clients forever */ while (1) connect_two_clients(listen_socket); /* We don't ever come here */ close(listen_socket); Socket example 23

24 Client: contacting the server int getchatpartner( char servername[], char serverport[], char myname[], char myport[] ) int sock, listen_socket, partneraddresslength; struct sockaddr partneraddress; char name_length[3]; char client_or_server[2]; char chatpartnername[80]; char chatpartnerport[5]; char buf[80]; memset( name_length, 0, 3 ); memset( client_or_server, 0, 2 ); memset( chatpartnername, 0, 80 ); memset( chatpartnerport, 0, 5 ); /* Connect to a chat server */ sock = TCPClientSocket(servername,atoi(serverport)); /* Tell the server how you can be contacted by a chat * partner */ sprintf(name_length, "%d", strlen(myname)); safewrite(sock, name_length, 2); safewrite(sock, myname, strlen(myname)); safewrite(sock, myport, 4); /* Receive from the server whether you will act as a client * or as a server in the chat */ saferead(sock, client_or_server, 1); /* Create a socket that is read to accept connections from * a chat partner */ listen_socket = TCPListenSocket(atoi(myport)); Socket example 24

25 Client: contacting the server cntd. if (client_or_server[0] == 'K') /* You will be the client in the chat */ /* Close the socket that you would have * needed as a chat server */ close(listen_socket); /* Read the length of the chat partner's hostname */ saferead(sock, name_length, 2); /* Read the chat partner's hostname */ saferead(sock, chatpartnername, atoi(name_length)); /* Read the chat partner's port number */ saferead(sock, chatpartnerport, 4); /* Close the connection to the server */ close(sock); /* Connect to the chat partner */ sock = TCPClientSocket(chatpartnername, atoi(chatpartnerport)); /* Write to the screen that the user can talk first */ printf("connection create, you talk first!!\n"); else /* Act as the server in the chat, no more information * is coming from the server */ close(sock); /* Accept a connection from a chat partner */ partneraddresslength = sizeof(partneraddress); sock = accept(listen_socket, (struct sockaddr *)&partneraddress, &partneraddresslength); if (sock < 0) perror("error accepting connection from chat partner" ); /* Write to the screen that the chat partner talks first */ printf("connection create, partner talks first!!\n"); saferead(sock, buf,80); printf(buf); return sock; Socket example 25

26 Client: chatting and main /* A function that alternately reads a text string from * standard input and sends it over the TCP connection, and * receive a text string and prints it on the screen. */ int chat(int socket) char text[80]; while (1) fgets(text,80,stdin); write(socket,text, 80); if (text[0]=='#') return 0; saferead(socket, text,80); if (text[0]=='#') return 0; printf(text); int main(int argc, char *argv[]) int sock; if( argc!= 5 ) fprintf( stderr, "Usage: %s <servername> <serverport> <myname> <myport>\n", argv[0]); exit(1); /* ask for a chart partner */ sock = getchatpartner(argv[1], argv[2], argv[3], argv[4]); /* chat along!*/ chat(sock); /* Close the chat socket */ close(sock); Socket example 26

27 Weaksnesses of the implementation Server accounts hardly for wrong client behaviour Sending characters when a post number is required Client connects but does not send data, chat server ends Server forwards simple what it receives, without checking that the machine name is the calling client s Chat client can only send in turns That is different in a real chat session, or in real life Everything that is typed should be sent, without an understanding of turns Much more! Socket example 27

28 getchatpartner begins as before int getchatpartner( char servername[], char serverport[], char myname[], char myport[] ) int sock, listen_socket, partneraddresslength; struct sockaddr partneraddress; char name_length[3]; char client_or_server[2]; char chatpartnername[80]; char chatpartnerport[5]; char buf[80]; memset( name_length, 0, 3 ); memset( client_or_server, 0, 2 ); memset( chatpartnername, 0, 80 ); memset( chatpartnerport, 0, 5 ); /* Connect to a chat server */ sock = TCPClientSocket(servername,atoi(serverport)); /* Tell the server how you can be contacted by a chat * partner */ sprintf(name_length, "%d", strlen(myname)); safewrite(sock, name_length, 2); safewrite(sock, myname, strlen(myname)); safewrite(sock, myport, 4); /* Receive from the server whether you will act as a client * or as a server in the chat */ saferead(sock, client_or_server, 1); /* Create a socket that is read to accept connections from * a chat partner */ listen_socket = TCPListenSocket(atoi(myport)); Socket example 28

29 ...buts ends differently if (client_or_server[0] == 'K') /* You will be the client in the chat */ /* Close the socket that you would have needed * as a chat server */ close(listen_socket); /* Read the length of the chat partner's hostname */ saferead(sock, name_length, 2); /* Read the chat partner's hostname */ saferead(sock, chatpartnername, atoi(name_length)); /* Read the chat partner's port number */ saferead(sock, chatpartnerport, 4); /* Close the connection to the server */ close(sock); else /* Act as the server in the chat, no more information * is coming from the server */ close(sock); /* Accept a connection from a chat partner */ partneraddresslength = sizeof(partneraddress); sock = accept(listen_socket, (struct sockaddr *)&partneraddress, &partneraddresslength); if (sock < 0) perror("error accepting connection from chat partner" ); printf("connection create, chat along!!\n"); return sock; /* Connect to the chat partner */ sock = TCPClientSocket(chatpartnername, atoi(chatpartnerport)); Socket example 29

30 chat function used separate processes for reading and writing, so that the don t block each other: int chat(int socket) int status; char text[10]; if (safefork()==0) while (text[0]!= '#') fgets(text,80,stdin); write(socket,text, 80); else while (text[0]!= '#') saferead(socket, text,80); printf(text); int main(int argc, char *argv[]) int sock; /* get a chat partner */ sock = getchatpartner(argv[1], argv[2], argv[3], argv[4]); /* start chatting */ chat(sock); /* close the chat socket */ close(sock); Socket example 30

31 Data types Basic data types Have a certain number of bits Not very important in platform-dependent nonnetworked applications Not very important in platform-dependent networked applications Very important in platform-independent networked applications Socket example 31

32 Data types Basic data types C data types char unsigned char - 8 bits short unsigned short - 16 bits int unsigned int - 32 (or 64) bits long unsigned long - 32 or 64 bits long long unsigned long long - 64 (or 128) bits Socket API portable types size_t 32 bits unsigned, 0 2^32-1 ssize_t 32 bits signed, -2^31 2^31-1 Socket example 32

33 IP addresses and hostnames IPv4 host address When written on paper, it looks like dotted decimal notation Represents a 32 bit address Binary in bits Hexadecimal in bytes 0x81 0xf0 0x47 0xd5 One 4 byte int on x86, StrongARM, XScale, 0xd547f081 One 4 byte int on PowerPC, POWER, Sparc, 0x81f047d5 In network byte order 0x81f047d5 Socket example 33

34 IP addresses and hostnames On x86 etc. ntohl(0x81f047d5) == 0xd547f081 On PowerPC etc. ntohl(0x81f047d5) == 0x81f047d5 Socket example 34

35 IP addresses and hostnames IPv4 host address Corresponds to one network interface card (NIC) IPv4 network address Looks like /24 Refers to add addresses that that the same first 24 bits is in that network Socket example 35

36 IP addresses and hostnames IPv4 networks Institutes and companies own network address ranges e.g /16 - UiO e.g /8 IBM Institutes and companies assign addresses to their computers Fixed addresses Temporary addresses Class A addresses 0 network host / /8 Class B addresses Class C addresses Class D or multicast addresses 10 network host 110 network host 1110 multicast address / / / / Socket example 36

37 IP addresses and hostnames IPv4 networks Institutes and companies own network address ranges e.g /16 - UiO e.g /8 IBM Institutes and companies assign addresses to their computers Fixed addresses Temporary addresses They can also create subnets IFI has subnetsof UiO saddressspace E.g / can t be used for a computer, it s the network s address can t be used for a computer, it s an address for all computers in the network, the broadcast address Socket example 37

38 IP addresses and hostnames These are many addresses Why do we need IPv6? Most IPv4 addresses have owners No matter whether the addresses are needed Most in the US, using 1% Several in Europe Really tight in Asia, only assigned when need is proven IPv6 addresses 128 bits In text 2FFF:80:0:0:0:0:94:1 8 times 16 bits Hard to remember own address bit top level 32 bit next level 16 bit site level 64 bit interface id Socket example 38

39 IP addresses and hostnames Hostnames More exactly fully qualified host names Look like niu.ifi.uio.no Host niu In subdomain ifi, Institutt for Informatik In domain uio, Universitet i Oslo In top level domain no, Norway Who decided this?.no.uio.ifi niu - IANA gave it to Uninett - Uninett gave it to UiO - USIT, UiO s drift, gave it to IFI - IFI drift gave it to the machine Socket example 39

40 Name resolution Gethostbyname Takes a hostname Returns information aboutthathostname Including its IP address How? struct hostent *hostp; struct sockaddr_in serveraddr; int sock; /* Look in DNS for the IP address of the name */ if ((hostp = gethostbyname(machine)) == 0) fprintf(stderr, Unknown machine %s\n",machine); exit(1); bzero((void *) &serveraddr, sizeof(serveraddr)); serveraddr.sin_family = AF_INET; memcpy(&serveraddr.sin_addr, hostp->h_addr, hostp->h_length); serveraddr.sin_port = htons(port_number); Socket example 40

41 Name resolution Gethostbyname Takes a hostname Returns information aboutthathostname Including its IP address How? First: Look into /etc/hosts But only for few, special, well-known hosts # # list of statically known hosts # localhost argul.ifi.uio.no argul fileserver.ifi.uio.no fileserver Socket example 41

42 Name resolution Gethostbyname Root name server Takes a hostname Returns information aboutthathostname Including its IP address How? Then: ifi.uio.no dns.umass.edu Using DNS the Domain Name System 1 6 a121.ifi.uio.no gaia.cs.umass.edu Socket example 42

43 Name resolution Gethostbyname Takes a hostname Returns information aboutthathostname Including its IP address Return value Pointer to struct hostent Contains more than just an IP address Other names All addresses #define h_addr h_addr_list[0] struct hostent /* official hostname */ char* h_name; /* alias names of the host * entry NULL indicates end of the list */ char **h_aliases; /* host address type, e.g. AF_INET */ int h_addrtype; /* length of each address */ int h_length; /* list of addresses, primary is 0 th entry * entry 0 indicates end of the list */ char** h_addr_list; ; Socket example 43

44 Name resolution Finding the own hostname Command line ifconfig a (Unix) ipconfig /a (Windows) Gives you all IP addresses Typically 2: localhost and the actual one Inside a program Difficult without a connected socket With a connected socket: struct hostent* getsockname(int sock); Similar to gethostbyname eth0 Link encap:ethernet HWaddr 00:C0:4F:A3:0C:D3 inet addr: Bcast: Mask: UP BROADCAST NOTRAILERS RUNNING MULTICAST MTU:1500 Metric:1 RX packets: errors:65 dropped:0 overruns:203 frame:65 TX packets: errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:100 RX bytes: ( Mb) TX bytes: ( Mb) Interrupt:19 Base address:0xfcc0 lo Link encap:local Loopback inet addr: Mask: UP LOOPBACK RUNNING MTU:16436 Metric:1 RX packets:26429 errors:0 dropped:0 overruns:0 frame:0 TX packets:26429 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:0 RX bytes: (5.6 Mb) TX bytes: (5.6 Mb) Socket example 44

45 Netmasks Help your computer find the way All computers with addresses in the same network can be reached directly If you know your own computer s address, e.g and the relevant bits of your network, e.g. /24 you know that all computers with addresses ? are in the same network For each computer with another address, a member of the own network (computer or router) must be found that can send the data into the right direction This is sometimes wrong Understanding of network addresses becomes important Tell your computer its network address For computers with a fixed IP address: set up once For computers with a dynamic address: set up together with address Socket example 45

46 Netmasks The computer Is not told directly that it s on the network /24 Instead it is told that it s address is And that its netmask is these are 24 bits It figures the network address out from this In ifconfig or ipconfig Lists hostname E.g Lists netmask e.g Or 0xffffff00 Or the highest 24 bits set Implies that is part of the subnet /24 which is the same as /24 This answer from ifconfig implies also that All computers in the net /24 are reachable directly Without router Socket example 46

47 Select int select( int max_fd, fd_set* read_set, fd_set* write_set, fd_set* except_set, struct timeval* timeout ); Complicated at first But very useful Can wait for activity on many sockets New connections on request sockets New data on connected sockets Closing of a connected socket Ready-to-send on a socket Can wait for user input Can wait for timeouts Socket example 47

48 Select int select( int max_fd, fd_set* read_set, fd_set* write_set, fd_set* except_set, struct timeval* timeout ); For servers Serve many clients at once Handle clients that close connections, clients that crash, For the chat example Wait for data from chat partner Wait for typing of the user Socket example 48

49 Select int select( int max_fd, fd_set* read_set, fd_set* write_set, fd_set* except_set, struct timeval* timeout ); read_set Arriving connect requests Arriving data Closing sockets write_set Non often used Non-blocking send is finished except_set Hardly ever used sendto(.,.,.,msg_oob) Socket example 49

50 Select void wait_for_all(int clientsock[], int clients) fd_set read_set; int i,act,top=0; FD_ZERO(&read_set); for( i=0; i<clients; i++ ) FD_SET(clientsock[i],&read_set); top = MAX(top,clientsock[i]); act = select( top+1, &read_set, NULL, NULL, NULL); Using only the read_set is typical Clear the read_set Must be done every time Put all sockets into the read set Find the highest socket number, add 1 NULL timeout Means forever Call select waits for arriving data Socket example 50

51 Select void wait_some_time(int sec, int usec) struct timeval timeout; timeout.tv_sec = sec; timeout.tv_usec = usec; act = select( 0, NULL, NULL, NULL, &timeout ); select can also wait only for a timeout Without sockets Timeout parameter NULL means wait forever Timeval 5,0 means wait 5 seconds Timeval 0,0 means don t wait at all Socket example 51

52 Summary Names and addresses IP addresses Fully qualified hostnames Domain Name System How to use it Connections in TCP and UDP Functions The select function call Several functions for reading and writing Socket example 52