recv不会将整个消息保存在缓冲区中

我使用send和recv在客户端和服务器之间传递消息。在服务器端，当我在缓冲区fname上收到消息时，保存的消息并不是从客户端发送的全部消息

服务器

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/types.h>      /*For Sockets*/
#include <sys/socket.h>     /*For Sockets*/
#include <netdb.h>      /*For gethostbyaddr()*/
#include <netinet/in.h>     /*For internet sockets*/
#include <dirent.h>


/*Function for creating the lof file of Server*/

void log_event (char *message,char *filename)
{

FILE *file; 
char *log_this;

time_t system_time; //Get the system time
time(&system_time);

log_this=strcat(ctime(&system_time),message); //Create the message to log 

/*Check for filename and log as appropiate*/

if (filename!=NULL)
    {
        file = fopen(filename,"a+"); 
        fprintf(file,"%s",log_this); /*writes the message*/
        fclose(file); /*done!*/     
    }
else    
    {
        file = fopen("ftp_tracelog.txt","a+"); 
        fprintf(file,"%s",log_this); /*writes the message*/
        fclose(file); /*done!*/ 
    }

}

int main (int argc,char *argv[])
{

/*DECLERATIONS*/

char *filename; 
char message [1024];
char *temp;
char temp_2[1024];
char fname[128];
char request[1024];
char op[1000];
char command[5];
FILE *fp;
DIR *dp;
char list[1024];
int port,sock,newsock,serverlen,clientlen,fname_len,recvMsgSize,i;
char buf[256];

struct sockaddr_in server,client;
struct sockaddr *serverptr, *clientptr;
struct hostent *rem;
struct dirent *ep;     

/*END OF DECLERATIONS*/

/*Check for required arguments and get them as appropiate*/

if (argc < 2) { 
/* Check if server's port number is given */
printf("Please give the port number!!!\n");
exit(1);
}

/*if server's port number is given and filename for log is given*/

if(argc>2){
filename=argv[1];
port=atoi(argv[2]);
}

/*If only port is given*/

if (argc==2){
port=atoi(argv[1]);
filename=NULL;
}
temp="--Server is Starting!!--";
sprintf(message,"%s\n",temp);
log_event(message,filename);

/* Create socket */

if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0)
{perror("socket"); exit(1); }

server.sin_family = PF_INET; /* Internet domain */
server.sin_addr.s_addr = htonl(INADDR_ANY); /* My Internet address */
server.sin_port = htons(port); /* The given port */
serverptr = (struct sockaddr *) &server;
serverlen = sizeof (server);

/* Bind socket to address */

if (bind(sock, serverptr, serverlen) < 0) {
perror("bind"); exit(1); }

/* Listen for connections */

if (listen(sock, 40) < 0) { /* 5 max. requests in queue */
perror("listen"); exit(1); }

temp="---Listening for connections to port";
sprintf(temp_2,"%d----",port);
sprintf(message,"%s:%s\n",temp,temp_2);
log_event(message,filename);

/*Accepting Connecttion*/

