Ps22Pdf

Transcription

1 Linux/ U NIX L in u x

2 ( ) 158,,,,,, : 5, ( socket ) I/ O I/ O Inetd, U NIX/ L inux,,, UNIX/ Linux UNIX/ Linux 5, 5,, : Linux : : (, ) ht tp: / / w ww. tup. tsinghua. edu. cn : : : / 16: 20 5: 484 : : ISBN / T P : : 27 00

3 Lin ux,, Linux,, Linux,, W indows N T, Windows 95/ 98,,,, Linux W indows 95/ 98,,,,, Linux Linux, Int ernet,, Linux,,, Linux, Lin ux,,, Linux Linux,, Internet,,, Linux, Linux, Linux Linux, : 5 Linux,, : Linux T CP / IP U DP T CP/ IP Linux,, T CP/ IP 5, Linux,, Linux 6 Linu x, : Linux I/ O I/ O Inetd, Inetd, Linux ;,, Linux, Linux I/ O I/ O Linux,

4 Linux ; Inetd Linux Int ern et ; Linu x ; IP, Linux,, Lin ux,,,,,

5 1 Linux Linux TCP / IP Int ern et ( IP ) Int ern et ( ICMP) ( U DP ) ( T CP) Int ern et

6 4 TCP : : : : UDP recvfrom sendt o U DP : U DP : U DP U DP : U DP : U DP U DP U DP ( fork exec) ( daemon process) : in et d

7 recv send readv writ ev recvfrom sendt o recvmsg sendmsg : shutdown / : select get sockopt set sockopt IP T CP fcnt l ioctl ( pipe) V IPC ( memory mapped file) U N IX U N IX : T CP T CP

8 P IN G : ICMP IP H DRIN CL / / / / / : U DP : T CP : U DP T CP : T CP : T CP : T CP : I/ O T CP :

9 1 Linux 1.1 Linux Linux Linux, Linux, Linux Linux Linux, U NIX, : BSD System V, Linux Linux,,, Linux Ross Biro < biro@ yggdrasil.com > Ross WD 8003,, Linux Ross, Ross,,, Orest Zborowski < obz@ Kodak.COM > Linux BSD ( Socket),, Linux Linux, Linux, Laurence Culhane < holmes.demon.co.uk > SLIP Linux Linux, Ross, Fred van Kempen < waltje@ uwalt.nl.mugnet.org > Fred Linux,, NET 2, Fred, AX.25 Fred NET 2 Linux, 1

10 , F red,, 80 %, Ross, Fred Alan Cox < iialan@ > Fred NET 2,,,, Fred, Alan,, Linux NET 2D(ebugged),, Alan, NET 2 Linux :,, Linus, Alan, Alan Fred,,,, Fred Alan Linux Donald Becker < becker@cesdis.gsfc.nasa.gov >,, Linux 1.3., NET 3, Alan,, Alan AX.25 IPX,,, Linux NET 4 Linux,, Linux Linux Linux () ,, :,,,,,,, 1 1 : 2

11 1 1 - (1 ),, (2 ), (3 ) (4 ),, (5 ),, (6 ),, Linux,,, : (iterative server),,,,,, Linux ( daytime) (concurrent server),,,,,,, Linux, ( FT P ),,,, ;,,,,,, 3

12 1.3 -, - :, : # include < stdio.h > # include < stdlib.h > # include < errno.h > # include < string.h > # include < netdb.h > # include < sys/ types.h > # include < netinet/ in.h > # include < sys/ socket.h > # define PORT 3490 int main(int argc, char argv[]) int sockfd, nbytes; char buf[1024]; struct hostent he; struct sockaddr in srvaddr; if (argc!= 2) perror( usage: client hostname \ n ); exit(1); if ((he = gethostbyname(argv[1])) == NULL) perror( gethostbyname ); exit(1); if ((sockfd = socket(af INET, SOCK STREAM, 0)) == - 1) perror( create socket error ); exit(1); bzero(&srvaddr, sizeof(srvaddr)); srvaddr.sin family = AF INET; srvaddr.sin port = htons(port); srvaddr.sin addr = ((struct in addr )he -> h addr); if (connect(sockfd, (struct sockaddr )&srvaddr, \ sizeof(struct sockaddr)) == - 1) 4

13 exit(1); perror( connect error ); if ((nbytes = read(sockfd, buf, MAXDATASIZE)) == - 1) perror( read error ); exit(1); buf[nbytes] = \ 0 ; printf( read: % s,buf); close(sockfd);, : bash netclient localhost Hello, Network! Hello, Network!,, < sys/ socket.h > < netinet/ in.h > Internet IP,,, IP gethostbyname I P ( socket),,, socket socket open,, ;, IP Internet ( sockaddr in ) AF INET, Internet ; 3499, ; gethostbyname IP I P, I P htons, IP gethostbyname,,, connect Internet, 5

14 , read write, read,,, close 1.4, : # include < stdio.h > ; # include < stdlib.h > ; # include < errno.h > ; # include < string.h > ; # include < sys/ types.h > ; # include < netinet/ in.h > ; # include < sys/ socket.h > ; # include < sys/ wait.h > ; # define MYPORT 3490 # define BACKLOG 5 main() int sockfd, new fd; struct sockaddr in srvaddr; struct sockaddr in cliaddr; int sin size; if ((sockfd = socket(af INET, SOCK STREAM, 0)) == - 1) perror( socket error ); exit(1); bzero(&srvaddr, sizeof(srvaddr)); srvaddr.sin family = AF INET; srvaddr.sin port = htons(myport); srvaddr.sin addr.s addr = htonl(inaddr ANY); if (bind(sockfd, (struct sockaddr )&srvaddr, sizeof(struct sockaddr)) == - 1) perror( bind error ); exit(1); 6

15 if (listen(sockfd, BACKLOG) == - 1) perror( listen error ); exit(1); for (;;) sin size = sizeof(struct sockaddr in); if ((new fd = accept(sockfd, (struct sockaddr )&cliaddr, &sin size)) == - 1) perror( accept error ); continue; printf( server: got connection from % s \ n, inet ntoa(cliaddr.sin addr)); if (write(new fd, Hello, Network! \ n, 14) == - 1) perror( write error ); close(new fd); close(sockfd);,, < sys/ socket.h > socket bind, (, ), AF INET, 3490( ), IP INADDR ANY, bind I P (listening socket),, listen listen, listen BACKLOG ( unaccepted) 3 socket, bind listen, TCP 3, TCP, accept, accept, accept ( new fd) 7

16 ,, close,,,,,, 1.5,,,, 1. ifconfig ifconfig Linux, : bash ifconfig eth0 eth0 Linux encap:10mbps Ethernet Hwaddr 00:A0:24:9C:43:34 inet addr: Bcast: Mask: UP BROADCAST RUNNING MULTICAST MTU:1500 Metric;1 RX packets: errors:0 dropped:0 overruns:0 TX packets: errors:0 dropped:0 overruns:0 Interrupt: 10 Base address:0x300 00: A0: 24: 9C: 43 : 34, I P , , , MULTICAST 2. netstat netstat netstat,, - a - r- n,, IP : bash netstat - rn 8

17 Routing tables Destination Gateway Flags Refs Use MT U Netif Expire Default UG et h0 127/ U lo / U et h0 - i [iface] ( ): bash netstat - ni Kernel Interface table Iface MT U Met RX RX RX RX TX TX TX TX Flags OK ERR DRP OVRP OK ERR DRP OVR lo BLRU et h BRU netstat, netstat, 3. ping ping ping ICMP, ping : bash ping PING ( ): 56 data bytes 64 bytes from : icmp seq = 0 ttl = 255 time = 0.316ms 64 bytes from : icmp seq = 1 ttl = 255 time = 0.315ms 64 bytes from : icmp seq = 2 ttl = 255 time = 0.316ms 64 bytes from : icmp seq = 3 ttl = 255 time = 0.317ms ping : PING ( ): 56 data bytes Host unreachable ,, ping ping,, IP 9

18 4. telnet telnet Internet,,, : bash telnet localhost 3490 Hello, Network!, telnet, 5. tcpdump tcpdump RedHat 6.0, Linux, ftp:/ / ftp.ee.lbl.gov/ ( datalink packet), : bash tcpdump (udp and port daytime) or icmp 13 ( daytime ) UDP ICMP : bash tcpdump tcp and port 80 adn tcp[13:1]& 2!= 0 80 (HT TP ), SYN ( SYN TCP 13,, 2) TCP tcpdump, TCP/ I P tcpdump, tcpdump 6.,,,, 1.6 Linux, 10

