Java-Client erhält nur erste Antwort von C-Server

Question

Ich erstelle ein einfaches Spiel, das aus Java-Client und C-Server besteht. Wenn der Client die erste Anfrage an den Server sendet, ist es in Ordnung. Der Server sendet eine Antwort und der Client liest sie. Wenn der Client jedoch eine zweite Anfrage sendet, sendet der Server die Antwort wie immer, aber der Client liest nichts. Wenn ich \ n aus der Antwort lösche, bleibt clinet auf readLine() hängen, was in Ordnung ist, aber wenn ich \ n zurückstelle, liest readLine() nichts. Ich bin ziemlich verzweifelt und ich habe verschiedene Aktionen versucht und die Nachricht vom Server wie 1000 Mal geändert, aber nichts funktioniert. Hier

ist Verbindungsmethode:

public int connect() { 
    try { 
     if (port != 0 && !host.equals(null)) { 
      socket = new Socket(host, port); 
      socket.setSoTimeout(5000); 
      socket.setKeepAlive(true); 
     } else { 
      socket = new Socket("localhost", 50001); 
     } 

     out = new OutputStreamWriter(socket.getOutputStream()); 
     in = new BufferedReader(new InputStreamReader(socket.getInputStream())); 

    } catch (UnknownHostException ex1) { 
     System.out.println("Unknown host: " + host); 
     return 1; 
    } catch (IOException ex2) { 
     System.out.println("No I/O: " + ex2.getMessage()); 
     return 2; 
    } 
    return 0; 
} 

Hier sind Methoden für Komunikation:

public String listRooms() throws DisconnectedException, IOException { 
    this.send(LIST_ROOMS); 

    String data = this.receive(); 
    System.out.println("Action: " + LIST_ROOMS + " Result: " + data); 

    return data;   
} 

public int createRoom(String playerName) throws IOException, DisconnectedException { 
    this.send(playerName, CREATE_ROOM); 

    int result = this.receiveInt(); 
    System.out.println("Action: " + CREATE_ROOM + " Result: " + result); 
    return result; 
} 

public void joinRoom(String playerName, int number) throws IOException, DisconnectedException { 

    String message = number + "\0" + playerName; 

    this.send(message, JOIN_ROOM); 

    try { 
     System.out.println("Action: " + JOIN_ROOM + " Result: " + this.receive()); 
    } catch (SocketTimeoutException e) { 
     throw new DisconnectedException("Connection with server lost..."); 
    } 
} 

private void send(String message, int actionNumber) throws IOException { 
    out.write((char) actionNumber); 
    out.write(message); 
    out.flush(); 
} 

private void send(int actionNumber) throws IOException { 
    out.write((char) actionNumber); 
    out.flush(); 
} 

private int receiveInt() throws IOException { 
    int response = in.read(); 
    System.out.println(response); 


    return 0; 
} 

private String receive() throws IOException { 
    String answer = in.readLine(); 

    System.out.println("ANSWER: " + answer);   

    if (answer == null) { 
     System.out.println("You recieved nothing Jon Snow..."); 
    } else if ("0".equals(answer)) { 
     System.out.println("Error recieveing answer from server"); 
     return "0"; 
    } 

    return answer; 
} 

und hier ist Server:

#include <arpa/inet.h> 
#include <netinet/in.h> 
#include <pthread.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <sys/socket.h> 
#include <unistd.h> 

#include "room.h" 

void error_message(const char *msg); 

typedef struct thread_args 
{ 
    int client_sock; 
    char ip_address[16]; 
} thread_args; 