while(1) {
clientptr = (struct sockaddr *) &client;
clientlen = sizeof(client);
/* Accept connection */
if ((newsock = accept(sock, clientptr, &clientlen)) < 0) {
perror("accept"); exit(1); }
/* Find client's address */
if ((rem = gethostbyaddr((char *) &client.sin_addr.s_addr,
sizeof (client.sin_addr.s_addr), client.sin_family)) == NULL) {
perror("gethostbyaddr"); exit(1);
}

temp="----Accepted connection from ";
sprintf(temp_2,"%s----", rem -> h_name);
sprintf(message,"%s:%s\n",temp,temp_2);
log_event(message,filename);

/* Create child for serving the client */
switch (fork()) {

case -1:
perror("fork"); exit(1);

case 0: /* Child process */
do{
/* Receive message from client */
if ((recvMsgSize = recv(newsock,request,sizeof(request),0))< 0)
perror("recv() failed");
//printf("%s\n",request);

strncpy(command,request,4);
printf("%s\n",command);
/*IF YOU ARE GOING TO EXECUTE AN LS COMMAND*/

if (strcmp(command,"ls")==0)
{
dp = opendir ("./");

if (dp != NULL)
  { /*LOG LS REQUEST*/

    temp="--Client ";
    sprintf(temp_2,"%s requested ls -------",rem -> h_name);
    sprintf(message,"%s:%s\n",temp,temp_2);
    log_event(message,filename);

    /*SEND ALL DIRECTORY LISTING*/    

    while (ep = readdir (dp))
{
    strcpy(list,ep->d_name);
    //printf("sending:%s\n",list);
    if (send(newsock,list,sizeof(list), 0)!= sizeof(list))
    perror("send() sent a different number of bytes than expected");
}
    //IF DIRECORY IS FINISHED SEND A LAST MESSAGE FOR ENDING

    (void) closedir (dp);
    if (send(newsock,"end",sizeof("end"), 0)!= sizeof("end"))
    perror("send() sent a different number of bytes than expected");    
  }
  else
    perror ("Couldn't open the directory");
}
/*IF THE COMMAND IS PUT*/

if (strcmp(command,"put")==0) 
{
printf("execute put!!\n");

bzero(fname, sizeof fname); /* Initialize buffer */

if ((recvMsgSize = recv(newsock,fname,128, MSG_WAITALL)) < 0)
perror("recv() failed");

printf("%s!!!!\n",fname);

}
}while (strcmp(request,"end")!=0); //run until client sents end request

/*LOG EXIT OF CLIENT*/

temp="--Client";
    sprintf(temp_2,"%s is disconnected---",rem -> h_name);
    sprintf(message,"%s:%s\n",temp,temp_2);
    log_event(message,filename);

close(newsock); /* Close socket */
exit(0);
} /* end of switch */
} /* end of while(1) */


}

