求助：send函数本地发送，缓冲未满就EAGAIN错误

Question

两个程序，一个srv，一个cli，建立tcp连接后，cli 程序连续不断地发送指定大小的数据到srv程序，而srv程序不做任何接收
最后统计cli连续发送多少包后开始发送失败（返回-1，错误码为 EAGAIN）。

在我的测试中，在每次发的数据包的大小1024的情况下，

当srv与cli在同一主机上运行时，结果从8到30变化不定，这远远小于事先指定的缓冲大小64k

当srv与cli在不同主机上运行时，结果是固定的，一般约为缓冲大小/发送包大小，这个很容易理解

不解为什么两者在同一主机上运行时，会出现这种情况，

在我的应用中，由于客户端发送包小但短时间会发送很多包，server端接收处理不够及时，所以设置了较大的缓冲，
没想到在同一台机器上运行时缓冲没使用完就发送失败了

下面为我的测试程序，请大家多多指教！！！

代码如下，前面的是srv.c,后面的为cli.c，最后为Makefile，方便大家测试，测试时需修改cli.c中宏MY_TEST_IP指定的IP地址：

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <errno.h>
4. #include <string.h>
5. #include <sys/filio.h>
7. #include <sys/types.h>
8. #include <sys/socket.h>
9. #include <netinet/in.h>
10. #include <sys/time.h>        /* select */
11. #include <netdb.h>
13. #define MY_TEST_PORT         9011
15. int main()
16. {
17.         int ret;
19.         int s;
20.         int ns;
22.         struct sockaddr sa;
23.         struct sockaddr dest;
24.         struct sockaddr_in *sin;
25.         socklen_t destlen;
27.         fd_set rset;
29.         int optval;
30.         int optlen;
32.         s = socket(AF_INET, SOCK_STREAM, 0);
33.         if(s < 0)
34.         {
35.                 perror("socket:");
36.                 exit(1);
37.         }
39.         sin = (struct sockaddr_in *) &sa;
40.         sin->sin_family = AF_INET;
41.         sin->sin_port = htons(MY_TEST_PORT);
42.         sin->sin_addr.s_addr = INADDR_ANY;
44.         ret = bind(s, &sa, sizeof(sa));
45.         if(ret < 0)
46.         {
47.                 perror("bind:");
48.                 exit(1);
49.         }
51.         optval = 1;
52.         optlen = sizeof(optval);
54.         /*set non-block */
55.         do {
56.                 ret = ioctl(s, FIONBIO, &optval);
57.         } while(errno == EINTR);
59.         optval = 64*1024;
60.         optlen = sizeof(optval);
62.         /*set recv buf size */
63.         do {
64.                 ret = setsockopt(s,SOL_SOCKET,SO_RCVBUF,&optval,optlen);
65.         } while(errno == EINTR);
67.         /*set send buf size */
68.         do {
69.                 ret = setsockopt(s,SOL_SOCKET,SO_SNDBUF,&optval,optlen);
70.         } while(errno == EINTR);
71.        
73.         listen(s,5);
74.         destlen = sizeof(dest);
76.         while(1)
77.         {
78.                 FD_ZERO(&rset);
79.                 FD_SET(s,&rset);
81.                 select(s+1, &rset, NULL, NULL, NULL);
82.                 if(FD_ISSET(s,&rset))
83.                 {
84.                         ns = accept(s, &dest, &destlen);
85.                         printf("accept return %d errno %dn",ns,errno);
86.                 }
87.         }
88. }

