在从客户端发送任何消息之前，无法从服务器端到客户端打印消息 [英] Unable to print message from server side to client side before sending any message from client
本文介绍了在从客户端发送任何消息之前，无法从服务器端到客户端打印消息的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
我有两个程序用于服务器和客户端。我的服务器可以连接到多个客户端。但现在我面临的问题是，我想显示一些消息从服务器端到客户端，但我不能这样做。下面提供了服务器和客户端程序。我认为阻止我在客户端打印消息的语法是 scanf ，它使用客户端的代码（第二行while循环）。我没有得到任何解决方案，如何显示来自服务器端的两个消息，当客户端将连接。
问题1：
当客户端连接时，我想在客户端显示的服务器端消息：在 new_connection_handler 函数中）
message =这是连接处理程序\\ n;
message =键入内容\\\
;
问题2：
$ b b
为什么我需要在客户端使用 sleep（2）？如果我不使用 sleep（2），那么我不能接收客户端在客户端发送的数据。数据显示当我从客户端第二次发送的东西。
问题3：
可以同时写入客户端和服务器
pre>＃include< stdio.h>
＃include< string.h> // strlen
＃include< stdlib.h> // strlen
＃include< sys / socket.h>
＃include< arpa / inet.h> // inet_addr
＃include< unistd.h> // write
＃include< pthread.h> // for thread
#define MAX_CLIENTS 5
//线程函数
void * new_connection_handler（void *）;
int main（int argc，char * argv []）
{
int socket_desc，client_sock，c，* new_sock;
struct sockaddr_in服务器，客户端;
//创建套接字
socket_desc = socket（AF_INET，SOCK_STREAM，0）;
if（socket_desc == -1）
{
printf（Could not create socket）;
}
//准备sockaddr_in结构
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = htons（8888）;
bzero（& server.sin_zero，8）;
//绑定
if（bind（socket_desc，（struct sockaddr *）& server，sizeof（server））< 0）
{
//打印错误消息
perror（bind failed。Error）;
return 1;
}
// Listen
listen（socket_desc，MAX_CLIENTS）;
//接受和传入连接
printf（正在等待传入连接\\\
）;
c = sizeof（struct sockaddr_in）;
while（（client_sock = accept（socket_desc，（struct sockaddr *）& client，（socklen_t *）& c）））
{
printf（Connection accepted）;
pthread_t thread_id;
if（pthread_create（& thread_id，NULL，new_connection_handler，（void *）& client_sock）< 0）
{
perror（could not create thread）;
return 1;
}
printf（Handler assigned \\\
）;
}
if（client_sock <0）
{
perror（accept failed）;
return 1;
}
return 0;
}
void * new_connection_handler（void * socket_desc）
{
//获取套接字描述符
int sock = * *）socket_desc;
int read_size;
char * message，client_message [2000];
//向客户端发送一些消息
message =这是连接处理程序\\\
;
write（sock，message，strlen（message））;
message =输入内容\\\
;
write（sock，message，strlen（message））;
//从客户端接收消息
while（（read_size = recv（sock，client_message，2000，0））> 0）
{
//将消息发送回客户端
write（sock，client_message，strlen（client_message））;
}
if（read_size == 0）
{
printf（Client disconnected\）;
fflush（stdout）;
}
else if（read_size == -1）
{
perror（recv failed）;
}
//释放套接字指针
free（socket_desc）;
return 0;
}
客户代码：
＃include< stdio.h> // printf
＃include< string.h> // strlen
＃include< sys / socket.h> // socket
＃include< arpa / inet.h> // inet_addr
int main（int argc，char * argv []）
{
int sock;
struct sockaddr_in server;
char message [1000]，server_reply [2000];
int len;
//创建套接字
sock = socket（AF_INET，SOCK_STREAM，0）;
if（sock == -1）
{
printf（Could not create socket）;
}
puts（Socket created）;
server.sin_addr.s_addr = inet_addr（127.0.0.1）;
server.sin_family = AF_INET;
server.sin_port = htons（8888）;
//连接到远程服务器
if（connect（sock，（struct sockaddr *）& server，sizeof（server））< 0）
{
perror（connect failed。Error）;
return 1;
}
puts（Connected\\\
）;
//继续与服务器通信
while（1）
{
printf（Enter message：）;
scanf（％s，message）;
//发送一些数据
if（send（sock，message，strlen（message），0）< 0）
{
puts （发送失败）;
return 1;
}
sleep（2）;
//从服务器接收答复
if（（len = recv（sock，server_reply，2000，0））<0）
{
puts ）;
break;
}
puts（Server reply：）;
server_reply [len] ='\0';
printf（％s\\\
，server_reply）;
}
close（sock）;
return 0;
}
解决方案
使用服务器的两个发送打开客户端处理线程。没有你的睡眠，你拿起一个，但不是另一个。你的缓冲区大小也没有被正确使用，因为它们不一致被当作终止字符串，事实上它们的发送长度是基于 strlen （这是确定，所以长因为它是一致的）。
我认为这是你尝试做，做一些修改：
客户端代码
#include< stdio.h> ;
#include< string.h>
#include< sys / socket.h>
#include< arpa / inet.h>
#include< unistd.h>
#include< stdint.h>
int main（int argc，char * argv []）
{
int sock;
struct sockaddr_in server;
char消息[1000]，server_reply [2000];
int len;
//创建套接字
sock = socket（AF_INET，SOCK_STREAM，0）;
if（sock == -1）
{
printf（Could not create socket）;
}
puts（Socket created）;
server.sin_addr.s_addr = inet_addr（127.0.0.1）;
server.sin_family = AF_INET;
server.sin_port = htons（8888）;
//连接到远程服务器
if（connect（sock，（struct sockaddr *）& server，sizeof（server））< 0）
{
perror（connect failed。Error）;
return 1;
}
puts（Connected\\\
）;
//与服务器保持通信
while（（len = recv（sock，server_reply，sizeof（server_reply），0））> 0）
{
printf（Server reply：％。* s，len，server_reply）;
printf（Enter message：）;
if（fgets（message，sizeof（message），stdin）== NULL）
break;
//发送一些数据
if（send（sock，message，strlen（message），0）< 0）
{
puts ）;
return 1;
}
}
close（sock）;
return 0;
}
服务器代码
＃include< stdio.h>
＃include< string.h>
＃include< stdlib.h>
＃include< sys / socket.h>
＃include< arpa / inet.h>
＃include< unistd.h>
＃include< pthread.h>
＃include< stdint.h>
#define MAX_CLIENTS 5
//线程函数
void * new_connection_handler（void *）;
int main（int argc，char * argv []）
{
int socket_desc，client_sock;
struct sockaddr_in服务器，客户端;
socklen_t c = sizeof（client）;
//创建套接字
socket_desc = socket（AF_INET，SOCK_STREAM，0）;
if（socket_desc == -1）
{
printf（Could not create socket）;
}
//准备sockaddr_in结构
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = htons（8888）;
bzero（& server.sin_zero，8）;
//绑定
if（bind（socket_desc，（struct sockaddr *）& server，sizeof（server））< 0）
{
//打印错误消息
perror（bind failed。Error）;
return 1;
}
// Listen
listen（socket_desc，MAX_CLIENTS）;
//接受和传入连接
printf（正在等待传入连接\\\
）;
c = sizeof（client）;
while（（client_sock = accept（socket_desc，（struct sockaddr *）& client，& c）））
{
printf（Connection accepted）;
pthread_t thread_id;
if（pthread_create（& thread_id，NULL，new_connection_handler，（void *）（intptr_t）client_sock）< 0）
{
perror ）;
return 1;
}
printf（Handler assigned \\\
）;
}
if（client_sock <0）
{
perror（accept failed）;
return 1;
}
return 0;
}
void * new_connection_handler（void * socket_desc）
{
//获取套接字描述符
int sock =（intptr_t） socket_desc;
int read_size = 0;
char client_message [2000];
static const char rdy [] =READY\\\
;
write（sock，rdy，sizeof（rdy）-1）;
//从客户端接收消息
while（（read_size = recv（sock，client_message，sizeof（client_message），0））> client_message，read_size）;
if（read_size == 0）
{
printf（Client disconnected\）;
fflush（stdout）;
}
else if（read_size == -1）
{
perror（recv failed）;
}
return 0;
}
这仍然需要在客户端线程更好的连接逻辑，并用适当的标志编译每一个。我认为它是你想要达到的。
最好的运气。
I have two programs for server and client. My server can connect to multiple client. But the problem right now I am facing is that, I want to display some message from the server side to client side but I am unable to do that. Both the server and client program are provided below. I think the syntax that is preventing me to print the message on the client side is scanfwhich is used the code of client (second line of the while loop). I am not getting any solution for that about how to display the two messages from the server side when the client will get connected.
Problem 1:
Server side messages that I want to display on the client side when client gets connected : (can be found in the new_connection_handler function)
message = "This is connection handler\n";
message = "Type something \n";
Problem 2:
Why I need to use the sleep (2) on the client side? If I do not use the sleep (2), then I cannot receive the data sent by the client on the client side. The data shows when I send something second time from the client side.
Problem 3:
Is it possible to write both the client and server code together and compile and run it using command line arguments?
Server Code:
#include<stdio.h>
#include<string.h> //strlen
#include<stdlib.h> //strlen
#include<sys/socket.h>
#include<arpa/inet.h> //inet_addr
#include<unistd.h> //write
#include<pthread.h> //for thread
#define MAX_CLIENTS 5
//the thread function
void *new_connection_handler(void *);
int main(int argc , char *argv[])
{
int socket_desc , client_sock , c , *new_sock;
struct sockaddr_in server , client;
//Create socket
socket_desc = socket(AF_INET , SOCK_STREAM , 0);
if (socket_desc == -1)
{
printf("Could not create socket");
}
//Prepare the sockaddr_in structure
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = htons( 8888 );
bzero (&server.sin_zero, 8);
//Bind
if( bind(socket_desc,(struct sockaddr *)&server , sizeof(server)) < 0)
{
//print the error message
perror("bind failed. Error");
return 1;
}
//Listen
listen(socket_desc , MAX_CLIENTS);
//Accept and incoming connection
printf("Waiting for incoming connections\n");
c = sizeof(struct sockaddr_in);
while( (client_sock = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c)) )
{
printf("Connection accepted");
pthread_t thread_id;
if( pthread_create( &thread_id , NULL , new_connection_handler , (void*) &client_sock) < 0)
{
perror("could not create thread");
return 1;
}
printf("Handler assigned\n");
}
if (client_sock < 0)
{
perror("accept failed");
return 1;
}
return 0;
}
void *new_connection_handler(void *socket_desc)
{
//Get the socket descriptor
int sock = *(int*)socket_desc;
int read_size;
char *message , client_message[2000];
//Send some messages to the client
message = "This is connection handler\n";
write(sock , message , strlen(message));
message = "Type something \n";
write(sock , message , strlen(message));
//Receive a message from client
while( (read_size = recv(sock , client_message , 2000 , 0)) > 0 )
{
//Send the message back to client
write(sock , client_message , strlen(client_message));
}
if(read_size == 0)
{
printf("Client disconnected\n");
fflush(stdout);
}
else if(read_size == -1)
{
perror("recv failed");
}
//Free the socket pointer
free(socket_desc);
return 0;
}
Client Code:
#include<stdio.h> //printf
#include<string.h> //strlen
#include<sys/socket.h> //socket
#include<arpa/inet.h> //inet_addr
int main(int argc , char *argv[])
{
int sock;
struct sockaddr_in server;
char message[1000] , server_reply[2000];
int len;
//Create socket
sock = socket(AF_INET , SOCK_STREAM , 0);
if (sock == -1)
{
printf("Could not create socket");
}
puts("Socket created");
server.sin_addr.s_addr = inet_addr("127.0.0.1");
server.sin_family = AF_INET;
server.sin_port = htons( 8888 );
//Connect to remote server
if (connect(sock , (struct sockaddr *)&server , sizeof(server)) < 0)
{
perror("connect failed. Error");
return 1;
}
puts("Connected\n");
//keep communicating with server
while(1)
{
printf("Enter message : ");
scanf("%s" , message);
//Send some data
if( send(sock , message , strlen(message) , 0) < 0)
{
puts("Send failed");
return 1;
}
sleep (2);
//Receive a reply from the server
if((len = recv(sock , server_reply , 2000 , 0)) < 0)
{
puts("recv failed");
break;
}
puts("Server reply :");
server_reply [len]='\0';
printf("%s\n", server_reply);
}
close(sock);
return 0;
}
解决方案
Your frames are out of sync You open your client handling thread with two sends from the server. Without your "sleep", you pick up one, but not the other. your buffer sizes are also not being used correctly, as they're inconsistently being treated as terminated strings when in fact their send length is based on strlen (which is ok, so long as it is consistent).
I think this is what you're trying to do, with a few modifications:
Client Code
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdint.h>
int main(int argc , char *argv[])
{
int sock;
struct sockaddr_in server;
char message[1000] , server_reply[2000];
int len;
//Create socket
sock = socket(AF_INET , SOCK_STREAM , 0);
if (sock == -1)
{
printf("Could not create socket");
}
puts("Socket created");
server.sin_addr.s_addr = inet_addr("127.0.0.1");
server.sin_family = AF_INET;
server.sin_port = htons( 8888 );
//Connect to remote server
if (connect(sock , (struct sockaddr *)&server , sizeof(server)) < 0)
{
perror("connect failed. Error");
return 1;
}
puts("Connected\n");
//keep communicating with server
while((len = recv(sock, server_reply, sizeof(server_reply), 0)) > 0)
{
printf("Server reply: %.*s", len, server_reply);
printf("Enter message : ");
if (fgets(message, sizeof(message), stdin) == NULL)
break;
//Send some data
if( send(sock , message , strlen(message) , 0) < 0)
{
puts("Send failed");
return 1;
}
}
close(sock);
return 0;
}
Server Code
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<pthread.h>
#include<stdint.h>
#define MAX_CLIENTS 5
//the thread function
void *new_connection_handler(void *);
int main(int argc , char *argv[])
{
int socket_desc , client_sock;
struct sockaddr_in server , client;
socklen_t c = sizeof(client);
//Create socket
socket_desc = socket(AF_INET , SOCK_STREAM , 0);
if (socket_desc == -1)
{
printf("Could not create socket");
}
//Prepare the sockaddr_in structure
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = htons( 8888 );
bzero (&server.sin_zero, 8);
//Bind
if( bind(socket_desc,(struct sockaddr *)&server , sizeof(server)) < 0)
{
//print the error message
perror("bind failed. Error");
return 1;
}
//Listen
listen(socket_desc , MAX_CLIENTS);
//Accept and incoming connection
printf("Waiting for incoming connections\n");
c = sizeof(client);
while( (client_sock = accept(socket_desc, (struct sockaddr *)&client, &c)) )
{
printf("Connection accepted");
pthread_t thread_id;
if( pthread_create( &thread_id , NULL , new_connection_handler , (void*) (intptr_t)client_sock) < 0)
{
perror("could not create thread");
return 1;
}
printf("Handler assigned\n");
}
if (client_sock < 0)
{
perror("accept failed");
return 1;
}
return 0;
}
void *new_connection_handler(void *socket_desc)
{
//Get the socket descriptor
int sock = (intptr_t)socket_desc;
int read_size = 0;
char client_message[2000];
static const char rdy[] = "READY\n";
write(sock, rdy, sizeof(rdy)-1);
//Receive a message from client
while( (read_size = recv(sock , client_message , sizeof(client_message) , 0)) > 0 )
write(sock , client_message , read_size);
if(read_size == 0)
{
printf("Client disconnected\n");
fflush(stdout);
}
else if(read_size == -1)
{
perror("recv failed");
}
return 0;
}
This still needs better join-logic on the client threads, but if you paste and compile each with appropriate flags I think it does what you're trying to achieve.
Best of luck.
这篇关于在从客户端发送任何消息之前，无法从服务器端到客户端打印消息的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
