关于socket 传送文件的问题 [困惑]

rambo0808

关于socket 传送文件的问题 [困惑]

这几天一直被这个问题困扰着

编写了一个socket 传送BMP 图像的程序

client 向 server 传送client.bmp

但是在server 端接受到的图像不能打开

用 UltraEdit  打开client发送的 client.bmp图像和server接受的图像  server.bmp 对比，

server.bmp文件的前面 1448个字节 与 client.bmp的前1448个字节一样

但是server.bmp文件第1448个字节后的全部字节都为 0x00了

所以 server.bmp 所显示出来的几乎就是黑色的图片了

我的问题是 ---》 传送的是非0值，为什么收了一部分后就全变为0了呢?

请大虾们指点一下，我参考了资料+百度这个问题，还是百思不得其解。


我把我的代码附上

1. 
   
2. ----------server-----------
   
3. #include <sys/types.h>
   
4. #include <sys/socket.h>
   
5. #include <stdio.h>
   
6. #include <stdlib.h>
   
7. #include <errno.h>
   
8. #include <string.h>
   
9. #include <unistd.h>
   
10. #include <netinet/in.h>
    
11. 
    
12. #define SERVPORT 3333
    
13. #define BACKLOG 10
    
14. #define MAX_CONNECTED_NO 10
    
15. #define MAXDATASIZE 100*100*3+54
    
16. 
    
17. int main()
    
18. {
    
19.          struct sockaddr_in  server_sockaddr,client_sockaddr;
    
20.          int sin_size,recvbytes;
    
21.          int sockfd,client_fd;
    
22.          char buf[MAXDATASIZE];
    
23.          int nwrite,i;
    
24.        
    
25.          FILE *fbmp;
    
26.          char bmpdata[100*100*3+54];       
    
27.        
    
28.         if (( fbmp = fopen("server.bmp", "w+")) == NULL)
    
29.                    {
    
30.                    printf("Open  server bmp error !\n");
    
31.                    exit(-1);
    
32.             }
    
33. 
    
34.          
    
35.          if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
    
36.                    perror("socket");
    
37.                    exit(1);
    
38.          }
    
39. 
    
40.    printf("socket success!,sockfd = %d\n",sockfd);
    
41.    
    
42.    server_sockaddr.sin_family = AF_INET;         
    
43.    server_sockaddr.sin_port = htons(SERVPORT);                 
    
44.    server_sockaddr.sin_addr.s_addr = INADDR_ANY;
    
45.    
    
46.    bzero(&(server_sockaddr.sin_zero), 8);
    
47.    
    
48.    if(bind(sockfd, (struct sockaddr *)&server_sockaddr, sizeof(struct sockaddr)) == -1 ){
    
49.        perror("bind");
    
50.        exit(1);           
    
51.           }                 
    
52.          
    
53.          printf("bind success!\n");
    
54.          
    
55.          if(listen(sockfd, BACKLOG) == -1){
    
56.                    perror("listen");
    
57.                    exit(1);                  
    
58.          }
    
59.          
    
60.          printf("listening - - - \n");
    
61.          
    
62.          if( (client_fd = accept(sockfd, (struct sockaddr *)&client_sockaddr, &sin_size)) == -1 ){
    
63.                     perror("accept");
    
64.                     exit(1);
    
65.        }
    
66.        
    
67.         if(( recvbytes = recv(client_fd, bmpdata, MAXDATASIZE, 0)) == -1){
    
68.                 perror("recv");
    
69.                 exit(1);
    
70.         }
    
71. 
    
72. 
    
73.     for( i = 0  ; i< MAXDATASIZE ; i++ )
    
74.          {   
    
75.                    printf("%x - ",bmpdata[i] ) ;
    
76.          }
    
77. 
    
78. if ( nwrite = fwrite (bmpdata,MAXDATASIZE,1, fbmp  ) < 0)
    
79.              {
    
80.                      printf("Write  BMP error !\n");
    
81.                     exit(-1);
    
82.       }
    
83. 
    
84.     fclose(fbmp);
    
85.     close(sockfd);
    
86. 
    
87. }
    
88. 
    
89. 
    
90. ---------------client---------------------
    
91. 
    
92. #include <sys/types.h>
    