19 , Linux -,, TCP,, 11

20 2 TCP/ IP 2.1,,,, TCP/ IP 2 1 Internet IP TCP UDP ICMP, I P ICMP, ; UDP TCP,, 2 1 TCP/ IP 2.2 Internet (IP) 2 1, IP TCP/ IP UDP TCP, IP, 12

21 IP, I P,,, IP I P IP, ; IP I P : 1. IP 2 2 IP 2 2 IP IPv4 4I P,, I Pv6 IP, 4 (32 ) IP 20, I P IP, 5, I P, 16, I P I P, IP (Don t F ragment, DF )( More Fragment, MF ) I P 13

22 , 1 0, IP I P, TCP UDP ( Header Checksum) I P IP I P I P I P, 2. IP Internet IP, I P 32 IP 4, IP IP A ( 2 24 ), B (2 16 ), C (2 8 ), D, IP, 4, IP : IP,, I P,, 0,,, I P ; 1,, IP 1,, 1, ; I P , I P 4, Internet,,, B 14

23 , C,,, , IP I P, I P B ,,, 10, 6, 1024, 64 ;, 6, 10, 64, 1024, IP : IP 32, 1 IP ( ), 0 I P : , 9 0, I P 23 I P 1,, 1, 0 IP,, : B I P : , 7, : , I P : , : ,, IP, IP IP,,, I P 2.3 Internet (ICMP) Internet Internet I P, IP, ICMP I P, IP, IP ICMP, ICMP, ICMP I P 2 5 ICMP 15

24 2 5 ICMP : ICMP : ICMP : ICMP ICMP :, : ( 1 ) ; ( 2) ; ( 3), ICM P, : I P ( TTL) 1, 0, I P, ICMP I P ECHO ECHO ECHO ICMP, ICMP, ECHO ICMP ICMP 2.4 (UDP) UDP IP, I P, UDP,, 16

25 UDP UDP : UDP, : UDP, : UDP, : UDP,, 0 UDP,, UDP,,, ( well known), 1024, UDP,,,, ;,,, UDP, UDP UDP,,, Linux, UDP, UDP, UDP UDP, I P, UDP IP UDP,, UDP, UDP, ICMP ;, UDP, 17

26 2.5 (TCP), IP UDP,, IP, ( TCP ),, 1. TCP TCP,,, TCP TCP TCP,,,, TCP,, TCP I P,,,, TCP :, TCP RT T( Round Trip Time),, TCP,,, TCP R TT,, Internet, TCP TCP,, TCP, TCP,,, 1048, TCP 67200, TCP 1024, TCP, , , TCP IP IP, TCP TCP, :,,,, 18

27 ,,,,,, TCP TCP TCP, ( ) TCP :, ;, :,, TCP, TCP, TCP : TCP : TCP : :, 1 : 4 ( 32 ) TCP, 20, TCP, U RG( urgent):, 1 ACK(acknowledge):, 1 PSH( push):, 1,,, RST( reset): TCP, TCP,, TCP 3 TCP RST : (1 ) SYN ; ( 2 ) TCP ; ( 3) TCP, RST TCP 19

28 2 7 TCP, SYN( synchronize) : TCP TCP, TCP, SYN, SYN, TCP FIN(finish):, TCP,,, TCP, FIN,, FIN FIN, (16 ) : : TCP : ( URG), TCP,, : TCP : (1 ) ( Maxi mum Segment Size, MSS), SY N, TCP,, ; (2 ),, 20

29 65535,,,, TCP, N, 2 N 3. TCP TCP IP, I P,, TCP 3 : socket bind listen,, connect connect TCP TCP SYN, TCP SYN, SYN, SYN TCP SYN, SYN, TCP SYN, TCP 2 8 TCP 3 3 (a), TCP SYN, X, TCP SYN, Y, SYN ( X + 1), SYN,,, 3 ( b),, TCP, SYN, (a) (c), SY N TCP ( I P, ) TCP SYN, SYN, Y, SYN (X + 1), TCP,, RST, SYN, RST TCP RST, TCP 3,, 4. TCP TCP, TCP,, TCP 21

30 2 8 TCP 3 TCP 4 : (1 ),, ( close )close TCP FIN (2 ),, F IN, TCP FIN FIN ( EOF ), F IN,, ( ) (3 ),, close close TCP F IN (4 ) TCP F IN, F IN, TCP 2 9, : TCP F IN, X, TCP FIN,, TCP,,,, TCP TCP F IN, Y TCP F IN,, TCP,, TCP 22

31 2 9 TCP 4, F IN TCP FIN F IN,, F IN,,, TCP,, FT P,, HT TP, 5. TCP TCP, : CLOSED:, LISTEN : SYN RCVD:, SYN SENT: ESTABLISHED:, F IN WAIT 1 :, F IN WAIT 2 :, TIME WAIT :, CLOSING: CLOSE WAIT : LAST ACK :,, TCP, 23

32 2 10 TCP CLOSED : TCP ( connect), TCP SYN, SYN SENT SYN + ACK, TCP ACK, 3, ESTABLISHED,, close, TCP F IN, F IN WAI T 1, ACK ACK, FIN WAIT 2,, ( FIN ), TCP FIN, TIME WAIT, TCP TIME WAIT,, TCP : listen, TCP LISTEN, SYN, TCP, SYN + ACK, SYN RCVD SYN, 3, ESTABLISHED,, F IN TCP F IN, CLOSE WAIT,, close, TCP F IN, LAST ACK,, TCP 24

33 6. TCP TCP,, TCP TCP - (1 ) TCP TCP SYN TCP SYN SENT TCP SYN, X, ( MSS)1460 (2 ) SYN TCP SYN, SYN, SYN ( X + 1 ) TCP LISTEN SYN RCVD TCP SYN, Y, MSS 1024TCP, MSS, MSS 1024 (3 ) SYN TCP SYN, SYN ( Y + 1 )TCP ESTABLISHED, (4 ) 25

34 ( Y + 1 ), TCP ESTAB LISHED,, (5 ) write (6 ) read (7 ) TCP,, write (8 ) read, TCP (9 ) close, TCP TCP FIN, FIN WAIT 1, FIN (10) TCP F IN, TCP CLOSE WAIT, TCP 0 (11) FIN TCP TCP, FIN WAIT 2, (12) close, TCP TCP FIN, LAST ACK, FIN (13) TCP F IN, TCP TIME WAIT, ( MSL), TCP (14) FIN TCP TCP TCP CLOSEDTCP, 7. TCP I P, TCP, 26

35 TCP ( port),, (well known), F T P 21 HTT P 80, 1024, TCP, 4 : IP IP I P ( socket) ( socket pair ), TCP ( ) A B, ( ), HTT P ( 80 ) : ( : 80 ),, , ( :3905) ( : 3810 ), ( : 80 : : :3905) ( :80: : : 3810 ), 8. TIME WAIT TIME WAIT TCP,,,, ( Maximum Segment Lifetime, MSL) TIME WAIT : TCP : ( F IN ), IP,,, F IN TCP, F IN,, TCP RST, RST TCP,, TCP TIME WAIT, TCP, FIN,,, :, ( ),, :, 27

36 ,,,, TCP,,, TCP TIME WAIT,, 2.6 Internet TCP, echo discard daytime chargen time / etc/ services Internet TCP UDP echo 7 7 discard 9 9 daytime TCP, chargen ; UDP time inetd, telnet, : bash telnet echo Trying Connected to Escape character is ^]. Who am I? Who am I? ^] telnet > close Connection closed., netstat 2.7 TCP/ IP : IP ICM P UDP TCP IP, IP 28 ICMP IP

37 UDP UDP UDP TCP TCP TCP,, TCP 3, TCP, / etc/ services 29

38 3 3.1 Internet TCP/ I P, Linux ( socket ) Linux socket connect bind listen accept closegetsockname getpeername, IP, Internet,, 3.2 Linux,,, Linux, < linux/ socket.h > : struct sockaddr unsigned short sa family; /, AF xxx / char sa data[14]; / 14 / ; sa family, TCP/ IP AF INET ; sa data,, sockaddr TCP/ IP sockaddr in, < linux/ in.h > : struct in addr u32 s addr; / unsigned long / 30