#包括
#包括
#包括
#包括
#包括/*插座*/
#包括/*插座*/
#包含/*用于gethostbyaddr（）*/
#包括/*用于internet套接字*/
#包括
/*用于创建服务器的lof文件的函数*/
无效日志事件（字符*消息，字符*文件名）
{
文件*文件；
char*log_这个；
time\t system\u time；//获取系统时间
时间（和系统时间）；
log_this=strcat（ctime（&system_time），message）；//创建要记录的消息
/*检查文件名和日志是否合适*/
如果（文件名！=NULL）
{
file=fopen（文件名为“a+”）；
fprintf（文件“%s”，记录此）；/*写入消息*/
fclose（文件）；/*完成！*/
}
其他的
{
file=fopen（“ftp\u tracelog.txt”，“a+”）；
fprintf（文件“%s”，记录此）；/*写入消息*/
fclose（文件）；/*完成！*/
}
}
int main（int argc，char*argv[]）
{
/*减退*/
字符*文件名；
字符消息[1024]；
字符*温度；
字符温度_2[1024]；
char-fname[128]；
字符请求[1024]；
char op[1000]；
char命令[5]；
文件*fp；
DIR*dp；
字符列表[1024]；
int-port、sock、newsock、serverlen、clientlen、fname_len、recvMsgSize、i；
char-buf[256]；
服务器、客户端中的结构sockaddr_；
结构sockaddr*serverptr，*clientptr；
结构宿主*rem；
结构方向*ep；
/*减赤结束*/
/*检查所需的参数，并将其作为适当的参数获取*/
如果（argc<2）{
/*检查是否提供了服务器的端口号*/
printf（“请提供端口号！！！\n”）；
出口（1）；
}
/*如果给定了服务器的端口号和日志的文件名*/
如果（argc>2）{
filename=argv[1]；
端口=atoi（argv[2]）；
}
/*如果只提供端口*/
如果（argc==2）{
端口=atoi（argv[1]）；
filename=NULL；
}
temp=“--服务器正在启动！！-->”；
sprintf（消息“%s\n”，临时）；
日志事件（消息、文件名）；
/*创建套接字*/
if（（sock=socket（PF_INET，sock_STREAM，0））<0）
{perror（“socket”）；出口（1）；}
server.sin_family=PF_INET；/*Internet域*/
server.sin_addr.s_addr=htonl（INADDR_ANY）；/*我的互联网地址*/
server.sin_port=htons（port）；/*给定端口*/
serverptr=（结构sockaddr*）&server；
serverlen=sizeof（服务器）；
/*将套接字绑定到地址*/
if（绑定（sock、serverptr、serverlen）<0）{
perror（“绑定”）；退出（1）；}
/*倾听联系*/
if（listen（sock，40）<0）{/*5队列中的最大请求数*/
perror（“倾听”）；退出（1）；}
temp=“---侦听到端口的连接”；
sprintf（临时2，“%d----”，端口）；
sprintf（消息，“%s:%s\n”，临时，临时2）；
日志事件（消息、文件名）；
/*接受连接*/
而(1){
clientptr=（struct sockaddr*）&client；
clientlen=sizeof（客户）；
/*接受连接*/
如果（（newsock=accept（sock、clientptr和clientlen））<0）{
perror（“接受”）；退出（1）；}
/*查找客户地址*/
如果（（rem=gethostbyaddr（（char*））和client.sin\u addr.s\u addr，
sizeof（client.sin\u addr.s\u addr）、client.sin\u family））==NULL）{
perror（“gethostbyaddr”）；出口（1）；
}
temp=“----已接受来自的连接”；
sprintf（temp_2，“%s--”，rem->h_name）；
sprintf（消息，“%s:%s\n”，临时，临时2）；
日志事件（消息、文件名）；
/*创建为客户端服务的子对象*/
开关（fork（））{
案例1：
出口（1）；
案例0:/*子进程*/
做{
/*从客户端接收消息*/
如果（（recvMsgSize=recv（newsock，request，sizeof（request），0））<0）
perror（“recv（）失败”）；
//printf（“%s\n”，请求）；
strncpy（命令、请求、4）；
printf（“%s\n”，命令）；
/*如果要执行LS命令*/
如果（strcmp（命令，“ls”）==0）
{
dp=opendir（“./”）；
如果（dp！=NULL）
{/*日志LS请求*/
temp=“--Client”；
sprintf（temp_2，“%s请求ls------”，rem->h_名称）；
sprintf（消息，“%s:%s\n”，临时，临时2）；
日志事件（消息、文件名）；
/*发送所有目录列表*/
while（ep=readdir（dp））
{
strcpy（列表，ep->d_名称）；
//printf（“发送：%s\n”，列表）；
如果（发送（新闻组、列表、sizeof（列表）、0）！=sizeof（列表））
perror（“send（）发送的字节数与预期的不同”）；
}
//如果DIRECORY已完成，则发送结束的最后一条消息
（无效）closedir（dp）；
如果（发送（newsock，“end”，sizeof（“end”），0）！=sizeof（“end”））
perror（“send（）发送的字节数与预期的不同”）；
}
其他的
perror（“无法打开目录”）；
}
/*如果命令被执行*/
if（strcmp（命令，“put”）==0）
{
printf（“执行put！！\n”）；
bzero（fname，sizeof fname）；/*初始化缓冲区*/
如果（（recvMsgSize=recv（newsock，fname，128，MSG_WAITALL））<0）
perror（“recv（）失败”）；
printf（“%s！！！！\n”，fname）；
}
}while（strcmp（请求，“结束”）！=0）；//运行，直到客户端发出结束请求
/*客户端日志退出*/
temp=“--Client”；
sprintf（temp_2，“%s已断开连接---”，rem->h_名称）；
sprintf（消息，“%s:%s\n”，临时，临时2）；
日志事件（消息、文件名）；
关闭（新锁）；/*关闭插座*/
出口（0）；
}/*开关末端*/
}/*期间结束（1）*/
}