93. #include <sys/socket.h>
    
94. #include <stdio.h>
    
95. #include <stdlib.h>
    
96. #include <errno.h>
    
97. #include <string.h>
    
98. #include <unistd.h>
    
99. #include <netinet/in.h>
    
100. #include <netdb.h>
     
101. 
     
102. #define SERVPORT 3333
     
103. 
     
104. #define MAXDATASIZE 100*100*3+54
     
105. 
     
106. main( int argc , char *argv[] )
     
107. {
     
108.          struct hostent *host;
     
109.    struct sockaddr_in serv_addr;
     
110.          int sockfd,sendbytes;
     
111.          char buf[MAXDATASIZE];
     
112.          int bmpsize = 0,
     
113.              i,
     
114.              headersize = 0,
     
115.              pixelsize = 0;
     
116.          
     
117.          FILE *fbmp;
     
118.          char bmpdata[100*100*3+54];
     
119.          
     
120.         if (( fbmp = fopen("client.bmp", "r")) == NULL)
     
121.                    {
     
122.                    printf("Open client bmp error !\n");
     
123.                    exit(-1);
     
124.             }   
     
125.   
     
126. 
     
127.   fseek(fbmp,0,SEEK_SET);
     
128.   fread(bmpdata,MAXDATASIZE,1,fbmp);
     
129.   
     
130.    if( argc < 2) {
     
131.                    fprintf(stderr, "Please enter the server's hostname!\n");
     
132.                    exit(1);
     
133.    }
     
134.    
     
135.    if( (host = gethostbyname(argv[1])) == NULL ){
     
136.               perror("gethostbyname");
     
137.               exit(1);          
     
138.    }
     
139.          
     
140.    if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
     
141.                    perror("socket");
     
142.                    exit(1);
     
143.    }
     
144. 
     
145.    printf("socket success!,socket = %d\n",sockfd);
     
146.    
     
147.    serv_addr.sin_family = AF_INET;         
     
148.    serv_addr.sin_port = htons(SERVPORT);                 
     
149.    serv_addr.sin_addr = *( (struct in_addr *)host->h_addr );
     
150.    
     
151.    bzero(&(serv_addr.sin_zero), 8);
     
152.    
     
153.    if( connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr)) == -1 ){
     
154.        perror("connect");
     
155.        exit(1);           
     
156.     }                 
     
157.          
     
158.    printf("connect success!\n");
     
159.          
     
160. 
     
161.   if(( sendbytes = send(sockfd, bmpdata ,bmpsize, 0)) == -1){
     
162.                 perror("send");
     
163.                 exit(1);
     
164.     }
     
165. 
     
166. 
     
167.     for( i = 0  ; i< MAXDATASIZE ; i++ )
     
168.          {   
     
169.            printf("%x - ",bmpdata[i] ) ;
     
170.          }
     
171.          
     
172.   printf("send over!\n");
     
173.   
     
174.   fclose(fbmp);
     
175. close(sockfd);
     
176. 
     
177. }
     
178. 
     

复制代码

rambo0808

#define MAXDATASIZE 100*100*3+54

我传的是一个确定大小的BMP

h0tr0ck

是不是该作为二进制文件打开读写？

hgcwhz

可能是recv接收到的字节数不正确，你可以尝试修改一下这段代码

1. 
   
2. if(( recvbytes = recv(client_fd, bmpdata, MAXDATASIZE, 0)) == -1){
   
3.                 perror("recv");
   
4.                 exit(1);
   
5.         }
   

复制代码

判断一下recvbytes 的大小。

cuzzg

你试着用二进制格式打开或读写文件试试看。

rambo0808

感谢论坛朋友们的建议
根据大家的建议
我分别用了 recv(client_fd, bmpdata, MAXDATASIZE, MSG_WAITALL) 和循环的方法来做

但是结果还是不很理想

一.用  recv(client_fd, bmpdata, MAXDATASIZE, MSG_WAITALL) 来解决
  现在想把 800*800 以下的任意 BMP传过去， 用以下的代码，试验了很多BMP 图片，也发现了几个有意思的现

象
  1.如果位图大小大于 1MB 的时候，server.bmp 最后的填充大小为 0k ，recv，send的返回值都比位图本身大

