请教 linux c 网络编程 server/client 程序问题 (tcp)

rml

一 个 server/client 程序 (tcp)
client 端能与 server端连接 ,而且可以互相传递消息,

问题是 server端在 接收字符串数据时,只能接收大于设定值时(红色),才能运行完成,
想问一 下各位大大,如何才能实现  任意字符串长度 的通信啊?  先谢谢了

// accept data&
bzero((void *)data2, len);
readn(client_sockfd, (void *)data2,10);
printf("Server read line:%s\n", data2);



client 源代码如下

1. /* File: client.c */
   
2. #include <sys/types.h>;
   
3. #include <sys/socket.h>;
   
4. #include <netinet/in.h>;
   
5. #include <errno.h>;
   
6. #include <stdio.h>;
   
7. #include <errno.h>;
   
8. 
   
9. int main(int argc, char **argv)
   
10. {
    
11.         int fd;
    
12.         struct sockaddr_in address;
    
13.         int address_len;
    
14.         int rtval;
    
15.         char *data;
    
16.         static char zx[100];
    
17.         char data2[100];
    
18.         int len;
    
19. 
    
20.         //建立套接口
    
21.         fd = socket(AF_INET, SOCK_STREAM, 0);
    
22. 
    
23.         //联接
    
24.         address.sin_family = AF_INET;
    
25.         address.sin_addr.s_addr = inet_addr("127.0.0.1");
    
26.         address.sin_port = htons(1234);
    
27.         address_len = sizeof(address);
    
28. 
    
29.         rtval = connect(fd, (struct sockaddr *) &address, address_len);
    
30.         if (rtval == -1)
    
31.                 exit(1);
    
32. 
    
33.         //发送数据
    
34.         printf("Client enter sth: \n");
    
35.         scanf("%s", zx);
    
36.         data = zx;
    
37.         printf("\n");
    
38. 
    
39. 
    
40.         writen(fd, (void *) data, strlen(data));
    
41.         printf("Client sent line:\n%s\n", data);
    
42. 
    
43.         //接收数据
    
44.         readn(fd, (void *) data2, 100);
    
45.         printf("Client read line:\n%s\n", data2);
    
46. 
    
47.         printf("Client exit.\n");
    
48.         //关闭
    
49.         close(fd);
    
50. }
    
51. 
    
52. 
    
53. 
    
54. // 下面是三个函数: 读n个字节; 写n个字节; 读一行.
    
55. 
    
56. ssize_t readn(int fd, void *vptr, size_t n)
    
57. {
    
58.         ssize_t nleft, nread;
    
59.         char *ptr;
    
60. 
    
61.         ptr = vptr;
    
62.         nleft = n;
    
63.         while (nleft >; 0) {
    
64.                 if ((nread = read(fd, ptr, nleft)) < 0) {
    
65.                         if (errno == EINTR)
    
66.                                 nread = 0;
    
67.                         else
    
68.                                 return -1;
    
69.                 } else if (nread == 0)
    
70.                         break;        //EOF
    
71.                 nleft -= nread;
    
72.                 ptr += nread;
    
73.         }
    
74.         return (n - nleft);
    
75. }
    
76. 
    
77. ssize_t writen(int fd, void *vptr, size_t n)
    
78. {
    
79.         size_t nleft, nwritten;
    
80.         char *ptr;
    
81. 
    
82.         ptr = vptr;
    
83.         nleft = n;
    
84. 
    
85.         while (nleft >; 0) {
    
86.                 if ((nwritten = write(fd, ptr, nleft)) <= 0) {
    
87.                         if (errno == EINTR)
    
88.                                 nwritten = 0;
    
89.                         else
    
90.                                 return -1;        //error
    
91.                 }
    
92.                 nleft -= nwritten;
    
93.                 ptr += nwritten;
    
94.         }
    
95.         return n;
    
96. }
    
97. 
    
98. 
    
99. ssize_t readline(int fd, void *vptr, size_t maxlen)
    