39 ; struct sockaddr in short int sin family;/, AF xxx / unsigned short int sin port; / / struct in addr sin addr; / Internet / / struct sockaddr, / unsigned char pad[ SOCK SIZE - sizeof(short int) - sizeof(unsigned short int) - sizeof(struct in addr)]; ; # define sin zero pad / BSD / : (1 ) < linux/ socket.h > < linux/ in.h > Linux,,, < sys/ socket.h > < netinet/ in.h >, (2 ) sockaddr in TCP UDP sin port I P sin addr (3 ) 32 IP, servaddr Internet, servaddr.sin addr servaddr.sin addr.s addr IP, ( struct in addr), ( unsigned long) IP,, (4 ) sin zero, ( struct sockaddr), 0 sockaddr in (5 ) TCP,, I P, sockaddr in IP, I P : # include < sys/ socket.h > # include < netinet/ in.h > # include < arpa/ inet.h > int inet aton(const char cp, struct in addr inp); unsigned long int inet addr(const char cp); char inet ntoa(struct in addr in); 3 I P 32 IP, IP , 31

40 IP C0A8000Ainet aton I P IP, 1, 0, I P inp inet addr inet aton,, INADDR NONEinet addr, inet aton inet addr inet addr INAD DR NONE ,32 1 (- 1 )inet ntoa 32 IP IP, 3.3, Intel PC RISC 16 A103 2, A1, 03 :, 3 1 (a) ;, 3 1( b)little endian, Intel ; big endian, RISC 3 1,, Internet big endiantcp IP Linux 4 : # include < netinet/ in.h > unsigned long int htonl(unsigned long int hostlong); unsigned short int htons(unsigned short int hostshort); unsigned long int ntohl(unsigned long int netlong); unsigned short int ntohs(unsigned short int netshort); 4 h host, n net work, s short, l longshort 16, long 32,,,, 32

41 3.4,, C Linux, b( byte), BSD ; mem( ), ANSI C b : # include < strings.h > void bzero(void s, int n); void bcopy(const void src, void dest, int n); int bcmp(const void s1, const void s2, int n); bzero s n 0, : bzero(&servaddr, sizeof(servaddr)); bcopy src dest bcmp s1 s2 n, 0, mem : # include < string.h > void memset(void s, int c, size t n); void memcpy(void dest, const void src, size t n); int memcmp(const void s1, const void s2, size t n); memset s n c memcpy bcopy, : bcopy src dest, memcpy, bcopymemcmp s1 s2 n, 0, 3.5 TCP, TCP 3 2 TCP, TCP : socket, bind, listen 33

42 3 2 TCP - (listening socket), accept,, socket, connect, 1. socket socket : # include < sys/ types.h > # include < sys/ socket.h > int socket(int domain, int type, int protocol); domain ; type ; proto col socket,,, ;, - 1, errno Linux (AP I), 34

43 , TCP/ IP UNIX domain domain : AF UNIX U NIX, AF INET Internet ( TCP/ IP ) AF ISO ISO type, : SOCK STREAM, SOCK DGRAM, SOCK RAW, Internet, IP protocol 0,, Internet TCP, UDP, protocol,, ICMP IGMP TCP : sockfd = socket(af INET, SOCK STREAM, 0); if (sockfd < 0) fprintf(stderr, socket error: % s \ n, strerror(errno)); exit(1); Linux :,, TCP TCP 2. connect connect : # include < sys/ types.h > # include < sys/ socket.h > int connect(int sockfd, struct sockaddr servaddr, int addrlen); sockfd socket ; servaddr, IP ; addrlen connect, 0; - 1, errno : ETIMEOUT ECONNREF USED EHOSTUNREACH ENETUNREACH connect, TCP : bzero(&servaddr, sizeof(servaddr)); 35

44 servaddr.sin family = AF INET; servaddr.sin port = htons(server PORT); if (inet aton( , &servaddr.sin addr) < 0) fprintf(stderr, Inet aton error \ n ); exit(1); if (connect(sockfd, (struct sockaddr )&servaddr, sizeof(servaddr)) < 0) fprintf(stderr, connect error: % s, strerror(errno)); exit(1); ( IP ), , IP connect TCP 3 ( 2 ), : TCP SYN,, ETIMEOUT TCP SYN, SY N,, TCP RST,, ECON NRE FUSED SYN, TCP RST, TCP RS T, SYN, SYN ICMP,, EHOSTU NREACH ENETU NREACH TCP ICM P,, SYN,, TCP ICMP, connect, TCP SYN, TCP CLOSED SYN SENT, SY N, TCP ESTABLISHED, connect, close, con nect 3. bind 36 bind :

45 # include < sys/ types.h > # include < sys/ socket.h > int bind(int sockfd, struct sockaddr myaddr, int addrlen); sockfd socket ; myaddr ; ad drlen bind, 0;, - 1, errno EADDRINUSER bind, bind : bzero(&myaddr, sizeof(myaddr)); myaddr.sin family = AF INET; myaddr.sin port = htons(port); myaddr.sin addr.s addr = htonl(inaddr ANY); if (bind(sockfd, (struct sockaddr )&myaddr, sizeof(myaddr)) < 0) fprintf(stderr, Bind to port % d error \ n, PORT); exit(1);, IP INADDR ANY IP IP INADDR ANY IP IP IP IP I P, 5 : (1 ), I P bind, IP INADDR ANY, (2 ) IP bind, IP IP, I P,,, (3 ) 37

46 ,, connect TCP,, IP,, Linux rlogin, rlogin,, bind (4 ) IP (5 ) IP,,,, : (1 ) ( HTT P ) TIME WAIT ( 2 ),,, TIME WAIT,,, con nect, ECONNREFUSED (2 ) ( F TP ) TIME WAIT,, TIME WAIT,,,, bind, EADDRIN USE 4. listen listen (listening socket) : # include < sys/ socket.h > int listen(int sockfd, int backlog); sockfd ; backlog listen, 0; - 1 listen, listen : (1 ) socket, ( connect),, listen : TCP, listen, TCP CLOSED LISTEN 38 (2 ) TCP, listen

47 , socket, bind, listen 3 TCP backlog, TCP : (1 ) 3 TCP TCP SYN,, SYN SYN (ACK + SYN ), SYN, SYN RCVD, SYN, (2 ) 3, ( accept )TCP SYN, 3, TCP, ESTABLISHED, accept , 4,,,

48 TCP SYN,, SYN SYN, SYN,, TCP accept, backlog, ( unaccepted ) SY N,, TCP SYN SYN, TCP RS T, : (1 ) TCP RST, connect, RST,,, (2 ) :, accept, TCP, SYN,, TCP, 3,,, ETIME OUT, telnet : # include < sys/ socket.h > # include < sys/ types.h > # include < netinet/ in.h > int main() int sockfd; struct sockaddr in servaddr; if ((sockfd = socket(af INET, SOCK STREAM, 0)) < 0) perror( socket error.\ n ); exit(1); bzero(&servaddr, sizeof(servaddr)); servaddr.sin family = AF INET; servaddr.sin port = htons(8080); servaddr.sin addr.s addr = htonl(inaddr ANY); if (bind(sockfd, (struct sockaddr )&servaddr, sizeof(servaddr)) < 0) perror( bind port 8080 error.\ n ); exit(1); 40

49 listen(sockfd, 2); for (;;) : bash telnet localhost 8080 & bash telnet localhost 8080 & bash telnet localhost 8080 netstat, : bash netstat - a grep 8080 tcp 0 0 :8080 : LISTEN tcp 0 0 localhost:5301 localhost:8080 tcp 0 0 localhost:8080 localhost:5301 tcp 0 0 localhost:5302 localhost:8080 tcp 0 0 localhost:8080 localhost:5302 tcp 0 0 localhost:5303 localhost:8080 ESTABLISHED ESTABLISHED ESTABLISHED ESTABLISHED SYN SENT,,, telnet, SYN,, telnet, 5. accept accept, : # include < sys/ socket.h > int accept(int sockfd, struct sockaddr addr, int addrlen); sockfd ; addr Internet ; addrlen accept, 3 :, ; addr ; addrlen, addr addrlen N ULLaccept, - 1 accept TCP,, 3, TCP, TCP,, accept, accept (connected socket) :, 41