小要小
   例如： 位图大小为 1418486 bytes，而 send 返回值为 712416，recv返回值为 641078.

  2.如果位图大小约为 800k 的时候，server.bmp 最后的填充大小为 client.bmp原始大小，但是位图只能显示

一大部分，剩余部分全为黑色    （0x00），recv，send的返回值都比位图本身大小要小
   例如： 位图大小为 814502 bytes，而 send 返回值为 705176，recv返回值为 641078.

   奇怪：recv 返回都为 641078 bytes

   如果位图大小为 600K 以下的话，就可以完全正确显示。百思不得其解

1. 
   
2. -------client-----------
   
3. 
   
4. #include <sys/types.h>
   
5. #include <sys/socket.h>
   
6. #include <stdio.h>
   
7. #include <stdlib.h>
   
8. #include <errno.h>
   
9. #include <string.h>
   
10. #include <unistd.h>
    
11. #include <netinet/in.h>
    
12. #include <netdb.h>
    
13. 
    
14. #define SERVPORT 3333
    
15. 
    
16. #define MAXDATASIZE 800*800+1024
    
17. 
    
18. 
    
19. main( int argc , char *argv[] )
    
20. {
    
21.          struct hostent *host;
    
22.    struct sockaddr_in serv_addr;
    
23.          int sockfd,sendbytes;
    
24.          char buf[MAXDATASIZE];
    
25.          int bmpsize = 0,
    
26.              i,
    
27.              headersize = 0,
    
28.              pixelsize = 0;
    
29.          
    
30.          FILE *fbmp;
    
31.          char bmpdata[MAXDATASIZE];
    
32.          
    
33. if (( fbmp = fopen("client.bmp", "r")) == NULL)
    
34.          {
    
35.            printf("Open client bmp error !\n");
    
36.            exit(-1);
    
37.            }
    
38. 
    
39. 
    
40.   fseek(fbmp,10,SEEK_SET);
    
41.   fread(&headersize,4,1,fbmp);
    
42.   printf("This BMP's headersize = %d \n" , headersize);
    
43.   
    
44.   fseek(fbmp,34,SEEK_SET);
    
45.   fread(&pixelsize,4,1,fbmp);
    
46.   printf("This BMP's pixelsize = %d \n" , pixelsize);   
    
47.   
    
48.   bmpsize = headersize + pixelsize ;
    
49. 
    
50.   printf("This BMP's  bmpsize = %d \n" , bmpsize);   
    
51.   
    
52. 
    
53.   fseek(fbmp,0,SEEK_SET);
    
54.   fread(bmpdata,MAXDATASIZE,1,fbmp);
    
55.   
    
56.   
    
57. if( argc < 2) {
    
58.          fprintf(stderr, "Please enter the server's hostname!\n");
    
59.            exit(1);
    
60.     }
    
61.    
    
62. if( (host = gethostbyname(argv[1])) == NULL ){
    
63.               perror("gethostbyname");
    
64.               exit(1);          
    
65.    }
    
66.          
    
67.   if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
    
68.                    perror("socket");
    
69.                    exit(1);
    
70.          }
    
71. 
    
72.    printf("socket success!,socket = %d\n",sockfd);
    
73.    
    
74.    serv_addr.sin_family = AF_INET;         
    
75.    serv_addr.sin_port = htons(SERVPORT);                 
    
76.    serv_addr.sin_addr = *( (struct in_addr *)host->h_addr );
    
77.    
    
78.    bzero(&(serv_addr.sin_zero), 8);
    
79.    
    
80.    if( connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr)) == -1 ){
    
81.        perror("connect");
    
82.        exit(1);           
    
83.           }                 
    
84.          
    
85.          printf("connect success!\n");         
    
86. 
    
87.   if(( sendbytes = send(sockfd, bmpdata ,bmpsize, 0)) == -1){
    
88.                 perror("send");
    
89.                 exit(1);
    
90.         }
    
91.           printf("sent connection :%d\n", sendbytes );
    
92. 
    
93.          
    
94.   printf("send over!\n");
    
95.   
    
96.   fclose(fbmp);
    
97.   close(sockfd);
    
98. 
    
99. }
    
100. 
     
101. --------------------server-----------------------
     
102. 
     
