c消息问题中的客户机-服务器程序

我最近用c语言编写了一个服务器客户端程序，但它似乎不起作用。在编译它时，我得到的唯一一件事是警告和客户端中存在错误的事实。谁能帮我一点忙吗

这是服务器代码：

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

int main()
{
    int server_socket;
    server_socket = socket(AF_INET,SOCK_STREAM,0);
    struct sockaddr_in server_address;
    int addrlen = sizeof(server_address);
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(9000);
    server_address.sin_addr.s_addr = INADDR_ANY;

    bind (server_socket, (struct sockaddr*) &server_address, sizeof(server_address));
    int client_socket;
    listen(server_socket, 3);
    client_socket=accept(server_socket, NULL, (socklen_t*)&addrlen);
    char response[256];

    recv(server_socket, &response, sizeof(response), 0);

    printf("%s",response);
    pclose (server_socket);
    return (0);
}

#包括
#包括
#包括
#包括
#包括
int main（）
{
int-server_-socket；
服务器\u套接字=套接字（AF\u INET，SOCK\u STREAM，0）；
服务器地址中的结构sockaddr\u；
int addrlen=sizeof（服务器地址）；
服务器地址.sin\u family=AF\u INET；
服务器地址sin端口=htons（9000）；
server_address.sin_addr.s_addr=INADDR\u ANY；
绑定（server_socket，（struct sockaddr*）和server_地址，sizeof（server_地址））；
int客户机接口；
监听（服务器接口，3）；
client\u socket=accept（server\u socket，NULL，（socklen\u t*）和addrlen）；
字符响应[256]；
recv（服务器\u套接字和响应，sizeof（响应），0）；
printf（“%s”，响应）；
pclose（服务器_套接字）；
返回（0）；
}

这是客户端代码：

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

int main()
{ 
    int network_socket; 
    network_socket = socket(AF_INET,SOCK_STREAM, 0);

    struct sockaddr_in server_address; 
    server_address.sin_family = AF_INET; 
    server_address.sin_port = htons(9000); 
    server_address.sin_addr.s_addr = INADDR_ANY; 

    int connection_status = connect(network_socket, (struct sockaddr*)&server_address, sizeof(server_address));
    if (connection_status == -1) { printf("ERROR"); } 

    char maw[256] = "this is a message"; send(network_socket, maw, sizeof(maw), 0); close(server_address); 
    return(0); 

    pclose(network_socket); 
}

#包括
#包括
#包括
#包括
#包括
int main（）
{ 
int网络接口；
网络套接字=套接字（网络，套接字流，0）；
服务器地址中的结构sockaddr\u；
服务器地址.sin\u family=AF\u INET；
服务器地址sin端口=htons（9000）；
server_address.sin_addr.s_addr=INADDR\u ANY；
int connection_status=connect（网络套接字，（结构sockaddr*）和服务器地址，sizeof（服务器地址））；
如果（连接状态==-1）{printf（“错误”）；}
char maw[256]=“这是一条消息”；发送（网络\u套接字，maw，sizeof（maw），0）；关闭（服务器\u地址）；
返回（0）；
pclose（网络接口）；
}

服务器代码中还有一个错误

服务器代码：

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

int main()
{
    int server_socket;
    server_socket = socket(AF_INET,SOCK_STREAM,0);
    struct sockaddr_in server_address;
    int addrlen = sizeof(server_address);
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(9000);
    server_address.sin_addr.s_addr = INADDR_ANY;

    bind (server_socket, (struct sockaddr*) &server_address, sizeof(server_address));
    int client_socket;
    listen(server_socket, 3);
    client_socket=accept(server_socket, NULL, (socklen_t*)&addrlen);
    char response[256];

    recv(client_socket, &response, sizeof(response), 0);

    printf("%s",response);
    shutdown (client_socket, SHUT_RDWR);
    close (client_socket);
    shutdown (server_socket, SHUT_RDWR);
    close (server_socket);
    return (0);
}

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

int main()
{ 
    int network_socket; 
    network_socket = socket(AF_INET,SOCK_STREAM, 0);

    struct sockaddr_in server_address; 
    server_address.sin_family = AF_INET; 
    server_address.sin_port = htons(9000); 
    server_address.sin_addr.s_addr = INADDR_ANY; 

    int connection_status = connect(network_socket, (struct sockaddr*)&server_address, sizeof(server_address));
    if (connection_status == -1) { printf("ERROR"); } 

    char maw[256] = "this is a message"; 
    send(network_socket, maw, sizeof(maw), 0);
    shutdown (network_socket, SHUT_RDWR);
    close(network_socket);
    return(0);
}

当您想从客户端接收消息时，必须在

recv（）函数的代码中使用
client\u套接字。不是
服务器\u套接字本身