50 ,, ; ( accepted), TCP,,,, accept,,, EINTR, accept 6. close close close close : # include < unistd.h > int close(int sockfd); sockfd close, 0;, - 1 close close : close 1, 0,, close ; 0,,, close : ( TCP CLOSED ), close,, TCP TCP,, F IN,, TCP, TCP 7. read write read write : int read(int fd, char buf, int len); int write(int fd, char buf, int len); fd ; read buf, write buf ; len read, ;, - 1 write, ;, - 1 TCP,,, TCP : TCP, ;, TCP 42

51 , read write read :, read ; read, read len ; read, read,, len ;, read, write :, write ; write len, write,, write,,, : (1 ) read,, 0 (2 ) TCP FIN F IN, read 0, 0, (3 ) TCP RST RST, read, ECON NRESET (4 ), read, EINTR 3 : 0 0 0, : rc = read(sock, buf, size); if (rc > 0) / / write(fd,buf,rc); else if (rc == 0) / / close(fd); close(sock); else / / if (errno == EINTR) / / 43

52 else fprintf(stderr, read error: % s \ n, strerror(errno)); exit(1); read 0,, ; 0,,, ; 0,, : EINT R,,, read ; ECONNRESET, RST,,,,, : (1 ) write, (2 ) TCP RST TCP, TCP RST, TCP RS T, write, E PIPE (3 ), write, EINTR : 0 0, : wc = write(sock, buf, size); if (wc > 0) / / / / else if (errno == EINTR) / / else fprintf(stderr, write error: % s \ n, strerror(errno)); exit(1); 0,, ; 0,, : 44

53 EINT R, ; EP IPE,,,,, ;,,,,,,, ;,, : int read all(int fd, void buf, int nbytes); int write all(int fd, void buf, int nbytes); read all fd nbytes buf write all fd buf nbytes : # include < errno.h > # include < unistd.h > int read all(int fd, void buf, int n) int nleft; int nbytes; char ptr; ptr = buf; nleft = n; for (; nleft > 0; ) nbytes = read(fd, ptr, nleft); if (nbytes < 0) if (errno == EINTR) nbytes = 0; else return ( - 1); else if (nbytes == 0) break; nleft - = nbytes; ptr + = nbytes; return (n - nleft); int write all(int fd, void buf, int n) 45

54 int nleft, nbytes; char ptr; nleft = n; ptr = buf; for (; nleft > 0; ) nbytes = write(fd, ptr, nleft); if (nbytes < = 0) if (errno == EINTR) nbytes = 0; else return ( - 1); nleft - = nbytes; ptr + = nbytes; return (n); read all read, EINTR,,, EINTR, - 1 write all write, EINTR,,, EINTR, getsockname getpeername getsockname ; getpeername : # include < sys/ socket.h > int getsockname(int sockfd, struct sockaddr localaddr, int addrlen); int getpeername(int sockfd, struct sockaddr peeraddr, int addrlen); sockfd ; localaddr peeraddr Internet ; addrlen getsockname, 0,, localaddr, addrlen getpeer name, 0,, peeraddr, addrlen, - 1 : # include < sys/ socket.h > 46

55 # include < sys/ types.h > # include < netinet/ in.h > void disp addrcont(struct sockaddr in addr) if (addr - > sin family!= AF INET) perror( Not an Internet socket.\ n ); return; printf( address is: % s: % d \ n, inet ntoa(addr - > sin addr), ntohs(addr - > sin port)); main() int listenfd, connfd; struct sockaddr inservaddr, cliaddr, addr; int cliaddrlen, addrlen; if ((listenfd = socket(af INET, SOCK STREAM, 0)) < 0) perror( socket error.\ n ); exit(1); bzero(&servaddr, sizeof(servaddr)); servaddr.sin family = AF INET; servaddr.sin port = htons(8080); servaddr.sin addr.s addr = htonl(inaddr ANY); if (bind(listenfd, (struct sockaddr )&servaddr, sizeof(servaddr)) < 0) perror( bind port 8080 error.\ n ); exit(1); if (listen(listenfd, 1) < 0) perror( listen error.\ n ); exit(1); for (;;) connfd = accept(listenfd, (struct sockaddr )&cliaddr, &cliaddrlen); if (connfd < 0) perror( accept error.\ n ); exit(1); 47

56 printf( accept returned client address: \ n ); disp addrcont(&cliaddr); getpeername(connfd, (struct sockaddr )&addr, &addrlen); printf( getpeername returned client address: \ n ); disp addrcont(&addr); getsockname(connfd, (struct sockaddr )&addr, &addrlen); printf( getsockname returned server address: \ n ); disp addrcont(&addr); 3 : (1 ) connect, getsockname I P (2 ) IP INADDR ANY bind TCP, ( accept), getsockname IP (3 ), getpeername 3.6, IP,,, I P, IP ( resolver ) gethostbyname gethostbyaddr, IP, I P, I P,, Internet ( Domain Name System ), I P bbs.tsinghua.edu.cn IP ,, IP, tsinghua.edu.cn tsinghuaedu cn 3, 3 5, tsinghua, edu.cn, - I P,, 48

57 3 5, - IP, I P, DNS A IP 32 MX, NS CNAME PTR I P A A I P : master.utopian.edu.cn IN A master.utopian.edu.cn IN A slave.utopian.edu.cn IN A free IN A master.utopian.edu.cn IP , slave.utopian.edu.cn IP , free, free.utopian.edu.cn, IP IN In ternet MX MX : utopian.edu.cn IN MX 1 master.utopian.edu.cn utopian.edu.cn IN MX 2 slave.utopian.edu.cn free IN MX 1 free IN MX 2 master 49

58 utopian.edu.cn master.utopian.edu. cn, spirit, slave.utopian.edu.cn free.utopian.edu.cn,, master NS NS CNAME CNAME : ftp.utopian.edu.cn IN CNAME master.utopian.edu.cn IN CNAME master.utopian.edu.cn master.utopian.edu.cn, ftp.utopian.edu.cn P TR PT R( Pointer)IP, , ( Linux / etc/ resolv.conf), IP UDP, UDP, Inter net, 50

59 1. gethostbyname gethostbyname IP : # include < netdb.h > struct hostent gethostbyname(const char hostname); hostname, gethostbyname,, hostent ;, NULL hostent, 3 7 struct hostent char h name; / / char h aliases; / / int h addrtype; / :AF INET / int h length; / :4 (32 ) / char h addr list; / IP / # define h addr h addr list[0] / h addr list IP / gethostname A, hostent : h name ftp.utopian.edu.cn master.utopian.edu.cn h aliases master.utopian.edu.cn ftp.utopian.edu.cnwww.utopian.edu.cn h addrtype IPv4 AF INET h length I Pv4 4, 32 h addr list IP IP, h length,, : struct hostent he; he = gethostbyname( ftp.utopian.edu.cn ); hostent 3 7 master.utopian.edu.cn, ftp.utopian.edu.cn I P, gethostbyname, h errno, herror h errno : 51

60 3 7 hostent HOS T NOT FOU ND : NO ADDRESS:, IP NO RECOVERY: TRY AGAIN :, 2. gethostbyaddr gethostbyaddr IP : # include < netdb.h > struct hostent gethostbyaddr(const char addr, size t len, int family); addr in addr, IP ; len IP ; family AF INET gethostbyaddr, gethostbyname, h name ;, NULL gethostbyname gethostbyaddr : # include < netdb.h > # include < stdio.h > # include < stdlib.h > # include < sys/ socket.h > # include < netinet/ in.h > main(int argc, char argv[]) struct sockaddr in addr; struct hostent he; char alias; if (argc < 2) 52

61 perror( usage: hostname name ip...\ n ); exit(1); argv ++ ; for (; argv!= NULL; argv ++ ) if (inet aton( argv, &addr.sin addr)!= 0) he = gethostbyaddr((char )&addr.sin addr, 4, AF INET); printf( address information of IP % : \ n, argv); else he = gethostbyname( argv); printf( address information of host % s: \ n, argv); if (he == NULL) fprintf(stderr, no address information of % s \ n, argv); continue; printf( official host name: % s \ n, he - > h name); printf( name aliases: ); for (alias = he - > h aliases; alias!= NULL; alias ++ ) printf(% s,, alias); printf(\ nip addresses: ); for (alias = he - > h addr list; alias!= NULL; alias ++ ) printf(% s,, inet ntoa( (struct in addr )( alias)));, IP, IP, inet aton,, IP, ; inet aton,, gethostbyname, hostent h addr list IP, I P, I P, inet, addr I P : aton, conv, int addr conv(char address, struct in addr inaddr) struct hostent he; if (inet aton(address, inaddr) == 1) return 1; he = gethostbyname(address); 53

