命令用法：%s\n“，argv[0]）； 关闭（sd）； 出口（-1）； } memcpy（&serveraddr.sin_addr，hostp->h_addr，sizeof（serveraddr.sin_addr））； } /*将（）连接到服务器*/ if（（rc=connect（sd，（struct sockaddr*）&serveraddr，sizeof（serveraddr）））

在client.c程序中，您尝试向服务器发送

文件*

。您发送的是客户端程序中文件描述符的地址，而不是文件中包含的文本

您只发送4或8个字节（取决于体系结构32或64位），而服务器在回显任何内容之前至少等待100个字节。因此，这两个程序都完全按照您编程的方式执行，但并不是按照您的预期执行

---

要发送文件内容，您可以读取一个字符数组中的文件，然后发送字符数组。您可以在文件上迭代，一次读取一个缓冲区，然后发送缓冲区。但是没有魔法允许发送整个文件。

我没有详细查看您的代码（有点凌乱和冗长），但是有很多echo服务器和客户端的例子。我建议你仔细研究它们…这个问题已经解决了一百万次。谢谢你的回复Karel Kubat。我的问题不是echo。我无法接受和读取客户端连接。我是c编程新手。我可以在我没有使用函数文件*fp=fopen（）；…现在我想在服务器上使用fopen读取该文件。请提供任何建议都可以帮助我解决此问题。此问题与fpga主题有任何关系吗？您用fpga标记了它…如果服务器不接受连接，会发生什么情况？您好EJP，服务器正在等待从客户端接受连接。我有两个问题：es在Linux上的客户端读写。我使用cat>/dev/xillybus_write-8运行写文件，在那里我可以输入数据。数据应该通过服务器上的客户端并接收确认。在收到完整消息之前，循环到底有什么“危险”呢？你好，Serge Ballesta，感谢您回答我的问题n、 我目前正在尝试找出解决方案。@EJP：没有什么危险的，只是在当前情况下，对等方从未发送足够的数据，并且没有超时或其他错误处理，它以无限循环结束。没有。它会导致阻塞读取，通过数据到达或对等方关闭连接终止打开。世界上每一个基于协议的程序都必须不断阅读，直到它汇编整个请求。你的评论毫无意义。@EJP：好的，我明白你的意思。当客户端只发送4个字符时，服务器会等待100个字符，但这是一个协议执行不好的问题。我的评论是基于这样一个事实，即程序只是回显输入，一个nd可以在数据到达后立即处理数据，但我必须承认这不是我的话的意思。我可以将其从帖子中删除，因为这里已经详细介绍了。谢谢您的关注。

Server.C

#include<stdio.h>

#define BufferLength 100

/* Server port number */
#define SERVPORT 3389

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

/* Variable and structure definitions. */
int sd, sd2, rc, length = sizeof(int);
int totalcnt = 0, on = 1;
char temp;
char buffer[BufferLength];
//char data[BufferLength];
struct sockaddr_in serveraddr;
struct sockaddr_in their_addr;

fd_set read_fd;
struct timeval timeout;
timeout.tv_sec = 15;
timeout.tv_usec = 0;

/*To read xillybus*/
//  FILE *fp;
//  fp = fopen("/dev/xillybus_read_8", "r");
//  if(fp==NULL)
//  {
//      printf("Error file open\n");
//      exit(-1);
//  }
//  else{
//      printf("File found %s\n", fp);
//  }


/* Get a socket descriptor */

if((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
    perror("Server-socket() error");
    exit (-1);
}
else
{
    printf("Server-socket() is OK\n");
}


/* Allow socket descriptor to be reusable */

if((rc = setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on))) < 0)
{
    perror("Server-setsockopt() error");
    close(sd);
    exit (-1);
}
else
{
    printf("Server-setsockopt() is OK\n");
}

/* bind to an address */
memset(&serveraddr, 0x00, sizeof(struct sockaddr_in));
serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons(SERVPORT);
serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
printf("Using %s, listening at %d\n", inet_ntoa(serveraddr.sin_addr), SERVPORT);



if((rc = bind(sd, (struct sockaddr *)&serveraddr, sizeof(serveraddr))) < 0)
{
    perror("Server-bind() error");
    close(sd);
    exit(-1);
}

else
{
    printf("Server-bind() is OK\n");
}



/* Up to 10 clients can be queued */

if((rc = listen(sd, 10)) < 0)
{
    perror("Server-listen() error");
    close(sd);
    exit (-1);
}
else
{
    printf("Server-Ready for client connection...\n");
}


/* accept() the incoming connection request. */

int sin_size = sizeof(struct sockaddr_in);


if((sd2 = accept(sd, (struct sockaddr *)&their_addr, &sin_size)) < 0)
{

    perror("Server-accept() error");
    close(sd);
    exit (-1);
}
else
{

    printf("Server-accept() is OK\n");
}

/*client IP*/
    printf("Server-new socket, sd2 is OK...\n");
    printf("Got connection from the  client: %s\n", inet_ntoa(their_addr.sin_addr));

/* Wait for up to 15 seconds on */
/* select() for data to be read. */
FD_ZERO(&read_fd);
FD_SET(sd2, &read_fd);
rc = select(sd2+1, &read_fd, NULL, NULL, &timeout);