100. {
     
101.         ssize_t n, rc;
     
102.         char c, *ptr;
     
103. 
     
104.         ptr = vptr;
     
105.         for (n = 1; n < maxlen; n++) {
     
106.               again:
     
107.                 if ((rc = read(fd, &c, 1)) == 1) {
     
108.                         *ptr++ = c;
     
109.                         if (c == '\n')
     
110.                                 break;        //readover
     
111.                 } else if (rc == 0) {
     
112.                         if (n == 1)
     
113.                                 return 0;        //EOF no data read
     
114.                         else
     
115.                                 break;        //EOF some data read
     
116.                 } else {
     
117.                         if (errno == EINTR)
     
118.                                 goto again;
     
119.                         return -1;        //error
     
120.                 }
     
121.         }
     
122.         *ptr = 0;
     
123.         return n;
     
124. }
     
125. 
     

复制代码

server1源代码

1. /* File: server1.c */
   
2. 
   
3. #include <stdio.h>;
   
4. #include <sys/types.h>;
   
5. #include <sys/socket.h>;
   
6. #include <netinet/in.h>;
   
7. #include <sys/time.h>;
   
8. #include <errno.h>;
   
9. 
   
10. int main(int argc, char **argv)
    
11. {
    
12.         int fd;
    
13.         int address_len;
    
14.         struct sockaddr_in address;
    
15.         fd_set fdset;
    
16. 
    
17.         // socket build
    
18.         fd = socket(AF_INET, SOCK_STREAM, 0);
    
19. 
    
20.         // bind
    
21.         address.sin_family = AF_INET;
    
22.         address.sin_addr.s_addr = htonl(INADDR_ANY);
    
23.         address.sin_port = htons(1234);
    
24.         address_len = sizeof(address);
    
25.         bind(fd, (struct sockaddr *) &address, address_len);
    
26. 
    
27.         // listen  
    
28.         listen(fd, 64);
    
29. 
    
30. 
    
31.         printf("waiting...");
    
32.         while (1) {
    
33.                 struct sockaddr_in client_address;
    
34.                 int len;
    
35.                 int client_sockfd;
    
36.                 char *data;
    
37.                 static char zx[100];
    
38.                 char data2[100];
    
39.                 struct timeval timeout;
    
40. 
    
41.                 // set timeout
    
42.                 timeout.tv_sec = 1;
    
43.                 timeout.tv_usec = 0;
    
44. 
    
45.                 // set fdset
    
46.                 FD_ZERO(&fdset);
    
47.                 FD_CLR(fd, &fdset);
    
48.                 FD_SET(fd, &fdset);
    
49.                 if ((select(fd + 1, &fdset, NULL, NULL, &timeout)) < 0) {
    
50.                         printf("cannot select.\n");
    
51.                         fflush(stdout);
    
52.                 }
    
53.                 if (FD_ISSET(fd, &fdset)) {
    
54.                         //&connect?
    
55.                         len = sizeof(client_address);
    
56.                         client_sockfd = accept(fd,
    
57.                                                (struct sockaddr *)
    
58.                                                &client_address, &len);
    
59. 
    
60.                         // accept data&
    
61.                         bzero((void *) data2, len);
    
62.                         readn(client_sockfd, (void *)data2,10);         //????????问题是不是出在这句啊????????????? : (  
    
63.                         printf("Server read line:%s\n", data2);
    
64. 
    
65.                         // post data
    
66. 
    
67.                         printf("Server enter sth:\n");
    
68.                         scanf("%s", zx);
    
69.                         data = zx;
    
70.                         printf("\n");
    
71. 
    
72.                         writen(client_sockfd, (void *) data, strlen(data));
    
73.                         printf("Server send line:%s\n", data);
    
74. 
    
75.                         close(client_sockfd);
    
76.                         printf("waiting...");
    
77.                         fflush(stdout);
    
78.                 } else {
    
79.                         printf(".");
    
80.                         fflush(stdout);
    
81.                 }
    
82.         }
    
83. }
    