客户端代码：

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

int main()
{
    int server_socket;
    server_socket = socket(AF_INET,SOCK_STREAM,0);
    struct sockaddr_in server_address;
    int addrlen = sizeof(server_address);
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(9000);
    server_address.sin_addr.s_addr = INADDR_ANY;

    bind (server_socket, (struct sockaddr*) &server_address, sizeof(server_address));
    int client_socket;
    listen(server_socket, 3);
    client_socket=accept(server_socket, NULL, (socklen_t*)&addrlen);
    char response[256];

    recv(client_socket, &response, sizeof(response), 0);

    printf("%s",response);
    shutdown (client_socket, SHUT_RDWR);
    close (client_socket);
    shutdown (server_socket, SHUT_RDWR);
    close (server_socket);
    return (0);
}

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

int main()
{ 
    int network_socket; 
    network_socket = socket(AF_INET,SOCK_STREAM, 0);

    struct sockaddr_in server_address; 
    server_address.sin_family = AF_INET; 
    server_address.sin_port = htons(9000); 
    server_address.sin_addr.s_addr = INADDR_ANY; 

    int connection_status = connect(network_socket, (struct sockaddr*)&server_address, sizeof(server_address));
    if (connection_status == -1) { printf("ERROR"); } 

    char maw[256] = "this is a message"; 
    send(network_socket, maw, sizeof(maw), 0);
    shutdown (network_socket, SHUT_RDWR);
    close(network_socket);
    return(0);
}

为什么要使用
pclose（）
函数关闭套接字？它用于管道，需要
文件
指针。此外，函数从未被调用（在return语句之后）

这应该可以工作（在我的系统上测试）：

服务器：

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

int main()
{
    int server_socket;
    server_socket = socket(AF_INET,SOCK_STREAM,0);
    struct sockaddr_in server_address;
    int addrlen = sizeof(server_address);
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(9000);
    server_address.sin_addr.s_addr = INADDR_ANY;

    bind (server_socket, (struct sockaddr*) &server_address, sizeof(server_address));
    int client_socket;
    listen(server_socket, 3);
    client_socket=accept(server_socket, NULL, (socklen_t*)&addrlen);
    char response[256];

    recv(client_socket, &response, sizeof(response), 0);

    printf("%s",response);
    shutdown (client_socket, SHUT_RDWR);
    close (client_socket);
    shutdown (server_socket, SHUT_RDWR);
    close (server_socket);
    return (0);
}

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

int main()
{ 
    int network_socket; 
    network_socket = socket(AF_INET,SOCK_STREAM, 0);

    struct sockaddr_in server_address; 
    server_address.sin_family = AF_INET; 
    server_address.sin_port = htons(9000); 
    server_address.sin_addr.s_addr = INADDR_ANY; 

    int connection_status = connect(network_socket, (struct sockaddr*)&server_address, sizeof(server_address));
    if (connection_status == -1) { printf("ERROR"); } 

    char maw[256] = "this is a message"; 
    send(network_socket, maw, sizeof(maw), 0);
    shutdown (network_socket, SHUT_RDWR);
    close(network_socket);
    return(0);
}

#包括
#包括
#包括
#包括
#包括
#包括
int main（）
{
int-server_-socket；
服务器\u套接字=套接字（AF\u INET，SOCK\u STREAM，0）；
服务器地址中的结构sockaddr\u；
int addrlen=sizeof（服务器地址）；
服务器地址.sin\u family=AF\u INET；
服务器地址sin端口=htons（9000）；
server_address.sin_addr.s_addr=INADDR\u ANY；
绑定（server_socket，（struct sockaddr*）和server_地址，sizeof（server_地址））；
int客户机接口；
监听（服务器接口，3）；
client\u socket=accept（server\u socket，NULL，（socklen\u t*）和addrlen）；
字符响应[256]；
recv（客户端套接字和响应，sizeof（响应），0）；
printf（“%s”，响应）；
关闭（客户端\u套接字，关闭\RDWR）；
关闭（客户端_套接字）；
关闭（服务器\u套接字，关闭\RDWR）；
关闭（服务器_套接字）；
返回（0）；
}

客户端：

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

int main()
{
    int server_socket;
    server_socket = socket(AF_INET,SOCK_STREAM,0);
    struct sockaddr_in server_address;
    int addrlen = sizeof(server_address);
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(9000);
    server_address.sin_addr.s_addr = INADDR_ANY;

    bind (server_socket, (struct sockaddr*) &server_address, sizeof(server_address));
    int client_socket;
    listen(server_socket, 3);
    client_socket=accept(server_socket, NULL, (socklen_t*)&addrlen);
    char response[256];

    recv(client_socket, &response, sizeof(response), 0);

    printf("%s",response);
    shutdown (client_socket, SHUT_RDWR);
    close (client_socket);
    shutdown (server_socket, SHUT_RDWR);
    close (server_socket);
    return (0);
}

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

