LinuxC网络通信程序在调试器中工作，但不能在调试器外部工作

我有两个文件，server.c和client.c。服务器侦听客户机请求，然后相应地进行响应（现在只实现了带有静态目录的列表）。当服务器接收到LIST命令时，它统计指定目录中的常规文件数量（现在是一个静态值），然后向客户端发送该数量，以便它继续侦听，直到收到n个元素。然后，服务器开始向侦听客户端发送文件名

这在理论上和调试服务器时都有效，但在我通过终端正常运行这两个应用程序时则无效。客户机只是在键入LIST命令后陷入困境，而当服务器接收到它时，它不会继续发送项目数量和名称。然而，当以代码块的调试模式运行服务器（尽管我想IDE并不重要）并逐行检查代码时，一切都完全按照预期工作。这可能是某种种族状况，但我无法独自解决它

客户c

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define BUF 1024
#define PORT 8543

int main (int argc, char **argv) {
  int create_socket;
  char buffer[BUF];
  struct sockaddr_in address;
  int size;

  if ((create_socket = socket (AF_INET, SOCK_STREAM, 0)) == -1)
  {
     perror("Socket error");
     return EXIT_FAILURE;
  }

  memset(&address,0,sizeof(address));
  address.sin_family = AF_INET;
  address.sin_port = htons (PORT);
  const char *addr = "localhost";
  inet_aton (addr, &address.sin_addr);
  if (connect ( create_socket, (struct sockaddr *) &address, sizeof (address)) == 0)
  {
     printf ("Connection with server (%s) established\n", inet_ntoa (address.sin_addr));
     size=recv(create_socket,buffer,BUF-1, 0);
    if (size>0)
     {
        buffer[size]= '\0';
        printf("%s",buffer);
        bzero(buffer, BUF);

     }
  }
  else
  {
     perror("Connect error - no server available");
     return EXIT_FAILURE;
  }

  do {
     printf ("Send message: ");
     fgets (buffer, BUF, stdin);
     send(create_socket, buffer, strlen (buffer), 0);
     if(strcmp(buffer, "LIST\n")){
        bzero(buffer, BUF);
        size=recv(create_socket,buffer,BUF-1, 0);
        if(size >0){
          buffer[size] = '\0';
          int items = atoi(buffer);
         printf("%d", items);
          bzero(buffer, BUF);
          for(int i = 0; i < items; i++){
            size=recv(create_socket,buffer,BUF-1, 0);
            if(size >0){
              buffer[size] = '\0';
              printf("%s\n", buffer);
            }
            bzero(buffer, BUF);
          }
        }
     }
  }
  while (strcmp (buffer, "QUIT\n") != 0);
  close (create_socket);
  return EXIT_SUCCESS;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义buf1024
#定义端口8543
int main（int argc，字符**argv）{
int创建_套接字；
字符缓冲区[BUF]；
地址中的结构sockaddr_；
整数大小；
if（（创建套接字=套接字（AF\u INET，SOCK\u STREAM，0））=-1）
{
perror（“套接字错误”）；
返回退出失败；
}
memset（&address，0，sizeof（address））；
address.sin_family=AF_INET；
address.sin_port=htons（port）；
const char*addr=“localhost”；
inet_-aton（地址和地址sin_-addr）；
if（connect（create_socket，（struct sockaddr*）和address，sizeof（address））=0）
{
printf（“已建立与服务器（%s）的连接”，inet_ntoa（address.sin_addr））；
大小=recv（创建插槽、缓冲区、BUF-1、0）；
如果（大小>0）
{
缓冲区[大小]='\0'；
printf（“%s”，缓冲区）；
bzero（缓冲器，BUF）；
}
}
其他的
{
perror（“连接错误-没有可用的服务器”）；
返回退出失败；
}
做{
printf（“发送消息：”）；
fgets（缓冲区、BUF、标准输入）；
发送（创建_套接字、缓冲区、strlen（缓冲区）、0）；
if（strcmp（缓冲区，“列表”））{
bzero（缓冲器，BUF）；
大小=recv（创建插槽、缓冲区、BUF-1、0）；
如果（大小>0）{
缓冲区[大小]='\0'；
int items=atoi（缓冲区）；
printf（“%d”，项目）；
bzero（缓冲器，BUF）；
对于（int i=0；i0）{
缓冲区[大小]='\0'；
printf（“%s\n”，缓冲区）；
}
bzero（缓冲器，BUF）；
}
}
}
}
while（strcmp（缓冲区，“退出”！=0）；
关闭（创建_套接字）；
返回退出成功；
}

服务器.c

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include <errno.h>
#include <string>
#include <iostream>
#define BUF 1024
#define PORT 8543

using namespace std;