客户

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>

int main (int argc,char *argv[])
{

int port, sock, serverlen,recvMsgSize;
int fname_len,msg_len,request_len;
char buf[256];
char fname[128];
char request[1204];
char list[1024];
char msg[512];
char op[1000];
char temp[5];
char *temp3;
FILE *fp;


struct sockaddr_in server;
struct sockaddr *serverptr;
struct hostent *rem;

temp3="put";

/* Are server's host name and port number given? */
if (argc < 3) {
printf("Please give host name and port number\n"); exit(1);

}

/* Create socket */
if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
perror("socket");
exit(1);
}

/* Find server address */
if ((rem = gethostbyname(argv[1])) == NULL) {
herror("gethostbyname"); exit(1);
}

/* Convert port number to integer */
port = atoi(argv[2]);

/* Internet domain */
server.sin_family = PF_INET; 
bcopy((char *) rem -> h_addr, (char *) &server.sin_addr,
rem -> h_length);

/*Server's Internet address and port*/
server.sin_port = htons(port); 
serverptr = (struct sockaddr *) &server;
serverlen = sizeof(server);


if (connect(sock, serverptr, serverlen) < 0) { /* Request connection */
perror("connect"); 
exit(1); }

printf("Requested connection to host %s port %d\n", argv[1], port);



do{
printf("Please enter request\n:");
scanf("%s",request);

request_len=sizeof(request);

/* Send the string to the server */
if (send(sock,request,request_len, 0)!= request_len)
perror("send() sent a different number of bytes than expected");

strncpy(temp,request,4);
printf("%s\n",temp);

if(strcmp(temp,"ls")==0)
{
sprintf(list,"");

/*Recieve from server*/
while(strcmp(list,"end")!=0){

if ((recvMsgSize = recv(sock,list,sizeof(list),0))< 0)
perror("recv() failed");

if(strcmp(list,"end")!=0){
    printf("%s\n",list);
        }
}
}

/*Command for put*/
if(strcmp(request,temp)==0)
{
printf("Please enter filename:\n");
scanf("%s",fname);

if (send(sock,fname,128, MSG_DONTWAIT)!= 128)
perror("send() sent a different number of bytes than expected");

}
}while (strcmp(request,"end")!=0);
close(sock); /* Close socket */
exit(0);
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
int main（int argc，char*argv[]）
{
int端口、sock、serverlen、recvMsgSize；
int fname_len、msg_len、request_len；
char-buf[256]；
char-fname[128]；
字符请求[1204]；
字符列表[1024]；
char-msg[512]；
char op[1000]；
炭温[5]；
字符*temp3；
文件*fp；
服务器中的结构sockaddr_；
结构sockaddr*serverptr；
结构宿主*rem；
temp3=“put”；
/*是否提供了服务器的主机名和端口号*/
如果（argc<3）{
printf（“请提供主机名和端口号”）；退出（1）；
}
/*创建套接字*/
if（（sock=socket（PF_INET，sock_STREAM，0））<0）{
佩罗（“插座”）；
出口（1）；
}
/*查找服务器地址*/
if（（rem=gethostbyname（argv[1]））==NULL）{
herror（“gethostbyname”）；出口（1）；
}
/*将端口号转换为整数*/
端口=atoi（argv[2]）；
/*互联网领域*/
server.sin_family=PF_INET；
b复制（（char*）rem->h_addr，（char*）和server.sinu addr，
rem->h_长度）；
char buf[N];
char* p = buf;
ssize_t bytesRemaining = N;
while (bytesRemaining) {
   ssize_t recvd;
   recvd = recv(sock, p, bytesRemaining, 0);
   bytesRemaining -= recvd;     // keep track of bytes left
   p += recvd;                  // advance buffer pointer
}