int main()
{ 
    int network_socket; 
    network_socket = socket(AF_INET,SOCK_STREAM, 0);

    struct sockaddr_in server_address; 
    server_address.sin_family = AF_INET; 
    server_address.sin_port = htons(9000); 
    server_address.sin_addr.s_addr = INADDR_ANY; 

    int connection_status = connect(network_socket, (struct sockaddr*)&server_address, sizeof(server_address));
    if (connection_status == -1) { printf("ERROR"); } 

    char maw[256] = "this is a message"; 
    send(network_socket, maw, sizeof(maw), 0);
    shutdown (network_socket, SHUT_RDWR);
    close(network_socket);
    return(0);
}

#包括
#包括
#包括
#包括
#包括
#包括
int main（）
{ 
int网络接口；
网络套接字=套接字（网络，套接字流，0）；
服务器地址中的结构sockaddr\u；
服务器地址.sin\u family=AF\u INET；
服务器地址sin端口=htons（9000）；
server_address.sin_addr.s_addr=INADDR\u ANY；
int connection_status=connect（网络套接字，（结构sockaddr*）和服务器地址，sizeof（服务器地址））；
如果（连接状态==-1）{printf（“错误”）；}
char maw[256]=“这是一条消息”；
发送（网络_套接字，maw，sizeof（maw），0）；
关闭（网络插座，关闭RDWR）；
关闭（网络插座）；
返回（0）；
}

有关函数
shutdown（）
请参见此。
服务器代码中还有一个错误

服务器代码：

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

int main()
{
    int server_socket;
    server_socket = socket(AF_INET,SOCK_STREAM,0);
    struct sockaddr_in server_address;
    int addrlen = sizeof(server_address);
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(9000);
    server_address.sin_addr.s_addr = INADDR_ANY;

    bind (server_socket, (struct sockaddr*) &server_address, sizeof(server_address));
    int client_socket;
    listen(server_socket, 3);
    client_socket=accept(server_socket, NULL, (socklen_t*)&addrlen);
    char response[256];

    recv(client_socket, &response, sizeof(response), 0);

    printf("%s",response);
    shutdown (client_socket, SHUT_RDWR);
    close (client_socket);
    shutdown (server_socket, SHUT_RDWR);
    close (server_socket);
    return (0);
}

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

int main()
{ 
    int network_socket; 
    network_socket = socket(AF_INET,SOCK_STREAM, 0);

    struct sockaddr_in server_address; 
    server_address.sin_family = AF_INET; 
    server_address.sin_port = htons(9000); 
    server_address.sin_addr.s_addr = INADDR_ANY; 

    int connection_status = connect(network_socket, (struct sockaddr*)&server_address, sizeof(server_address));
    if (connection_status == -1) { printf("ERROR"); } 

    char maw[256] = "this is a message"; 
    send(network_socket, maw, sizeof(maw), 0);
    shutdown (network_socket, SHUT_RDWR);
    close(network_socket);
    return(0);
}

当您想从客户端接收消息时，必须在
recv（）函数的代码中使用
client\u套接字。不是
服务器\u套接字本身

客户端代码：

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

int main()
{
    int server_socket;
    server_socket = socket(AF_INET,SOCK_STREAM,0);
    struct sockaddr_in server_address;
    int addrlen = sizeof(server_address);
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(9000);
    server_address.sin_addr.s_addr = INADDR_ANY;

    bind (server_socket, (struct sockaddr*) &server_address, sizeof(server_address));
    int client_socket;
    listen(server_socket, 3);
    client_socket=accept(server_socket, NULL, (socklen_t*)&addrlen);
    char response[256];

    recv(client_socket, &response, sizeof(response), 0);

    printf("%s",response);
    shutdown (client_socket, SHUT_RDWR);
    close (client_socket);
    shutdown (server_socket, SHUT_RDWR);
    close (server_socket);
    return (0);
}

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

int main()
{ 
    int network_socket; 
    network_socket = socket(AF_INET,SOCK_STREAM, 0);

    struct sockaddr_in server_address; 
    server_address.sin_family = AF_INET; 
    server_address.sin_port = htons(9000); 
    server_address.sin_addr.s_addr = INADDR_ANY; 

    int connection_status = connect(network_socket, (struct sockaddr*)&server_address, sizeof(server_address));
    if (connection_status == -1) { printf("ERROR"); } 

    char maw[256] = "this is a message"; 
    send(network_socket, maw, sizeof(maw), 0);
    shutdown (network_socket, SHUT_RDWR);
    close(network_socket);
    return(0);
}