103. #include <sys/types.h>
     
104. #include <sys/socket.h>
     
105. #include <stdio.h>
     
106. #include <stdlib.h>
     
107. #include <errno.h>
     
108. #include <string.h>
     
109. #include <unistd.h>
     
110. #include <netinet/in.h>
     
111. 
     
112. #define SERVPORT 3333
     
113. #define BACKLOG 10
     
114. #define MAX_CONNECTED_NO 10
     
115. 
     
116. #define MAXDATASIZE 800*800+1078
     
117. 
     
118. 
     
119. 
     
120. int main()
     
121. {
     
122.          struct sockaddr_in  server_sockaddr,client_sockaddr;
     
123.          int sin_size,recvbytes;
     
124.          int sockfd,client_fd;
     
125.          char buf[MAXDATASIZE];
     
126.          int nwrite,i;
     
127.          int headersize,pixelsize,bmpsize;
     
128.        
     
129.          FILE *fbmp;
     
130.          char bmpdata[MAXDATASIZE];       
     
131.        
     
132. if (( fbmp = fopen("server.bmp", "w+")) == NULL)
     
133.           {
     
134.                    printf("Open  server bmp error !\n");
     
135.                    exit(-1);
     
136.             }
     
137. 
     
138.          
     
139. if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
     
140.                    perror("socket");
     
141.                    exit(1);
     
142.          }
     
143. 
     
144.    printf("socket success!,sockfd = %d\n",sockfd);
     
145.    
     
146.    server_sockaddr.sin_family = AF_INET;         
     
147.    server_sockaddr.sin_port = htons(SERVPORT);                 
     
148.    server_sockaddr.sin_addr.s_addr = INADDR_ANY;
     
149.    
     
150.    bzero(&(server_sockaddr.sin_zero), 8);
     
151.    
     
152.    if(bind(sockfd, (struct sockaddr *)&server_sockaddr, sizeof(struct sockaddr)) == -1 ){
     
153.        perror("bind");
     
154.        exit(1);           
     
155.           }
     
156.          
     
157.          printf("bind success!\n");
     
158.          
     
159.          
     
160.          
     
161.    if(listen(sockfd, BACKLOG) == -1){
     
162.                    perror("listen");
     
163.                    exit(1);                  
     
164.          }
     
165.          
     
166.          printf("listening - - - \n");
     
167.          
     
168.   if( (client_fd = accept(sockfd, (struct sockaddr *)&client_sockaddr, &sin_size)) == -1 ){
     
169.                     perror("accept");
     
170.                     exit(1);
     
171.   }
     
172.        
     
173. 
     
174.   if(( recvbytes = recv(client_fd, bmpdata, MAXDATASIZE, MSG_WAITALL)) == -1){
     
175.                 perror("recv");
     
176.                 exit(1);
     
177.         }
     
178.          
     
179.          
     
180.          
     
181.           printf("received a connection :%d\n", recvbytes );
     
182. 
     
183. 
     
184. 
     
185.   headersize =((bmpdata[13] & 0x000000ff) *256*256*256 ) + ((bmpdata[12] & 0x000000ff) *256*256 )
     
186. 
     
187. \
     
188.               + ( (bmpdata[11] & 0x000000ff) *256 ) + (bmpdata[10] & 0x000000ff) *1 ;
     
189. 
     
190.   
     
191.   pixelsize =((bmpdata[37] & 0x000000ff) *256*256*256 ) + ((bmpdata[36] & 0x000000ff) *256*256 ) +
     
192. 
     
193. \
     
194.               ( (bmpdata[35] & 0x000000ff) *256 ) + (bmpdata[34] & 0x000000ff) *1 ;
     
195.   
     
196. 
     
197.   bmpsize = headersize + pixelsize;         
     
198. 
     
199. 
     
200. 
     
201. if ( nwrite = fwrite (bmpdata, bmpsize,1, fbmp  ) < 0)
     
202.              {
     
203.                      printf("Write  BMP error !\n");
     
204.                     exit(-1);
     
205.       }
     
206. 
     
207.   fclose(fbmp);
     
208.   close(sockfd);
     
209. 
     
210. }
     
211. 
     

复制代码

rambo0808

