read函数返回值的困惑

skychongrichie

最近在学习《unix网络编程》，在第5章内容中有个例子：在客户与服务器之间传递二进制结构，让人百思不得其解的是为嘛在Readn函数中调用read函数读取数据时，直接返回0？客户端明明已经把数据write进去了，难道是木有flush，导致客户端套接字发送缓冲区中的数据根本木有发送给服务器？代码中省略了头文件包含，代码跟下面是客户端代码：

1. 
   
2. #define MAXLINE 4096
   
3. #define SERV_PORT 9875
   
4. #define SA struct sockaddr
   
5. 
   
6. struct args
   
7. {
   
8.         long arg1;
   
9.         long arg2;
   
10. };
    
11. 
    
12. struct result
    
13. {
    
14.         long sum;
    
15. };
    
16. 
    
17. void print_errno()
    
18. {
    
19.         printf("stderr:%s\n",strerror(errno));
    
20. }
    
21. 
    
22. void err_quit(const char* err_msg)
    
23. {
    
24.         printf("%s",err_msg);
    
25.         printf("\n");
    
26.         return;
    
27. }
    
28. 
    
29. ssize_t Readn(int fd,void *vptr,size_t n)
    
30. {
    
31.         size_t nleft;
    
32.         ssize_t nread;
    
33.         char* ptr;
    
34.         ptr = reinterpret_cast<char*>(vptr);
    
35.         nleft = n;
    
36.         while(nleft > 0)
    
37.         {
    
38.                 if((nread = read(fd,ptr,nleft) < 0))
    
39.                 {
    
40.                         if(errno == EINTR)
    
41.                                 nread = 0;
    
42.                         else
    
43.                                 return -1;
    
44.                 }else if(nread == 0)
    
45.                         break;//EOF
    
46.                 nleft -= nread;
    
47.                 ptr += nread;
    
48.         }
    
49.         return n - nleft;
    
50. 
    
51. }
    
52. 
    
53. ssize_t Writen(int fd,const void *vptr,size_t n)
    
54. {
    
55.         size_t nleft;
    
56.         ssize_t nwritten;
    
57.         const char* ptr;
    
58. 
    
59.         ptr = reinterpret_cast<const char*>(vptr);
    
60.         nleft = n;
    
61.         while(nleft > 0)
    
62.         {
    
63.                 if((nwritten = write(fd,ptr,nleft)) <= 0)
    
64.                 {
    
65.                         if(nwritten < 0 && errno == EINTR)
    
66.                                 nwritten = 0;
    
67.                         else
    
68.                         {
    
69.                                 print_errno();
    
70.                                 return -1;
    
71.                         }
    
72.                 }
    
73.                 nleft -= nwritten;
    
74.                 ptr += nwritten;
    
75.         }
    
76. 
    
77.         return n - nleft;
    
78. }
    
79. 
    
80. void str_cli_new(FILE* fp,int sockfd)
    
81. {
    
82.         char sendline[MAXLINE];
    
83.         struct args args;
    
84.         struct result result;
    
85.         while(fgets(sendline,MAXLINE,fp) != NULL)
    
86.         {
    
87.                 if(sscanf(sendline,"%ld%ld",&args.arg1,&args.arg2) != 2)
    
88.                 {
    
89.                         printf("invalid input:%s",sendline);
    
90.                         continue;
    
91.                 }
    
92.                 printf("arg1:%ld arg2:%ld\n",args.arg1,args.arg2);
    
93.                 Writen(sockfd,&args,sizeof(args));
    
94.                 if(Readn(sockfd,&result,sizeof(result)) == 0)
    
95.                         err_quit("str_cli:server terminated prematurely");
    
96.                 printf("%ld\n",result.sum);
    
97.         }
    
98. }
    
99. 
    
100. int main(int argc,char** argv)
     
101. {
     
102.         int sockfd;
     
103.         struct sockaddr_in servaddr;
     
104.         if(argc != 2)
     
105.                 err_quit("usage:tcpcli<IPaddress>");
     
106. 
     
107.         sockfd = socket(AF_INET,SOCK_STREAM,0);
     
108. 
     
109.         bzero(&servaddr,sizeof(servaddr));
     
110.         servaddr.sin_family = AF_INET;
     
111.         servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
     
112.         servaddr.sin_port = htons(SERV_PORT);
     
113.         inet_pton(AF_INET,argv[1],&servaddr.sin_addr);
     
114. 
     
115.         signal(SIGPIPE,SIG_IGN);
     
116. 
     
117.         int res = connect(sockfd,(SA*)&servaddr,sizeof(servaddr));
     
118.         printf("The result of connection is %d\n",res);
     
119.         if(res < 0)
     
120.                 printf("stderr:%s",strerror(errno));
     
121.         str_cli_new(stdin,sockfd);
     
122.         if(errno == EPIPE)
     
123.                 printf("Broken pipe\n");
     
124.         else
     
125.                 printf("errno is %d",errno);
     
126.         exit(0);
     
127. }
     

复制代码

服务器代码：

1. #define        MAXLINE                4096
   
2. #define        LISTENQ                1024
   
3. #define        SERV_PORT        9875
   
4. #define SA struct sockaddr
   
5. 
   
6. typedef void Sigfunc(int);
   
7. 
   
8. void sig_chld(int signo);
   
9. Sigfunc* signal(int signo,Sigfunc* func);
   