62 if (he!= NULL) inaddr = return 1; else return 0; (struct in addr )he - > h addr list[0]); addr conv 1, 0addr conv inet aton, inaddr, 1;, gethostbyname, IP inaddr, 1, inaddr s addr - 1, 0, :,,, ;, : (1 ) struct hostent host1, host2, host3, host4; (2 ) host1 = get hostbyname( host name1) ; (3 ) host2 = get hostbyname( host name2) ; (4 ) if ( host2 ) host3 = host2 ; (5 ) host4 = get hostbyname( host name4) ; (2 )hostname1, host1 ; ( 3) hostname2, host2, hostname1, host1 hostname2 ; ( 4), host2 host3, ( 5 ) gethostbyname, ( 5 ), host4 hostname4,, host3 hostname4 hostent, hostent,, hostent,,, :, geth ostbyname, IP,, : Web, I P , Web, IP,,, gethostbyname,, : ( 1), ; ( 2) 54

63 , Linux,,, U NIX,, Netscape Communicator 3. uname gethostname uname gethostname : # include < sys/ utsname.h > int uname(struct utsname name); # include < unistd.h > int gethostname(char name, size t len); uname name utsname, 0, name ;, - 1gethostname name, len name utsname : struct utsname char sysname[sys NMLN]; char nodename[sys NMLN]; char release[sys NMLN]; char version[sys NMLN]; char machine[sys NMLN]; char domainname[sys NMLN]; ; uname, utsname nodename uname,, gethostbyname, IP : struct hostent he; struct utsname myname; struct in addr paddrlist; if (uname(&myname) < 0) return(null); if ( (he = gethostbyname(myname.nodename)) == NULL) return(null); paddrlist = he - > h addr list; 3.7 Internet, ( F T P ) ( TELNET ) 55

64 ( ),, F TP 20 21, TELNET 23, 25, Inter net Linux / etc/ services, www : www 80/ tcp http # WorldWideWeb HTTP www, 80, TCP,, HTT P : bash telnet bash telnet http HTT P 80 : :, HT TP, HT TP HT TP 80, 80, HTT P 8080, 8080,, / etc/ services : 1. getservbyname getservbyname : # include < netdb.h > struct servent getservbyname(const char servname, const char protoname); servname ; protoname, servent ;, NULL servname : struct servent char s name; / / char s aliases; int s port; char s proto; ; / / / / / /? s port, getservbyname, ( HTT P TCP ), protoname N ULL ; 56

65 (DNS, UDP TCP ),,, protoname NULL, : int serv port(char servname, char proto, int port) struct servent se; se = getservbyname(servname, proto); if (se == NULL) return (0); port = se - > s port; return (1); serv port servname proto, port,, 1, 0 2. getservbyport getservbyport : # include < netdb.h > struct servent getservbyport(int port, const char protoname); port ; protoname, servent ;, NULL servents name, 514 TCP Shell, UDP Syslog, protoname 3.8, 1.,,, 2., 57

66 3.,,, 16, htons ntohs ; 32, htonl ntohl ; 64, 32 : void sender(int sockfd, long data) long nd; nd = htonl(data); write(sockfd, &nd, sizeof(nd)); void receiver(int sockfd, long data) long nd; read(sockfd, &nd, sizeof(nd)); data = ntohl(nd); :, 64 : void sender(int sockfd, long data) char buf[5]; sprintf(buf, % ld, data); write(sockfd, buf, strlen(buf)); void receiver(int sockfd, long data) char buf[5]; read(sockfd, buf, sizeof(buf)); sscanf(buf, % ld, data); 4. 58

67 , :, : struct multi type char sd str[10]; int sd int; ; void sender(int sockfd, struct multi type data) int len; len = strlen(data.sd str); len = htonl(len); write(sockfd, &len, sizeof(len)); write(sockfd, & data.sd str,len); len = htonl(data.sd int); write(sockfd, &len, sizeof(len)); void receiver(int sockfd, struct multi type data) int len; read(sockfd, &len, sizeof(len)); len = ntohl(len); read(sockfd, data - > sd str, len); read(sockfd, &len, sizeof(len)); data - > sd int = ntohl(len); sender :,,,,, receiver :, multi type,, multi type,, 5., 59

68 6.,, Sun Microsystem, Sun XDR (external Data Representation) - XDR, XDR,, ( local representation ) XDR XDR, RFC TCP TCP, connect TCP 3, TCP, bind, lis ten,, accept, close gethostbyname I P get servbyname 60

69 4 TCP , ,,,,,, :, Telnet, -,, : (1 ) = + (2 ) : Length : (3 ) Length,,, : Length 14 Hello, my lord! 14, Hello, my lord! 4 1,,, write requ read requ, 61

70 4 1 - write all read all, 4.3 : : # include < string.h > # include < sys/ socket.h > # include < netinet/ in.h > # include < stdio.h > # include < signal.h > # define SERVER PORT 8080 # define BACKLOG 5 int main(int argc, char argv[]) int listenfd, connfd; struct sockaddr in servaddr; listenfd = socket(af INET, SOCK STREAM, 0); if (listenfd < 0) fprintf(stderr, Socket error \ n ); exit(1); bzero(&servaddr, sizeof(servaddr)); servaddr.sin family = AF INET; servaddr.sin addr.s addr = htonl(inaddr ANY); servaddr.sin port = htons(server PORT); if (bind(listenfd, (struct sockaddr )&servaddr, sizeof(servaddr)) < 0) fprintf(stderr, Bind error \ n ); exit(1); if (listen(listenfd, BACKLOG) < 0) fprintf(stderr, Listen error \ n ); exit(1); for ( ;; ) 62

71 connfd = accept(listenfd, NULL, NULL); if (connfd < 0) fprintf(stderr, Accept error \ n ); exit(1); serv respon(connfd); close(connfd); close(listenfd); : (1 ) socket, 8080, 8080 : 1024,, ; 5000,, ;, bind listen (2 ) accept accept, connfd (3 ), serv respon, close (4 ), 4.4 : serv respon, : # include < string.h > # include < sys/ socket.h > # include < netinet/ in.h > # include < stdio.h > # include < signal.h > # define SERVER PORT 8080 # define BACKLOG 5 void serv resp on (int sockfd) 63

72 int nbytes; char buf[1024]; for ( ;; ) nbytes = read requ(sockfd, buf, 1024); if (nbytes == 0) return; else if (bytes < 0) fprintf(stderr, read error: % s \ n, strerror(errno)); return; if (write all(sockfd, buf, nbytes) < 0) fprintf(stderr, write error: % s \ n, strerror(errno)); : read requ, buf,, read requ 0,, ; 0,, ; read requ 0,, write all, serv respon serv respon read requ, : int read requ(int sockfd, char buf, int size) char inbuf[256]; int n; int i; i = read line(sockfd, inbuf, 256); if (i < 0) return (i); else if (i == 0) return (0); if (strncmp(inbuf, Length, 6) == 0) sscanf(buf + 6, % d, &n); else sprintf(buf, Invalid option, 14); return (14); return (read all(sockfd, buf, n)); 64

73 read requ :, read requ read line, Length, sscanf ; Length,, read requ, read requ read line, : # include < errno.h > # define MAX BUF SIZE 1024 int get char(int fd, char ch) static int offset = 0; static int size = 0; static char buf[max BUF SIZE]; for (; size < = 0 offset == size; ) size = read(fd, buf, MAX BUF SIZE); if (size < 0) if (errno == EINTR) size = 0; continue; else return ( - 1); offset = 0; ch = buf[offset ++ ]; return (1); int read line(int fd, char buf, int maxlen) int i, n; char ch; for (i = 0; i < maxlen; ) n = get char(fd, &ch); if (n == 1) buf[i ++ ] = ch; if (ch == \ n ) break; else if (n < 0) return ( - 1); else break; 65