复制代码

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <sys/types.h>
4. #include <sys/socket.h>
5. #include <sys/time.h>        /* select */
6. #include <errno.h>
7. #include <stropts.h>
8. #include <unistd.h>
9. #include <sys/filio.h>
11. #define MY_BUFFER_LEN         1024
13. #define MY_TEST_PORT        9011
14. #define MY_TEST_IP        "192.168.1.96"
16. int main(int argc, char *argv[])
17. {
18.         int ret;
19.         int s, ns;
20.         int optval,optlen;
21.         struct sockaddr sa;
22.         struct sockaddr dest;
23.         struct sockaddr_in *sin;
24.        
25.         int i;
27.         char *buf = NULL;
28.         int buflen;
30.         if(argc == 2)
31.         {
32.                 buflen = atoi(argv[1]);
33.                 if(buflen <= 0 || buflen > 64*1024)
34.                 {
35.                         buflen = 1024;
36.                 }
37.         }
38.         else
39.                 buflen = 1024;
41.         buf = calloc(buflen,1);
43.         setbuf(stdout,NULL);
45.         s = socket(AF_INET, SOCK_STREAM, 0);
46.        
47.         optval = 1;
48.         optlen = sizeof(optval);
50.         /*set non-block */
51.         do {
52.                 ret = ioctl(s, FIONBIO, &optval);
53.         } while(errno == EINTR);
55.         optval = 64*1024;
56.         optlen = sizeof(optval);
58.         /*set recv buff size*/
59.         do {
60.                 ret = setsockopt(s,SOL_SOCKET,SO_RCVBUF,&optval,optlen);
61.                 if(ret != 0 && errno != EINTR)
62.                         printf("setsockopt11 ret %d errno %dn",ret,errno);
63.         } while(errno == EINTR);
65.         /*set send buff size*/
66.         do {
67.                 ret = setsockopt(s,SOL_SOCKET,SO_SNDBUF,&optval,optlen);
68.                 if(ret != 0 && errno != EINTR)
69.                         printf("setsockopt22 ret %d errno %dn",ret,errno);
70.         } while(errno == EINTR);
72.         sin = (struct sockaddr_in *) &dest;
73.         memset(sin,0,sizeof(dest));
74.         sin->sin_family = AF_INET;
75.         sin->sin_port = htons(MY_TEST_PORT);
76.         sin->sin_addr.s_addr = inet_addr(MY_TEST_IP);
78.         ns = connect(s, &dest, sizeof(dest));
79.         if(ns < 0)
80.                 sleep(1);
82.         for(i = 0; i < 0x7FFFFFFF; i++)
83.         {
84.                 ret = send(s, buf, buflen, 0 );
85.                 if(ret < 0)
86.                 {
87.                         //printf("i %d ret %d errno %dn",i,ret,errno);
88.                         printf("%dn",i);
89.                         break;
90.                 }
91.         }
92. }

复制代码

1. #
2. #
3. #
4. CC = gcc
5. CFLAG = -g -c
6. LDFLAG =
7. LIBPATH = -lnsl -lsocket
9. SRC_FILE = ${SRV_SRC_FILE} ${CLI_SRC_FILE}
10. SRV_SRC_FILE = srv.c
11. CLI_SRC_FILE = cli.c
13. OBJ_FILE = ${SRV_OBJ_FILE} ${CLI_OBJ_FILE}
14. SRV_OBJ_FILE = srv.o
15. CLI_OBJ_FILE = cli.o
17. BIN_FILE = ${SRV_BIN_FILE} ${CLI_BIN_FILE}
18. SRV_BIN_FILE = srv
19. CLI_BIN_FILE = cli
21. all:
22.         ${BIN_FILE}
23. clean:
24.         rm -f ${OBJ_FILE}
25.         rm -f ${BIN_FILE}
27. ${SRV_BIN_FILE} : ${SRV_OBJ_FILE}
28.         ${CC} $^ -o $@ ${LDFLAG} ${LIBPATH}
29. ${SRV_OBJ_FILE} : ${SRV_SRC_FILE}
30.         ${CC} ${CFLAG} ${INCPATH} $^
32. ${CLI_BIN_FILE} : ${CLI_OBJ_FILE}
33.         ${CC} $^ -o $@ ${LDFLAG} ${LIBPATH}
34. ${CLI_OBJ_FILE} : ${CLI_SRC_FILE}
35.         ${CC} ${CFLAG} ${INCPATH} $^

复制代码

Answer 1

的确如此，看来SunOS对回环的socket缓冲区有不同的处理，没有提供好控制参数接口。同样的代码在linux上运行则表现的符合逻辑。

Answer 2

做一些补充：

user@test:~$uname -a
SunOS wfsrv 5.10 Generic_137138-09 i86pc i386 i86pc

在上面的测试中，减小发送包的大小一直到每次发送16或32字节，结果并没有发生变化，可见与缓冲大小无关的，

我用ndd /dev/tcp查看各种参数没发现有什么相关的

请大家多多指教，不知道的也可指点一下思路，谢谢了！