10. 
    
11. struct args
    
12. {
    
13.         long arg1;
    
14.         long arg2;
    
15. };
    
16. 
    
17. struct result
    
18. {
    
19.         long sum;
    
20. };
    
21. 
    
22. void err_sys(const char* err_msg)
    
23. {
    
24.         printf("%s",err_msg);
    
25.         printf("\n");
    
26.         exit(0);
    
27. }
    
28. 
    
29. void print_errno()
    
30. {
    
31.         printf("stderr:%s\n",strerror(errno));
    
32. }
    
33. 
    
34. ssize_t Readn(int fd,void *vptr,size_t n)
    
35. {
    
36.         size_t nleft;
    
37.         ssize_t nread;
    
38.         char* ptr;
    
39.         printf("Readn begin here.\n");
    
40.         ptr = reinterpret_cast<char*>(vptr);
    
41.         nleft = n;
    
42.         while(nleft > 0)
    
43.         {
    
44.                 if((nread = read(fd,ptr,nleft) < 0))
    
45.                 {
    
46.                         if(errno == EINTR)
    
47.                         {
    
48.                                 printf("EINTR error\n");
    
49.                                 nread = 0;
    
50.                         }
    
51.                         else
    
52.                         {
    
53.                                 print_errno();
    
54.                                 printf("error in function Readn\n");
    
55.                                 return -1;
    
56.                         }
    
57.                 }else if(nread == 0)
    
58.                 {
    
59.                         printf("EOF");
    
60.                         break;//EOF
    
61.                 }
    
62.                 nleft -= nread;
    
63.                 ptr += nread;
    
64.         }
    
65.         return n - nleft;
    
66. }
    
67. 
    
68. ssize_t Writen(int fd,const void *vptr,size_t n)
    
69. {
    
70.         size_t nleft;
    
71.         ssize_t nwritten;
    
72.         const char* ptr;
    
73. 
    
74.         ptr = reinterpret_cast<const char*>(vptr);
    
75.         nleft = n;
    
76.         while(nleft > 0)
    
77.         {
    
78.                 if((nwritten = write(fd,ptr,nleft)) <= 0)
    
79.                 {
    
80.                         if(nwritten < 0 && errno == EINTR)
    
81.                                 nwritten = 0;
    
82.                         else
    
83.                         {
    
84.                                 print_errno();
    
85.                                 return -1;
    
86.                         }
    
87.                 }
    
88.                 nleft -= nwritten;
    
89.                 ptr += nwritten;
    
90.         }
    
91. 
    
92.         return n - nleft;
    
93. }
    
94. 
    
95. void str_echo_new(int sockfd)
    
96. {
    
97.         ssize_t n;
    
98.         struct args args;
    
99.         struct result result;
    
100.         for(;;)
     
101.         {
     
102.                 if((n = Readn(sockfd,&args,sizeof(args))) == 0)
     
103.                 {
     
104.                         return;
     
105.                 }
     
106.                 printf("arg1:%ld arg2:%ld\n",args.arg1,args.arg2);
     
107.                 result.sum = args.arg1 + args.arg2;
     
108.                 Writen(sockfd,&result,sizeof(result));
     
109.         }
     
110. }
     
111. 
     
112. int main()
     
113. {
     
114.         int listenfd,connfd;
     
115.         pid_t childpid;
     
116.         socklen_t clilen;
     
117.         struct sockaddr_in cliaddr,servaddr;
     
118.         listenfd = socket(AF_INET,SOCK_STREAM,0);
     
119.         bzero(&servaddr,sizeof(servaddr));
     
120.         servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
     
121.         servaddr.sin_port = htons(SERV_PORT);
     
122.         int bind_res = bind(listenfd,(SA*)&servaddr,sizeof(servaddr));
     
123.         if(bind_res < 0)
     
124.                 print_errno();
     
125. 
     
126.         listen(listenfd,LISTENQ);
     
127.         signal(SIGCHLD,sig_chld);
     
128.         if(bind_res < 0)
     
129.                 print_errno();
     
130. 
     
131.         for(;;)
     
132.         {
     
133.                 clilen = sizeof(cliaddr);
     
134.                 if((connfd = accept(listenfd,(SA*)&servaddr,&clilen)) < 0)
     
135.                 {
     
136.                         if(errno == EINTR)
     
137.                                 continue;
     
138.                         else
     
139.                                 err_sys("accept error");
     
140.                 }
     
141.                 printf("An connection has been received.\n");
     
142.                 if((childpid = fork()) == 0)
     
143.                 {
     
144.                         close(listenfd);
     
145.                         str_echo_new(connfd);
     
146.                         close(connfd);
     
147.                         exit(0);
     
148.                 }
     
149.                 close(connfd);
     
150.         }
     
151. }
     

复制代码

代码跟书中的代码有点儿出入，不过结构基本上一样，启动服务器，然后启动客户端，命令行参数时127.0.0.1,可以发现服务器客户端连接成功，然后在客户端输入两个整数，回车，如果调试的可以发现write操作是成功的，也就是数据至少成功写入了套接字的发送缓冲区。不过服务器这边在fork子进程中，试图调用read操作去读取对应套接字接受缓冲区内容时，返回值为0，难道服务器响应套接字根本没有接收到数据？为什么呢？这个问题困扰小菜几天了，往各位大神不吝赐教哈