74 buf[i] = \ 0 ; return (i); read line, (\ n ),,, read, read,,,, read line get char, get char get char read, buf read line get char, get char buf,, ; buf, read, 4.5 : : # include < sys/ socket.h > # include < stdio.h > # include < netinet/ in.h > # define SERVER PORT 8080 void main(int argc, char argv[]) int sockfd; struct sockaddr in servaddr; if (argc!= 2) fprintf(stderr, usage: client < IPaddress > \ n ); exit(1); sockfd = socket(af INET, SOCK STREAM, 0); if (sockfd < 0) fprintf(stderr, Socket error \ n ); exit(1); bzero(&servaddr, sizeof(servaddr)); servaddr.sin family = AF INET; servaddr.sin port = htons(server PORT); if (inet aton(argv[1], &servaddr.sin addr) == 0) fprintf(stderr, Inet aton error \ n ); exit(1); 66

75 if (connect(sockfd, (struct sockaddr )&servaddr, sizeof(servaddr)) < 0) fprintf(stderr, connect error: % s \ n, strerror(errno)); exit(1); cli requ(sockfd); close(sockfd); : (1 ) socket (2 ) I P, inet aton IP, IP servaddr, connect, connect, connect (3 ), cli requ (4 ) close 4.6 : cli requ, : # include < sys/ socket.h > # include < stdio.h > # include < netinet/ in.h > # define SERVER PORT 8080 void cli requ(int sockfd) char inbuf[256], oubuf[256]; int n; for ( ;; ) if (gets(inbuf) == NULL) return; n = strlen(inbuf); sprintf(oubuf, Length % d \ n, n); 67

76 write all(sockfd, oubuf, strlen(oubuf)); write all(sockfd, inbuf, n); n = read all(sockfd, inbuf, n); if (n == 0) return; else if (n < 0) fprintf(stderr, read line error.\ n ); return; write(1, buf, n); :,,,,, ( 0 ), cli requ , : bash echo - serv& [1] 283, socket bind listen accept,, accept, netstat : bash netstat - a grep 8080 tcp 0 0 :8080 : LISTEN netstat - a LISTEN, I P,, 8080, I P , ( 2 ) IP echo cli : bash echo cli , socket connectconnect TCP 3, TCP SYN, 68

77 connect, accept, 3 :, netstat 3 : bash netstat - a grep 8080 tcp 0 0 localhost:8080 localhost:1157 ESTABLISHED tcp 0 0 localhost:1157 localhost:8080 ESTABLISHED tcp 0 0 :8080 : LISTEN, 8080, 1157, ESTABLISHED, 1157, 8080, ESTABLISHED, LIS TEN : accept, accept,, accept, connect, (1 ) write all (2 ) read line (3 ) write all (4 ) read all (5 ) write all (6 ) read all : bash echo - cli

78 Hello World! Hello World! Hello World!,,,,, Ctrl + D, Linux Ctrl + D Ctrl + D, gets, cli requ,, close TCP, (1 ) cli requ, close, Linux, (2 ), close, 0, : TCP TCP FIN, F IN WAIT 1,, netstat : bash netstat grep 8080 tcp : :8080 FIN WAIT 1 TCP, FIN, CLOSE WAIT, FIN WAIT 2, netstat,, close( connfd),, netstat : 70

79 bash netstat grep 8080 tcp 0 0 localhost:8080 localhost:1157 CLOSE WAIT tcp 0 0 localhost:1157 localhost:8080 FIN WAIT 2 tcp 0 0 :8080.LISTEN, CLOSE WAIT, FIN, ;, F IN WAIT 2, FIN (3 ) TCP TCP F IN, read line, TCP F IN, read line 0,, read requ 0, serv respon (4 ) serv respon, close, 0, : TCP TCP FIN, TCP LAST ACK, TCP, netstat : bash netstat grep 8080 tcp : :1537 LAST ACK tcp 0 0 :8080. LISTEN TCP F IN, TIME WAIT, F IN, TIME WAIT MSL, TCP TCP FIN, TCP netstat : bash netstat grep 8080 tcp 0 0 localhost:1157 localhost:8080 TIME WAIT tcp 0 0 :8080. LISTEN TIME WAIT, (5 ),,,

80 ,, ( GDB) : bash gdb echo serv serv resp read requ,, read requ,, i GDB i 0 : gdb > set i = 0 i, serv resp, close, close, 0, TCP : TCP F IN, TCP FIN, TCP, FIN WAIT 2 netstat : bash netstat - a grep 8080 tcp 0 0 localhost:8080 localhost:1200 FIN WAIT 2 tcp 0 0 localhost:1200 localhost:8080 CLOSE WAIT tcp 0 0 :8080.LISTEN, F IN WAIT 2; FIN, CLOSE WAIT, read all, read, TCP FIN, read all 0, cli requ close, TCP : TCP F IN, TCP F IN,, TIME WAIT 2, MSL

81 , HT TP,,, 4.9 -, -, kill,, kill : bash ps x grep echo - serv 140 p0 S 0:02 echo - serv bash kill 140 [3] + Terminated echo serv, :, accept,,,,,,, TCP SYN,, ; TCP SY N,,,,,,, TCP F IN 3 :, cli requ write all ;, cli requ write all ;, read all F IN, -, FIN, -, F IN,,, FIN, 3 : write all F IN 73

82 write all,,,, TCP FIN, FIN,,, write,, write all TCP, TCP, TCP RST write all,, TCP RST, write all, TCP RST, write SIGP IPE,,,, SIGPI PE,, ( ) : # include < signal.h > int main() signal(sigpipe, SIG IGN); cli requ(); SIGP IPE, write all, E PIP E 74

83 cli requ,, write all F IN write all,,, TCP FIN, write,, write all TCP, TCP,, TCP RST, write all, read all, read all 0, TCP F IN cli requ,,, TCP RST, -, write all,,, TCP TCP RST, RST, read all, ECONNRESET-, read all F IN read all,,, TCP F IN, read all 0, cli requ,, 4.10,, RESET,,, : (1 ), read all,,, (2 ), write all, write, write all, read all,,,, : 75

84 TCP,, TCP, TCP,, TCP,,, read, ETIMEOUT ( ) -, TCP,, ICMP, TCP ICM P,, read all, ICMP, EHOSTU NREACH ENETU N REACH ( ICMP ),, read, 76

85 4.11,,,,,,,,,,,, : (1 ), read all,,,, (2 ), write all, write, write all, read all,,,, : TCP,, TCP, TCP,, TCP TCP,, TCP, TCP, RST TCP RST,, read, ECONNRESET

86 4.12,, : (1 ), read,,,,,,, (denial of service) : TCP TCP, (2 ), write all, write, TCP RST, RS T,, TCP RST, read, ECONNRESET 4.13 TCP, 3 : connect, accept read write close, close,, TCP RST ;, 78

87 5 UDP 5.1 UDP TCP, UDP TCP UDP TCP, UDP - UDP socket, bind, recvfrom UDP UDP socket, sendto, close UDP, UDP TCP, UDP 79

88 5.2 recvfrom sendto recvfrom, sendto, UDP : # include < sys/ socket.h > int recvfrom(int sockfd, void buf, int len, unsigned int flags, struct sockaddr from, socklen t addrlen); int sendto(int sockfd, const void msg, int len, unsigned int flags, const struct sockaddr to, int tolen); sockfd buf len read write, ; flay recvfrom from, ; addrlen sendto to ; addrlen recvfrom, ; - 1 sendto, ; - 1 UDP,, sendto UDP,, recvfrom, ;, recvfrom from NULL, addrlen NULL UDP sendto, UDP UDP, ; recvfrom, UDP UDP UDP UDP, sendto, sendto, UDP UDP, UPD IP, UDP UDP, UDP UDP UDP, UDP, sendto, EMSGSIZEUDP, sendto, UDP, UDP, UDP, sendto 0 UDP UDP,, UDP, UDP 5 2 UDP 80

89 5 2 UDP UDP, UDP, UDP, UDP, UDP recvfrom, ;,, UDP, recvfrom 0 TCP : TCP, 0,, TCP, ; UDP,, 0, 0, 5.3 UDP : UDP, : # include < sys/ types.h > # include < sys/ socket.h > # include < netinet/ in.h > # include < stdio.h > # define SERV PORT 8080 int main() int sockfd; struct sockaddr in addr; sockfd = socket(af INET, SOCK DGRAM, 0); if (sockfd < 0) fprintf(stderr, socket error.\ n ); exit(1); bzero(&addr, sizeof(addr)); addr.sin family = AF INET; 81

