Sockets: Server in C/C++, Klient in Java

[FBIagent]

Hallo,
ich wollte mir eine kleine Klient Anwendung schreiben. Dieser soll einige Daten an
einen Server übermitteln. Dieser verarbeitet diese Daten und sendet entweder 1 oder 2
zurück. Klient ist in Java geschrieben und der Server in C/C++(Deshalb war ich mich
auch nicht so ganz sicher wo ich nun mein Thema erstellen sollte).

Dies ist der Klient:

package net.sf.l2j.gameserver;
 
import java.io.*;
import java.net.*;
 
public class GeoClient
{
        private boolean _connected = false;
        private Socket _geoServerSocket = null;
        private DataInputStream _input = null;
        private DataOutputStream _output = null;

        public static GeoClient _instance = null;
 
        public GeoClient()
        {
                System.out.print("Connecting to geodata server... ");
 
                try
                {
                        _geoServerSocket = new Socket("127.0.0.1", 3388);
                        _input = new DataInputStream(_geoServerSocket.getInputStream());
                        _output = new DataOutputStream(_geoServerSocket.getOutputStream());
                }
                catch (IOException ioe)
                {
                        _connected = false;
                        System.out.println("failed! " + ioe.getMessage());
                }
 
                _connected = true;
                System.out.println("done.");
        }

        public static GeoClient getInstance()
        {
                if (_instance == null)
                        _instance = new GeoClient();
 
                return _instance;
        }
 
        public byte r()
        {
                if (!_connected)
                        return 48;
 
                try
                {
                        byte result = _input.readByte();
 
                        System.out.println("GeoClient: Received |" + result + "|");
 
                        return result;
                }
                catch (IOException ioe)
                {
                        System.out.println(ioe.getMessage());
                }
 
                return 48;
        }
 
        private void w(String str)
        {
                if (!_connected)
                        return;
 
                try
                {
                        _output.writeBytes(str);
                }
                catch (IOException ioe)
                {
                        System.out.println(ioe.getMessage());
                }
        }
 

        public boolean isInWater(int x, int y)
        {
                w("0");
                w(String.valueOf(x));
                w(String.valueOf(y));
 
                byte waterResult = r();
 
                switch (waterResult)
                {
                        case 48: return false;
                        case 49: return false;
                        case 50: return true;
                }
 

                return false;
        }
 

        public boolean canMoveNext(int x, int y, int z, int toX, int toY, int heading)
        {
                w("1");
                w(String.valueOf(x));
                w(String.valueOf(y));
                w(String.valueOf(z));
                w(String.valueOf(toX));
                w(String.valueOf(toY));
                w(String.valueOf(heading));
 
                byte moveResult = r();
 
                switch (moveResult)
                {
                        case 48: return true;
                        case 49: return true;
                        case 50: return false;
                }
 
                return true;
        }
}

Beim C/C++ Teil werde ich nur die empfänfer und sender stellen posten
(verbindungsaufbau funktioniert ja):

for (;;)
{
        int bufferSize,
                sendBuffSize; // size of received buffers
 
        if ((bufferSize = recv(gameServerSock, recvBuffType, 1, 0)) == SOCKET_ERROR) // receive buffer
        {}//printf("Receive failed: %d", WSAGetLastError());
        else
        {
                std::string type = recvBuffType;
 
                if (type == "0")
                {
                        char x[256],
                               y[256];
 
                        bufferSize = recv(gameServerSock, x, 256, 0); // receive buffer
                        bufferSize = recv(gameServerSock, y, 256, 0); // receive buffer
                        printf("Water check\n");
                        printf("|%s|%s|\n", x, y);
 
                        if (isInWater(atoi(x), atoi(y)))
                                sendBuffSize = send(gameServerSock, "2", 1, 0);
                        else
                                sendBuffSize = send(gameServerSock, "1", 1, 0);
                }
                else if (type == "1")
                {
                        char x[256],
                               y[256],
                               z[256],
                               toX[256],
                               toY[256],
                               heading[256];
 
                        bufferSize = recv(gameServerSock, x, 256, 0); // receive buffer
                        bufferSize = recv(gameServerSock, y, 256, 0); // receive buffer
                        bufferSize = recv(gameServerSock, z, 256, 0); // receive buffer
                        bufferSize = recv(gameServerSock, toX, 256, 0); // receive buffer
                        bufferSize = recv(gameServerSock, toY, 256, 0); // receive buffer
                        bufferSize = recv(gameServerSock, heading, 256, 0); // receive buffer
                        printf("Move check\n");
                        printf("|%s|%s|%s|%s|%s|%s|\n", x, y, z, toX, toY, heading);
 
                        if (canMoveNext(atoi(x), atoi(y), atoi(z), atoi(toX), atoi(toY), atoi(heading)))
                                sendBuffSize = send(gameServerSock, "1", 1, 0);
                        else
                                sendBuffSize = send(gameServerSock, "2", 1, 0);
                }
                else
                        sendBuffSize = send(gameServerSock, "1", 1, 0);
        }
 
        if (kbhit())
        {
                if (getch() == 'q')
                        break;
        }
}

Ich weis ist etwas gemischt, aber Klient hat in Java zu sein und Server hat in C/C++
zu sein.

Wenn im Klient _input.readByte(); aufgerufen wird gibt es einen Problem: Der Klient
wartet auf eine Antwort vom Server. Diese kommt aber nie an. Sollte sie aber da der
Server sendet. Nachdem einige zeit vergangen ist terminiert der Server einfach
unerwartet(nichts geht einfach nur aus, das ist nicht vorgesehen). Nun bekomme ich
auch die IOException von Java.

An den Funktionen isInWater() und canMoveNext() sollte es nicht liegen da diese zum test erst einmal nur
true bzw. false zurück liefern.

Wäre nicht schlecht wenn jemand helfen könnte.

Mit freundlichen grüßen,
FBIagent