84. 
    
85. 
    
86. 
    
87. // 下面是三个函数: 读n个字节; 写n个字节; 读一行.
    
88. 
    
89. ssize_t readn(int fd, void *vptr, size_t n)
    
90. {
    
91.         ssize_t nleft, nread;
    
92.         char *ptr;
    
93. 
    
94.         ptr = vptr;
    
95.         nleft = n;
    
96.         while (nleft >; 0) {
    
97.                 if ((nread = read(fd, ptr, nleft)) < 0) {
    
98.                         if (errno == EINTR)
    
99.                                 nread = 0;
    
100.                         else
     
101.                                 return -1;
     
102.                 } else if (nread == 0)
     
103.                         break;        //EOF
     
104.                 nleft -= nread;
     
105.                 ptr += nread;
     
106.         }
     
107.         return (n - nleft);
     
108. }
     
109. 
     
110. ssize_t writen(int fd, void *vptr, size_t n)
     
111. {
     
112.         size_t nleft, nwritten;
     
113.         char *ptr;
     
114. 
     
115.         ptr = vptr;
     
116.         nleft = n;
     
117. 
     
118.         while (nleft >; 0) {
     
119.                 if ((nwritten = write(fd, ptr, nleft)) <= 0) {
     
120.                         if (errno == EINTR)
     
121.                                 nwritten = 0;
     
122.                         else
     
123.                                 return -1;        //error
     
124.                 }
     
125.                 nleft -= nwritten;
     
126.                 ptr += nwritten;
     
127.         }
     
128.         return n;
     
129. }
     
130. 
     
131. 
     
132. ssize_t readline(int fd, void *vptr, size_t maxlen)
     
133. {
     
134.         ssize_t n, rc;
     
135.         char c, *ptr;
     
136. 
     
137.         ptr = vptr;
     
138.         for (n = 1; n < maxlen; n++) {
     
139.               again:
     
140.                 if ((rc = read(fd, &c, 1)) == 1) {
     
141.                         *ptr++ = c;
     
142.                         if (c == '\n')
     
143.                                 break;        //readover
     
144.                 } else if (rc == 0) {
     
145.                         if (n == 1)
     
146.                                 return 0;        //EOF no data read
     
147.                         else
     
148.                                 break;        //EOF some data read
     
149.                 } else {
     
150.                         if (errno == EINTR)
     
151.                                 goto again;
     
152.                         return -1;        //error
     
153.                 }
     
154.         }
     
155.         *ptr = 0;
     
156.         return n;
     
157. }
     

复制代码

win_hate

1、你的 readn 多数情况下读满指定字节才返回。

2、用 read 就可以达到你的目的。

rml

先谢谢 win_hate  大哥了

1.  你的 readn 多数情况下读满指定字节才返回。
设置的是 10个
就是这段代码: readn(client_sockfd, (void *)data2,10);
后面的那三个: readn writen 还有 writeline 是 richard steverns 他老人家书上的例子.


2. 用 read 就可以达到你的目的。
是直接用 read 语句来读吗? 就是说不调用readn函数,直接在主程序中实现?

yuxh

一般一个TCP/IP包最好加一个长度，接收时先收长度，再根据长度取后继包文
read(socket, buffer, len)得到一次发送的数据，返回的结果可能少于len个，一般只在短连接中用这种办法，但包文不能太大，至少不能大于SOCKET缓冲

rml

下面 是 我在机器上的运行步骤于结果:

1. 开server 端

[root@localhost root]# cd cs
[root@localhost cs]#  cd server/
[root@localhost server]#  ./server9
waiting.........


2. 开client 端 ( 在新开的另外一个终端上运行)

[root@localhost root]# cd cs
[root@localhost cs]# cd client/
[root@localhost client]# ./zx9
Client enter sth:

注: zx9 是 client 的文件名,这个时候,另一个终端 ( server 终端) 的光标停下来等待



未写完,先回家吃饭去,晚上再来问, 谢谢 楼上 两位大大了 ~~