90 addr.sin addr.s addr = htonl(inaddr ANY); addr.sin port = htons(serv PORT); if (bind(sockfd, (struct sockaddr )&addr, sizeof(addr)) < 0) fprintf(stderr, bind error.\ n ); exit(1); udps respon(sockfd); close(sockfd); UDP, : sockfd = socket(af INET, SOCK DGRAM, 0);,, udps respon, 5.4 UDP : : # define MAX MSG SIZE 1024 void udps respon(int sockfd) struct sockaddr in addr; int addrlen; char msg[max MSG SIZE]; for ( ;; ) n = recvfrom(sockfd, msg, MAX MSG SIZE, 0, (struct sockaddr )&addr, &addrlen); sendto(sockfd, msg, n, 0, addr, addrlen); : recvfrom, 5.5 UDP UDP, : UDP,,

91 , UDP UDP, UDP, : TCP, UDP ; IP,, I P, I P 2.,, UDP TCP : UDP, UDP,, UDP,, ; TCP,,, TCP,, 5 3 UDP, 5 4 UDP 5 3 UDP 5 4 UDP 83

92 5 4,, TCP, UDP,, UDP 3. recvfrom,, recvfrom from 4. IP I P INADDR ANY, UDP, IP, IP, UDP TCP 5 1 TCP UDP 5 1 TCP UDP IP IP accept getsockpeer accept getsockpeer getsockname getsockname recvfrom recvfrom - getsockname UDP, : (1 ), I P, IP IP (2 ) IP UDP UDP, IP,,,,, SO REUSEADDR 5.6 UDP : UDP, : # include < sys/ types.h > # include < sys/ socket.h > # include < netinet/ in.h > 84

93 # include < stdio.h > int main(int argc, char int sockfd; struct sockaddr in addr; if (argc!= 3) argv[]) fprintf(stderr, usage: client ipaddr port \ n ); exit(1); sockfd = socket(af INET, SOCK DGRAM, 0); if (sockfd < 0) fprintf(stderr, socket error.\ n ); exit(1); bzero(&addr, sizeof(addr)); addr.sin family = AF INET; addr.sin port = htons(atoi(argv[2])); if (inet aton(argv[1], &addr.sin addr) < 0) fprintf(stderr, inet aton error.\ n ); exit(1); udpc requ(sockfd, &addr, sizeof(addr)); close(sockfd); socket,, udpc requ, 5.7 UDP : : # define MAX BUF SIZE 1024 void udpc requ(int sockfd,const struct sockaddr in addr,int len) char buf[max BUF SIZE]; int n; for (; fgets(buf, MAX BUF SIZE, stdin)!= NULL; ) sendto(sockfd, buf, strlen(buf), 0, addr, len); n = recvfrom(sockfd, buf, MAX BUF SIZE, 0, NULL, NULL); buf[n] = 0; 85

94 fputs(buf, stdout);, sendto, recvfrom, sendto recvfrom, ( Ctrl + D), 5.8 UDP UDP, : 1. UDP,, UDP, sendto, sendto, recvfrom sendto, UDP,, UDP IP, IP,, UDP UDP, IP IP IP IP,recvfrom,recvfrom I P, sendto, UDP, 2., recvfrom, sendto,,,, :,,, : # define MAX BUF SIZE 1024 void udpc requ(int sockfd, const struct sockaddr in addr,int len) 86

95 struct sockaddr in inaddr; int inaddrlen; char buf[max BUF SIZE]; int n; for (; fgets(buf, MAX BUF SIZE, stdin)!= NULL; ) sendto(sockfd, buf, strlen(buf), 0, addr, len); n = recvfrom(sockfd, buf, MAX BUF SIZE, 0, &inaddr, &inaddrlen); if (inaddrlen!= len memcmp(&inaddr, addr, len)!= 0) fprintf(stderr, unexpected response from % s, discarded.\ n,inet ntoa (inaddr.sin addr)); continue; buf[n] = 0; fputs(buf, stdout); recvfrom,,, :,,, recvfrom,, : connect, connect UDP 3. UDP,, recvfrom,,, : (1 ),, recvfrom (2 ),,,, recvfrom,,, recvfrom,, recvfrom 87

96 5.9 UDP UDP connect, TCP UDP connect 3, UDP UDP connect, UDP I P, connect ; TCP connect, TCP 3,, connect connect UDP UDP, connect UDP UDP UDP : 1. UDP UDP, UDP UDP 2., UDP UDP UDP UDP 5 5 UDP 5 5 UDP :,, UDP UDP UDP, UDP, UDP, ; UDP, UDP I P IP,,, UDP, connect, UDP UDP 88

97 3. write, write, write, UDP TCP, TCP : TCP, write, TCP write ; UDP, write,, UDP write UDP :, TCP, UDP UDP,, UDP,, UDP, ICMP, ICM P UDP, UDP sendto, sendto,,,, ECONNRESET UDP, U NIX ; UDP, Linux, UNIX,, UDP, U NIX, Linux SO BSDCOM PAT,,, Linux UDP ICMP,,, UDP ICMP,, UDP ICMP, UDP ICMP,,, ENETU NREACH EHOSTU N REACH,,, connect UDP UDP UDP, UDP 89

98 : (1 ) (2 ), U NIX UDP connect TCP, TCP connect connect, UDP : struct sockaddr in addr1, addr2; int udpfd; connect(udpfd, (struct sockaddr )&addr1, sizeof(addr1)); connect(udpfd, (struct sockaddr )&addr2, sizeof(addr2)); UDP TCP : TCP close ; UDP connect UDP UDP, connect,, connect, Posix connect AF SPEC, UDP : struct sockaddr in addr; int sockfd;... addr.sin family = AF UNSPEC;... connect(sockfd, (struct sockaddr )&addr, sizeof(addr)); U N, EAFNOSUPPOR T, UDP AF UNSP EC, UDP, UDP, : # include < sys/ socket.h > # include < sys/ types.h > # include < netinet/ in.h > int main(int argc, char argv[]) int sockfd; struct sockaddr in addr; if (argc!= 3) 90

99 fprintf(stderr, usage: client ipaddr port \ n ); exit(1); sockfd = socket(af INET, SOCK DGRAM, 0); if (sockfd < 0) fprintf(stderr, socket error.\ n ); exit(1); bzero(&addr, sizeof(addr)); addr.sin family = AF INET; addr.sin port = htons(atoi(argv[2])); if (inet aton(argv[1], &addr.sin addr) < 0) fprintf(stderr, inet aton error.\ n ); exit(1); if (connect(sockfd, (struct sockaddr )&addr,sizeof(addr)) < 0) fprintf(stderr, connect error.\ n ); exit(1); udpc requ(sockfd); close(sockfd); connect, UDP UDP, udpc requ udpc requ : # define MAX BUF SIZE 1024 void udpc requ(int sockfd) char buf[max BUF SIZE]; int n; for (; fgets(buf, MAX BUF SIZE, stdin)!= NULL; ) write(sockfd, buf, strlen(buf)); n = read(sockfd, buf, MAX BUF SIZE); if (n < 0) fprintf(stderr, read error: % s \ n, strerror(errno)); return; buf[n] = 0; fputs(buf, stdout); 91

100 , write, read read,, udpc requ, 5.10 UDP UDP 1. UDP UDP UDP, TCP : UDP, UDP UDP,,,,,,,,,,,,, UDP, DNS, T FT P RPC, UDP 2. UDP UDP,,,,,, UDP, UDP, 3. UDP UDP,, recvfrom,, UDP 92

101 ,, UDP :,,,,,,, :,,,,, 4. UDP UDP : - ( multicast),, TCP UDP,,,,, UDP TCP TCP, UDP, TCP, UDP, TCP, UDP TCP, TCP, 5.11 UDP recvfrom sendto UDP sendto recvfrom UDP connect UDP, UDP 93

102 6 6.1 Linux, Linux,,,,, 6.2 (fork exec) Linux, SHELL, SHELL Linux,,, init Linux, ( System Call) fork Linux vfork, fork, : # include < unistd.h > pid t fork(void); fork,, fork,, fork, ;, fork 0, - 1fork : if ((pid = fork()) == 0) / /... exit(0); else if (pid < 0) / / exit(1); 94