void *thread_service(void *args) 
{ 
    int client_sock; 
    char buffer[256] = ""; 
    char cbuf; 
    int n; 
    char address[16] = ""; 
    int result = 0; 
    room *room = NULL; 


    client_sock = ((thread_args *) args)->client_sock; 
    strcpy(address, ((thread_args *) args)->ip_address); 

    pthread_detach(pthread_self()); 

    while(1) 
    { 
     if ((recv(client_sock, &cbuf, 1, 0)) == -1) 
     { 
      printf("Receive message from %s failure\n", address); 
      break; 
     } 

     switch (cbuf) { 
      case 0: 
       result = create_room(&room, client_sock); 

       if(!result) 
       { 
        /* TODO */ 
       } 
       memset(buffer, 0, 256); 
       sprintf(buffer, "%d\n", result); 

       n = send(client_sock, buffer, 256, 0); 

       if (n <= 0) { 
        perror("ERROR writing to socket\n"); 
        close(client_sock); 
        break; 
       } 
       printf("sent\n"); 
       break; 
      case 1: 
       result = join_room(&room, client_sock); 
       if(!result) 
       { 
        /* TODO */ 
       } 

       printf("Join to room for %s\n", address); 
       sprintf(buffer, "%d\n", result); 
       n = send(client_sock, buffer, 256, 0); 

       if (n <= 0) { 
        perror("ERROR writing to socket\n"); 
        break; 
       } 

       break; 
      case 2: 
       printf("List rooms\n"); 
       memset(buffer, 0, 256); 
       result = list_rooms(buffer); 

       if(!result) { 
        /* TODO */ 
       } 

       printf("Sending message: %s", buffer); 
       n = send(client_sock, buffer, 256, 0); 

       if (n <= 0) { 
        perror("ERROR writing to socket\n"); 
        close(client_sock); 
        break; 
       } 
       printf("Sent\n"); 
       break; 
      case 5: 
       exit(0); 
       break; 
     } 

    } 
    close(client_sock); 
    free(args); 
    return 0; 
} 

int main(int argc, char *argv[]) 
{ 
int sock_fd = 0, new_sock_fd = 0, port = 0, clilen = 0; 
struct sockaddr_in serv_addr, cli_addr; 
int *th_socket; 
pthread_t thread_id; 
thread_args *args = (thread_args *)malloc(sizeof(thread_args)); 
char address[16]; 
int yes = 1; 

if(argc < 2) 
{ 
    fprintf(stderr, "Error missing port"); 
    return 0; 
} 

sock_fd = socket(AF_INET, SOCK_STREAM, 0); 

if(sock_fd < 0) 
    fprintf(stderr, "Error opening socket"); 

memset(&serv_addr, 0, sizeof(serv_addr)); 

port = atoi(argv[1]); 

serv_addr.sin_family = AF_INET; 
serv_addr.sin_port = htons(port); 
serv_addr.sin_addr.s_addr = INADDR_ANY; 

if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == 0) 
{ 
    printf("Socket options was set.\n"); //TODO 
} 
else 
{ 
    printf("Set socket options failure.\n"); //TODO 
} 

if(bind(sock_fd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) 
    error_message("Error in connection"); 

listen(sock_fd, 5); 

if (pthread_mutex_init(&lock, NULL) != 0) 
{ 
    printf("Mutex init failed.\n"); 
    return 1; 
} 

while(1) 
{ 
    printf("Waiting for new connection\n"); 
    clilen = sizeof(cli_addr); 
    new_sock_fd = accept(sock_fd, (struct sockaddr *)&cli_addr, &clilen); 

    if (new_sock_fd < 0) { 
     printf("Error accepting new connection!\n"); 
     continue; 
    } 

    strcpy(args->ip_address, inet_ntoa(cli_addr.sin_addr)); 
    args->client_sock = new_sock_fd; 

    if (new_sock_fd > 0) { 
     th_socket=malloc(sizeof(int)); 
     *th_socket=new_sock_fd; 

     printf("Creating new thread for %s\n", args->ip_address); 
     pthread_create(&thread_id, NULL, (void *)&thread_service, (void *)args); 
    } else { 
     printf("Error creating thread for new connection.\n"); 
     return -1; 
    } 
} 

return 0; 
} 

Also, wenn Sie C servera Nachricht senden möchten wird es so aussehen:

UPDATE: A hat, dass herausgefunden, es war ziemlich böse Fehler, vielleicht wäre es andere zu helfen .. In Nachricht von JAVA-Client-Server sein muss (in meinem Fall) manuell angehängt „\ n“ Zeichen, Andernfalls werden einige Zeichen gesendet, die den Server verwirren. so sieht mein Code so aus out.write(message + "\n"); und dann einfach flush aufrufen() und es wird in Ordnung sein.

Answer 1

Sie haben die Enline Zeichen hinzufügen, aber wenn Sie die Printwriter verwenden, Anspiel dann könnte man die println Methode verwenden ...

PrintWriter pw = new PrintWriter(socket.getOutputStream(), true); 
pw.println("Bla bla"); 

Answer 2

So ist die Antwort einfach. Wenn Sie OutputStreamWriter verwenden, müssen Sie Ihrer Nachricht ein Zeilenumbruchzeichen hinzufügen.