if((rc == 1) && (FD_ISSET(sd2, &read_fd)))
{
/* Read data from the client. */
totalcnt = 0;

while(totalcnt < BufferLength)
{


/* read() from client */
rc = read(sd2, &buffer[totalcnt], (BufferLength - totalcnt));
if(rc < 0)
{
    perror("Server-read() error");
    close(sd);
    close(sd2);
    exit (-1);
}

else if (rc == 0)
{
    printf("Client program has issued a close()\n");
    close(sd);
    close(sd2);
    exit(-1);
}

else
{
    totalcnt += rc;
    printf("Server-read() is OK\n");
}

}
}
else if (rc < 0)
{
    perror("Server-select() error");
    close(sd);
    close(sd2);
    exit(-1);
}

/* rc == 0 */
else
{
    printf("Server-select() timed out.\n");
    close(sd);
    close(sd2);
    exit(-1);
}

/* Shows the data */
    printf("Received data from the client: %s\n", buffer);
    printf("Server-Echoing back to client...\n");

/*Write function*/
rc = write(sd2, buffer, totalcnt);
if(rc != totalcnt)
{
    perror("Server-write() error");
    rc = getsockopt(sd2, SOL_SOCKET, SO_ERROR, &temp, &length);

if(rc == 0)
{
    /* Print out the asynchronously */
    /* received error. */
    errno = temp;
    perror("SO_ERROR was: ");
}
else
{
    printf("Server-write() is OK\n");
}
close(sd);
close(sd2);
exit(-1);
}


/******************************************/
close(sd2);
close(sd);
exit(0);
return 0;
}

Client.c

#include<stdio.h>

#define BufferLength 100

#define SERVER "00.00.00.00"
/* Server's port number */

#define SERVPORT 3389

/* set the server name in the #define SERVER ... */

int main(int argc, char *argv[])
{
/* Variable and structure definitions. */
int sd, rc, length = sizeof(int);
struct sockaddr_in serveraddr;
char buffer[BufferLength];
char server[255];
char temp;
int totalcnt = 0;
struct hostent *hostp;

//char data[500] = "Hello ravi !!! "; // writes data to the server


/*To open directory and read the xillybus*/

FILE *fp;
char s[100];
fp = fopen("/dev/xillybus_read_8", "r");
if(!fp)
    return 1;
while(fgets(s,100,fp)!=NULL){
    printf("%s ", s);
}
//fclose(fp);

/******************************************/
/* get a socket descriptor */

if((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
    perror("Client-socket() error");
    exit(-1);
}
else
{
    printf("Client-socket() OK\n");
}
/*If the server hostname is supplied*/
if(argc > 1)
{
/*Use the supplied argument*/
    strcpy(server, argv[1]);
    printf("Connecting to the server %s, port %d ...\n", server, SERVPORT);
}
else
{
/*Use the default server name or IP*/
strcpy(server, SERVER);
memset(&serveraddr, 0x00, sizeof(struct sockaddr_in));
serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons(SERVPORT);
}

if((serveraddr.sin_addr.s_addr = inet_addr(server)) == (unsigned long)INADDR_NONE)
{

/* get host address */
hostp = gethostbyname(server);
if(hostp == (struct hostent *)NULL)
{
    printf("HOST NOT FOUND --> ");
/* h_errno is usually defined */
/* in netdb.h */
    printf("h_errno = %d\n",h_errno);
    printf("---This is a client program---\n");
    printf("Command usage: %s <server name or IP>\n", argv[0]);
    close(sd);
    exit(-1);
}
memcpy(&serveraddr.sin_addr, hostp->h_addr, sizeof(serveraddr.sin_addr));
}


/* connect() to server. */

if((rc = connect(sd, (struct sockaddr *)&serveraddr, sizeof(serveraddr))) < 0)
{
    perror("Client-connect() error");
    close(sd);
    exit(-1);
}
else
{
    printf("Connection established...\n");
    printf("Sending some string to the server %s...\n", server);
}
/* Write() some string to the server. */
//rc = write(sd, data, sizeof(data));

rc = write(sd,fp, sizeof(fp)); // here is my write function

if(rc < 0)
{
    perror("Client-write() error");
    rc = getsockopt(sd, SOL_SOCKET, SO_ERROR, &temp, &length);
if(rc == 0)
{
/* Print out the asynchronously received error. */
    errno = temp;
    perror("SO_ERROR was");
}
close(sd);
exit(-1);
}
else
{
    printf("Client-write() is OK\n");
    printf("String successfully sent \n");
    printf("Waiting the %s to echo back...\n", server);
}
totalcnt = 0;

/* Read data from the server. */
while(totalcnt < BufferLength)
{
rc = read(sd, &buffer[totalcnt], BufferLength-totalcnt); //&buffer[totalcnt],BufferLength-totalcnt
if(rc < 0)
{
    perror("Client-read() error");
    close(sd);
    exit(-1);
}
else if (rc == 0)
{
    printf("Server program has issued a close()\n");
    close(sd);
    exit(-1);
}
else
{
    totalcnt += rc;
}
}
    printf("Client-read() is OK\n");
    printf("Echoed data from the  server: %s\n", buffer); //data ->buffer

/* Close socket descriptor from client side. */
close(sd);
exit(0);
return 0;
}