103 else / /... exit(0); fork, fork : fork :,, ; fork 0 Linux fork : fork,, ( ), ,,,,, fork, fork, fork 0 :, ;,,,,, getppid 95

104 ,,,, ( real) (effective), HOME, PATH, close - on - exec ( nice ) ( process group ID) ( session ID) ( umask ) : fork,,,, if exit, exit, if...then...,,, : # include < unistd.h > int main() pid t pid; char buf[128]; gets(buf); pid = fork(); if (pid == 0) printf( child: ); else printf( parent: ); 96

105 printf(% s \ n, buf); : bash share hello parent: hello child: hello, printf(% s \ n, buf),, 5, / etc/ passwd,, , 1, inode, (/ etc/ passwd), 1, 6 3, 5, 2, Linux,,, # include < unistd.h > # include < fcntl.h > # include < sys/ types.h > int main() 97

106 6 3 int fd; pid t pid; off t off; fd = open( / etc/ passwd, O RDONLY); off = lseek(fd, 10, SEEK CUR); pid = fork(); if (pid == 0) printf( child: position % d \ n, off); off = lseek(fd, 0, SEEK END); printf( child: change position to % d \ n, off); exit(0); else if (pid > 0) wait(null); off = lseek(fd, 0, SEEK CUR); printf( parent: position % d \ n, off); exit(0); else printf( fork error.\ n ); 98

107 / etc/ passwd, 10,,,,,, lseek, : bash shr fd child: position 10 child: change position to 532 parent: position 532 : (1 ),,,, (2 ),, Linux, Shell, HTT P CGI,,,, if, then, exec 6, : # include < unistd.h > int execve(const char path, char const argv[], char const envp[]); int execl(const char path, const char arg,); int execlp(const char file, const char arg,); int execle(const char path, const char arg,,char const envp[]); int execv(const char path, char const argv[]); int execvp(const char file, char const argv[]);, 5,, path, ; file, PATH, argv [ 0 ], N ULL, execve execle,,,, - 1 exec, exec exec,, 99

108 : exec, FD CLOEXEC, exec, FD CLOEXEC, 5 : # include < fcntl.h > fcntl(5, F SETFD, FD CLOEXEC); 6.3,, ( real user id) ( effective user id), kill exec setuid, setuid, setuid, setuid 1 setuid : bash # chmod + s/ usr/ bin/ ping / usr/ bin/ ping setuid 1 setuid,, / usr/ bin/ ping, setuid,,, setuid,, pingmount login 6.4 Linux,,,,,, : 1., 100

109 (read), 2.,,, 6 1 Linux 6 1 SIGHUP SIGI NT SIGQU IT core, core SIGILL core SIGTRAP core SIGBUS core SIGSEGV core SIGFPE core SIGIOT core I/ O SIGKILL SIGPIPE SIGALARM SIGT ERM SIGSTOP SIGTSTP SIGCONT SIGURG I/ O SIGIO I/ O SIGCHLD SIGT TOU SIGT TIN SIGXCPU CPU SIGXFSZ SIGWI NCH SIGPROF SIGUSR1 1 SIGUSR2 2 SIGVTALRM,, : 101

110 ,, core,,,, sigaction : # include < signal.h > int sigaction(int signum, const struct sigaction act,struct sigaction oldact); signum, SIGKILL SIGSTOP ; act ; oldact,, 0; - 1 sigaction : struct sigaction void ( sa handler)(int); sigset t sa mask; int sa flags; void ( sa restorer)(void);/ / ; : sa handler, 3,, SIG DFL ;, SIG IGN;, sa mask,, sa flags : SA ONESHOT SA RESETHAND, SA RESTART, SA NOCLDSTOP signum SIGCHLD, ( SIGSTOP ), SA NOMASK SA NODEF ER, Linux signal : 102

111 # include < signal.h > void ( signal(int sig, void ( func)(int)))(int);, signal,, sigaction SA ONESHOT,, Linux : # include < signal.h > int sigprocmask(int how,const sigset t set, sigset t oldset); int sigpending(sigset t set); int sigsuspend(const sigset t mask); sigprocmask, how : SIG BLOCK, set SIG UNBLOCK, set SIG SETMASK, set oldset sigpending ( pending), set sigsuspend mask,,,, Linux : # include < signal.h > int sigemptyset(sigset t set); int sigfillset(sigset t set); int sigaddset(sigset t set, int signum); int sigdelset(sigset t set, int signum); int sigismember(const sigset t set, int signum); sigemptyset ; sigfillset ; sigaddset ; sigdelset ; sigismember, Linux : (1 ) ( ),, SA ONESHOT (2 ),, sa mask (3 ),,,, Linux 103

112 (4 ) sigprocmask,,,,,, ;,,,, EINTR : # include < signal.h > # include < string.h > # include < errno.h > void sigint handler(int); int main() char buf[10]; int n; struct sigaction act; act.sa handler = sigint handler; sigemptyset(&act.sa mask); act.sa flags = 0; sigaction(sigint, &act, NULL); n = read(0, buf, sizeof(buf)); if (n < 0) if (errno == EINTR) printf( read interrupted \ n ); else printf( read error: % s \ n, strerror(errno)); write(1, buf, n); void sigint handler(int sig) return; sigaction SIGINT ( Ctrl + C ),, ; Ctrl + C, SIGINT, : bash sig int ^C read interrupted 104

113 kill : # include < sys/ types.h > # include < signal.h > int kill(pid t pid, int sig); pid, sig pid : : pid 0: - 1:, 0 1-1: pid,,, kill 6.5 Linux exit,,, SIGCHLD, (Zombie) ps, < zombie > void exit(int status); status exit :, exit,,, exit, status exit : (1 ), SIGHU P (2 ) (3 ), init (4 ) SIGCHLD 6.6, SIGCHLD,, Linux : 105

114 int main() int i; for (i = 0; i < 5; i ++ ) if (fork() == 0) exit(0); for (;;), ps : bash ps x PID TTY STAT TIME COMMAND 66 2 S 0:00 - bash 68 4 S 0:00 - bash 91 2 R 0:28 a.out 92 2 Z 0:00 (a.out < zombie > ) 93 2 Z 0:00 (a.out < zombie > ) 94 2 Z 0:00 (a.out < zombie > ) 95 2 Z 0:00 (a.out < zombie > ) 96 2 Z 0:00 (a.out < zombie > ) R 0:00 ps x SIGCHLD, SIGCHLD : 1. SIGCHLD sigaction SIGCHLD, : # include < signal.h > struct sigaction act, oldact; act.sa handler = SIG IGN; sigemptyset(&act.sa mask); act.sa flags = 0; if (sigaction(sigchld, &act, &oldact) < 0) perror( sigaction error \ n ); exit(1); SIGCHLD,, SIG IGN,, SIGCHLD,, 106

115 Linux, UNIX,, SIGCHLD, SIGCHLD,, : # include < signal.h > int main() struct sigaction act; int i; act.sa handler = SIG IGN; sigemptyset(&act.sa mask); act.flags = 0; sigaction(sigchld, &act, NULL); for (i = 0; i < 5; i ++ ) if (fork() == 0) exit(0); for (;;), : bash zombie 1 PID TTY STAT TIME COMMAND 66 2 S 0:00 - bash 68 4 S 0:00 - bash R 0:52 def 1 2. wait waitpid wait waitpid, : # include < sys/ wait.h > pid t wait(int statloc); pid t waitpid(pid t pid, int statloc, int option); wait waitpid :, statloc, exit wait ;, ;, ;, - 1waitpid pid, ; pid - 1, WNOHANG waitpid,,, 107

116 ,,, int pid, status; while ((pid = wait(&status)) > 0) printf( child % d died, exit code % d \ n, pid, status);,,, : # include < sys/ types.h > # include < sys/ wait.h > int main() int i; pid t pid; for (i = 0; i < 5; i ++ ) if (fork() == 0) printf( child % d \ n, getpid()); exit(0); for (; (pid = wait(&i)) > 0; ) printf( child % d died: % d \ n, pid, WEXITSTATUS(i)); : bash zombie 2 child 98 child 99 child 102 child 101 child 100 child 102 died: 0 child 101 died: 0 child 100 died: 0 child 99 died: 0 child 98 died: 0 3. SIGCHLD SIGCHLD,, : 108