为什么要使用
pclose（）
函数关闭套接字？它用于管道，需要
文件
指针。此外，函数从未被调用（在return语句之后）

这应该可以工作（在我的系统上测试）：

服务器：

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

int main()
{
    int server_socket;
    server_socket = socket(AF_INET,SOCK_STREAM,0);
    struct sockaddr_in server_address;
    int addrlen = sizeof(server_address);
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(9000);
    server_address.sin_addr.s_addr = INADDR_ANY;

    bind (server_socket, (struct sockaddr*) &server_address, sizeof(server_address));
    int client_socket;
    listen(server_socket, 3);
    client_socket=accept(server_socket, NULL, (socklen_t*)&addrlen);
    char response[256];

    recv(client_socket, &response, sizeof(response), 0);

    printf("%s",response);
    shutdown (client_socket, SHUT_RDWR);
    close (client_socket);
    shutdown (server_socket, SHUT_RDWR);
    close (server_socket);
    return (0);
}

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

int main()
{ 
    int network_socket; 
    network_socket = socket(AF_INET,SOCK_STREAM, 0);

    struct sockaddr_in server_address; 
    server_address.sin_family = AF_INET; 
    server_address.sin_port = htons(9000); 
    server_address.sin_addr.s_addr = INADDR_ANY; 

    int connection_status = connect(network_socket, (struct sockaddr*)&server_address, sizeof(server_address));
    if (connection_status == -1) { printf("ERROR"); } 

    char maw[256] = "this is a message"; 
    send(network_socket, maw, sizeof(maw), 0);
    shutdown (network_socket, SHUT_RDWR);
    close(network_socket);
    return(0);
}

#包括
#包括
#包括
#包括
#包括
#包括
int main（）
{
int-server_-socket；
服务器\u套接字=套接字（AF\u INET，SOCK\u STREAM，0）；
服务器地址中的结构sockaddr\u；
int addrlen=sizeof（服务器地址）；
服务器地址.sin\u family=AF\u INET；
服务器地址sin端口=htons（9000）；
server_address.sin_addr.s_addr=INADDR\u ANY；
绑定（server_socket，（struct sockaddr*）和server_地址，sizeof（server_地址））；
int客户机接口；
监听（服务器接口，3）；
client\u socket=accept（server\u socket，NULL，（socklen\u t*）和addrlen）；
字符响应[256]；
recv（客户端套接字和响应，sizeof（响应），0）；
printf（“%s”，响应）；
关闭（客户端\u套接字，关闭\RDWR）；
关闭（客户端_套接字）；
关闭（服务器\u套接字，关闭\RDWR）；
关闭（服务器_套接字）；
返回（0）；
}

客户端：

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

int main()
{
    int server_socket;
    server_socket = socket(AF_INET,SOCK_STREAM,0);
    struct sockaddr_in server_address;
    int addrlen = sizeof(server_address);
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(9000);
    server_address.sin_addr.s_addr = INADDR_ANY;

    bind (server_socket, (struct sockaddr*) &server_address, sizeof(server_address));
    int client_socket;
    listen(server_socket, 3);
    client_socket=accept(server_socket, NULL, (socklen_t*)&addrlen);
    char response[256];

    recv(client_socket, &response, sizeof(response), 0);

    printf("%s",response);
    shutdown (client_socket, SHUT_RDWR);
    close (client_socket);
    shutdown (server_socket, SHUT_RDWR);
    close (server_socket);
    return (0);
}

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

int main()
{ 
    int network_socket; 
    network_socket = socket(AF_INET,SOCK_STREAM, 0);

    struct sockaddr_in server_address; 
    server_address.sin_family = AF_INET; 
    server_address.sin_port = htons(9000); 
    server_address.sin_addr.s_addr = INADDR_ANY; 

    int connection_status = connect(network_socket, (struct sockaddr*)&server_address, sizeof(server_address));
    if (connection_status == -1) { printf("ERROR"); } 

    char maw[256] = "this is a message"; 
    send(network_socket, maw, sizeof(maw), 0);
    shutdown (network_socket, SHUT_RDWR);
    close(network_socket);
    return(0);
}

#包括
#包括
#包括
#包括
#包括
#包括
int main（）
{ 
int网络接口；
网络套接字=套接字（网络，套接字流，0）；
服务器地址中的结构sockaddr\u；
服务器地址.sin\u family=AF\u INET；
服务器地址sin端口=htons（9000）；
server_address.sin_addr.s_addr=INADDR\u ANY；
int connection_status=connect（网络套接字，（结构sockaddr*）和服务器地址，sizeof（服务器地址））；
如果（连接状态==-1）{printf（“错误”）；}
char maw[256]=“这是一条消息”；
发送（网络接口、maw、，