二.用 循环的方法来解决

  1.如果位图大小大于 1MB 的时候，server.bmp 最后的填充大小为 1k ，且填充的值全为0x00，send的返回值都比位图本身大小要小
   例如： 位图大小为 1418486 bytes，而 send 返回值为 14480，recv循环返回值为 1.

  2.如果位图大小约为 800k 的时候，server.bmp 最后的填充大小为 1K. 且填充的值全为0x00，send的返回值比位图本身大小要小
   例如： 位图大小为 762054 bytes，而 send 返回值为 50680 ，recv循环返回值为 1.

   如果位图大小为 600K 以下的话，就可以完全正确显示。

1. 
   
2. --------client----------------
   
3. 
   
4. #include <sys/types.h>
   
5. #include <sys/socket.h>
   
6. #include <stdio.h>
   
7. #include <stdlib.h>
   
8. #include <errno.h>
   
9. #include <string.h>
   
10. #include <unistd.h>
    
11. #include <netinet/in.h>
    
12. #include <netdb.h>
    
13. 
    
14. #define SERVPORT 3333
    
15. 
    
16. #define MAXDATASIZE 512*512+1024+54
    
17. 
    
18. 
    
19. 
    
20. main( int argc , char *argv[] )
    
21. {
    
22.          struct hostent *host;
    
23.    struct sockaddr_in serv_addr;
    
24.          int sockfd,sendbytes;
    
25.          char buf[MAXDATASIZE];
    
26.          char size[4];
    
27.          int bmpsize = 0,
    
28.              i,
    
29.              headersize = 0,
    
30.              pixelsize = 0,
    
31.              vector = 0,
    
32.              palette = 0;
    
33.          char bmpsizechar;
    
34.          
    
35.          FILE *fbmp;
    
36.          char bmpdata[MAXDATASIZE];
    
37.          
    
38. if (( fbmp = fopen("client.bmp", "r")) == NULL)
    
39.                    {
    
40.                    printf("Open client bmp error !\n");
    
41.                    exit(-1);
    
42.             }
    
43. 
    
44. 
    
45.   fseek(fbmp,10,SEEK_SET);
    
46.   fread(&headersize,4,1,fbmp);
    
47.   printf("This BMP's headersize = %d \n" , headersize);  // 为 54 和1078
    
48.   
    
49.   fseek(fbmp,34,SEEK_SET);
    
50.   fread(&pixelsize,4,1,fbmp);
    
51.   printf("This BMP's pixelsize = %d \n" , pixelsize);   
    
52. 
    
53. 
    
54.   fseek(fbmp,28,SEEK_SET);
    
55.   fread(&vector,2,1,fbmp);
    
56.   printf("This BMP's vector = %d \n" , vector);
    
57.   
    
58.   if(vector == 24 || vector == 18)         
    
59.         bmpsize = 54 + pixelsize ;
    
60.   else
    
61.         bmpsize = 1078 + pixelsize ;  
    
62.         
    
63.   
    
64.   printf("This BMP's  bmpsize = %d \n" , bmpsize);   
    
65. 
    
66.   fseek(fbmp,0,SEEK_SET);
    
67.   fread(bmpdata,bmpsize,1,fbmp);
    
68. 
    
69.   if( argc < 2) {
    
70.           fprintf(stderr, "Please enter the server's hostname!\n");
    
71.            exit(1);
    
72.     }
    
73.    
    
74. if( (host = gethostbyname(argv[1])) == NULL ){
    
75.               perror("gethostbyname");
    
76.               exit(1);          
    
77.    }
    
78.          
    
79.   if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
    
80.                    perror("socket");
    
81.                    exit(1);
    
82.          }
    
83. 
    
84.    printf("socket success!,socket = %d\n",sockfd);
    
85.    
    
86.    serv_addr.sin_family = AF_INET;         
    
87.    serv_addr.sin_port = htons(SERVPORT);                 
    
88.    serv_addr.sin_addr = *( (struct in_addr *)host->h_addr );
    
89.    
    
90.    bzero(&(serv_addr.sin_zero), 8);
    
91.    
    
92.    if( connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr)) == -1 ){
    
93.        perror("connect");
    
94.        exit(1);           
    
95.           }                 
    
96.          
    
97.          printf("connect success!\n");
    