int main (void) {
  int create_socket, new_socket;
  socklen_t addrlen;
  char buffer[BUF];
  int size;
  struct sockaddr_in address, cliaddress;
  struct dirent *direntp;
  DIR *dirp;

  create_socket = socket (AF_INET, SOCK_STREAM, 0);

  memset(&address,0,sizeof(address));
  address.sin_family = AF_INET;
  address.sin_addr.s_addr = INADDR_ANY;
  address.sin_port = htons (PORT);

  int yes = 1;
  if (setsockopt(create_socket, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) == -1) {
    perror("setsockopt");
    exit(1);
  }


  if (bind ( create_socket, (struct sockaddr *) &address, sizeof (address)) != 0) {
     perror("bind error");
     return EXIT_FAILURE;
  }
  listen (create_socket, 5);

  addrlen = sizeof (struct sockaddr_in);

  int file_count = 0;
  struct dirent * entry;

  dirp = opendir("/home"); 
  while ((entry = readdir(dirp)) != NULL) {
    /* Only increment counter if item selected is a regular file */
    if (entry->d_type == DT_REG) {
         file_count++;
    }
  }
  closedir(dirp);

  while (1) {
     printf("Waiting for connections...\n");
     new_socket = accept ( create_socket, (struct sockaddr *) &cliaddress, &addrlen );
     if (new_socket > 0)
    {
        printf ("Client connected from %s:%d...\n", inet_ntoa (cliaddress.sin_addr),ntohs(cliaddress.sin_port));
        strcpy(buffer,"Welcome, please enter your command:\n");
        send(new_socket, buffer, strlen(buffer),0);
        bzero(buffer, BUF);
     }
     do {
        size = recv (new_socket, buffer, BUF-1, 0);
        if( size > 0)
        {
           if(strcmp(buffer, "LIST\n") == 0){
              if ((dirp = opendir("/home")) == NULL) {
                perror ("Failed to open directory");
                return 1;
              }
              bzero(buffer, BUF);
              sprintf(buffer, "%d", file_count);
              /* Send client the amount of items he is to receive */
              send(new_socket, buffer, strlen(buffer),0);
              bzero(buffer, BUF);
              while ((direntp = readdir(dirp)) != NULL)
                  /* Check if item is a file and if yes, send client its name */
                  if (direntp->d_type == DT_REG){
                    strcpy(buffer,direntp->d_name);
                    send(new_socket, buffer, strlen(buffer),0);
                    bzero(buffer, BUF);
                  }
              while ((closedir(dirp) == -1) && (errno == EINTR)) ;
           }
        }
        else if (size == 0)
        {
           printf("Client closed remote socket\n");
           break;
        }
        else
        {
           perror("recv error");
           return EXIT_FAILURE;
        }
     } while (strncmp (buffer, "quit", 4)  != 0);
     close (new_socket);
  }
  close (create_socket);
  return EXIT_SUCCESS;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义buf1024
#定义端口8543
使用名称空间std；
内部主（空）{
int创建_套接字，新建_套接字；
索克伦·阿德伦；
字符缓冲区[BUF]；
整数大小；
地址中的结构sockaddr_，cliaddress；
结构方向*direntp；
DIR*dirp；
创建\u socket=socket（AF\u INET，SOCK\u STREAM，0）；
memset（&address，0，sizeof（address））；
address.sin_family=AF_INET；
address.sin_addr.s_addr=INADDR\u ANY；
address.sin_port=htons（port）；
int yes=1；
if（setsockopt（创建_套接字，SOL_套接字，SO_REUSEADDR，&yes，sizeof（yes））=-1）{
perror（“setsockopt”）；
出口（1）；
}
if（绑定（创建_套接字，（结构sockaddr*）和地址，sizeof（地址））！=0）{
perror（“绑定错误”）；
返回退出失败；
}
监听（创建_套接字，5）；
addrlen=sizeof（结构sockaddr_in）；
int file_count=0；
结构方向*条目；
dirp=opendir（“/home”）；
while（（entry=readdir（dirp））！=NULL）{
/*仅当所选项目为常规文件时才使用增量计数器*/
如果（输入->d_类型==DT_注册表）{
文件计数++；
}
}
closedir（dirp）；
而(1){
printf（“等待连接…\n”）；
new_socket=accept（创建_socket，（struct sockaddr*）&cliaddress，&addrlen）；
如果（新插槽>0）
{
printf（“从%s连接的客户端：%d..\n”、inet\u ntoa（cliaddress.sin\u addr）、ntohs（cliaddress.sin\u端口））；
strcpy（缓冲区，“欢迎，请输入您的命令：\n”）；
发送（新的_套接字、缓冲区、strlen（缓冲区）、0）；
bzero（缓冲器，BUF）；
}
做{
大小=recv（新的_插槽，缓冲区，BUF-1，0）；
如果（大小>0）
{
if（strcmp（缓冲区，“列表\n”）==0）{
if（（dirp=opendir（“/home”））==NULL）{
perror（“打开目录失败”）；
返回1；
}
bzero（缓冲器，BUF）；
sprintf（缓冲区，“%d”，文件计数）；
/*向客户发送他要接收的项目数量*/
发送（新的_套接字、缓冲区、strlen（缓冲区）、0）；
bzero（缓冲器，BUF）；
while（（direntp=readdir（dirp））！=NULL）
/*检查项目是否为文件，如果是，则向客户端发送其名称*/
if（direntp->d_type==DT_REG）{
strcpy（buffer，direntp->d_name）；
发送（新的_套接字、缓冲区、strlen（缓冲区）、0）；
bzero（缓冲器，BUF）；
}
而（（closedir（dirp）=-1）和&（errno==EINTR））；
}
}
else if（大小==0）
{
printf（“客户端关闭的远程套接字”）；
打破
}
其他的
{
perror（“recv错误”）；
返回退出失败；
}
}而（strncmp（buffer，“quit”，4）！=0）；
关闭（新的_插座）；
}
关闭（创建_套接字）；
返回退出成功；
}

如前所述，您的代码假定每个

发送

对应一个

recv

。当y