98.        
    
99. 
    
100.   if(( sendbytes = send(sockfd, bmpdata ,bmpsize, 0)) == -1){
     
101.                 perror("send");
     
102.                 exit(1);
     
103.         }
     
104.        
     
105.    printf("sent connection :%d\n", sendbytes );
     
106. 
     
107. 
     
108.          
     
109.   printf("send over!\n");
     
110.   
     
111.   fclose(fbmp);
     
112.   close(sockfd);
     
113. 
     
114. }
     
115. 
     
116. -----------------------------server--------------------
     
117. 
     
118. #include <sys/types.h>
     
119. #include <sys/socket.h>
     
120. #include <stdio.h>
     
121. #include <stdlib.h>
     
122. #include <errno.h>
     
123. #include <string.h>
     
124. #include <unistd.h>
     
125. #include <netinet/in.h>
     
126. 
     
127. #define SERVPORT 3333
     
128. #define BACKLOG 10
     
129. #define MAX_CONNECTED_NO 10
     
130. //#define MAXDATASIZE 800*800+1024+54
     
131. 
     
132. 
     
133. 
     
134. int main()
     
135. {
     
136.          struct sockaddr_in  server_sockaddr,client_sockaddr;
     
137.          int sin_size,recvbytes;
     
138.          int sockfd,client_fd;
     
139.          int nwrite,i;
     
140. 
     
141.    char size[4];
     
142. 
     
143.    volatile int bmpsize = 800*800;
     
144. 
     
145.    int pixelsize,vector;
     
146.        
     
147.          FILE *fbmp;
     
148.          char bmpdata[MAXDATASIZE];       
     
149.          char *p;
     
150.        
     
151. 
     
152.          
     
153.   if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
     
154.                    perror("socket");
     
155.                    exit(1);
     
156.          }
     
157. 
     
158.    printf("socket success!,sockfd = %d\n",sockfd);
     
159.    
     
160.    server_sockaddr.sin_family = AF_INET;         
     
161.    server_sockaddr.sin_port = htons(SERVPORT);                 
     
162.    server_sockaddr.sin_addr.s_addr = INADDR_ANY;
     
163.    
     
164.    bzero(&(server_sockaddr.sin_zero), 8);
     
165.    
     
166. if(bind(sockfd, (struct sockaddr *)&server_sockaddr, sizeof(struct sockaddr)) == -1 ){
     
167.        perror("bind");
     
168.        exit(1);           
     
169.           }                 
     
170.          
     
171.      printf("bind success!\n");
     
172. 
     
173.          
     
174. if(listen(sockfd, BACKLOG) == -1){
     
175.                    perror("listen");
     
176.                    exit(1);                  
     
177.          }
     
178.          
     
179.          printf("listening - - - \n");
     
180.          
     
181. if( (client_fd = accept(sockfd, (struct sockaddr *)&client_sockaddr, &sin_size)) == -1 ){
     
182.                     perror("accept");
     
183.                     exit(1);
     
184.    }
     
185.        
     
186.                  printf("accept is ok ! \n");
     
187. 
     
188.         i = 0;
     
189.        
     
190. while(1){
     
191.        
     
192.         if(( recvbytes = recv(client_fd, &bmpdata[i], 1, 0)) == -1){
     
193.                 perror("recv");
     
194.                 exit(1);
     
195.           }
     
196.   
     
197.         if(i ==54){
     
198. 
     
199.           pixelsize = ((bmpdata[37] & 0x000000ff) *256*256*256 ) + ((bmpdata[36] & 0x000000ff) *256*256 ) \
     
200.                      + ( (bmpdata[35] & 0x000000ff) *256 ) + (bmpdata[34] & 0x000000ff) *1 ;
     
201.           vector =( bmpdata[28] & 0x000000ff) *1 ;
     
202.            
     
203.           if(vector == 24 || vector == 18)         
     
204.                   bmpsize = 54 + pixelsize ;
     
205.           else
     
206.                     bmpsize = 1078 + pixelsize ;  
     
207.                         
     
208.           printf("pixelnumber = %d\n",pixelsize);                       
     
209.           printf("size is change for = %d\n",bmpsize);
     
210.         }
     
211.        
     
212.      
     
213.           i++;
     
214.          
     
215.           if( i == bmpsize)
     
216.                  break;
     
217.          
     
218. }         
     
219. 
     
220. 
     
221.         printf("receiving bytes' number is  :%d\n", i);
     
222.           printf("received a connection :%d\n", recvbytes );
     
223. 
     
224. if (( fbmp = fopen("server.bmp", "w+")) == NULL)
     
225.            {
     
226.                    printf("Open  server bmp error !\n");
     
227.                    exit(-1);
     
228.             }  
     
229. 
     
230. 
     
231. if ( nwrite = fwrite (bmpdata, bmpsize,1, fbmp ) < 0)
     
232.              {
     
233.                      printf("Write  BMP error !\n");
     
234.                     exit(-1);
     
235.       }
     
236. 
     
237.   fclose(fbmp);
     
238.   close(sockfd);
     
239. 
     
240. }
     

复制代码

程序情人

建议研究一下你平台下的recv/send机制

rambo0808

如果用循环来做的话，那根据大小N   ， 一次只send 和recv 一个 byte吗？？？


其实我还有一个疑问：

在我的代码中，没有把socket设置成non-block模式, 为什么send()还没发送完, 就能返回？？？

rambo0808

根据大家的建议，用循环的思路来做
发送端--》发送4个字节表示文件长度，  然后循环调用send，直到发送字节数为N；
接收端-》接收4个字节，知道长度后，循环调用recv，直到收到字节数为N；（recv后，每次追加方式写入文件）

但是又有新的问题出现了,出现的问题标注在代码中，我把出现问题的那部分代码贴上，请大家分析一下

1. 
   
2. 
   
3. ---------------------------client-----------------------
   
4. if(( sendbytes = send(sockfd, size ,4, 0)) == -1){
   
5.         perror("send");
   
6.         exit(1);
   
7.    }
   
8. printf("sent connection1 =  :%d\n", sendbytes );  //int bmpsize --> char size[4], 此处发送正确，bmpsize = 814502
   
9. 
   
10.   
    
11. for( i = 0; i< bmpsize ;i++){       
    
12.                      
    
13.     if(( sendbytes = send(sockfd, &bmpdata[i] ,1, 0)) == -1){
    
14.                    perror("send");
    
15.                    exit(1);
    
16.             }        
    
17.            }  // 在client 运行的时候，程序会在此停留很久。然后打印：send: Bad address就退出了   
    
18. 
    
19. printf("sent connection2 = :%d\n", sendbytes );
    
20. 
    
21. ---------------------------server--------------------------
    
22. 
    
23.    bmpdata[0]=0xff;
    
24.    bmpdata[1]=0xff;  //初始化
    
25. 
    
26. 
    
27. if(( recvbytes = recv(client_fd, size, 4, 0)) == -1){
    
28.         perror("recv");
    
29.         exit(1);
    
30.    }
    
31.           
    
32. bmpsize = ((size[3] & 0x000000ff) *256*256*256 ) + ((size[2] & 0x000000ff) *256*256 ) \
    
33.            + ( (size[1] & 0x000000ff) *256 ) + (size[0] & 0x000000ff) *1 ;
    
34.        
    
35. printf(" bmpsize  is  :%d\n", bmpsize); //此处接收正确，也为client端发送的值，bmpsize = 814502
    
36. 
    
37. 
    
38. i = 0;
    
39.        
    
40. while(1){
    
41.        
    
42.    if(( recvbytes = recv(client_fd, &bmpdata[i], 1, 0)) == -1){
    
43.         perror("recv");
    
44.         exit(1);
    
45.     }
    
46.       
    
47.    if(i < 16)
    
48.              printf("bmpdata[%d] = %d\n",i ,bmpdata[i]); //此处打印的值不为初始化值，全为0，看来在接收，但接收不正确
    
49.      
    
50.    i++;
    
51.          
    
52.    if( i == bmpsize)     //程序在这个循环中停留很久，直到client端出现错误后，才往下执行。
    
53.          break;
    
54.          
    
55. }         
    
56.    // 接收的数据全为0
    
57.    printf("receiving bytes' number is  :%d\n", i);
    
58.    printf("received a connection :%d\n", recvbytes );
    
59. 
    

复制代码