Aplicação Server/Client em Windows/Linux

[s4l4s]

Boas pessoal. Vim aqui tentar resolver um problema para o qual ainda não encontrei solução e espero que voces me possam ajudar. Queria fazer um pequeno programita no qual eu tenho um servidor e um cliente na qual o cliente envia um pedido (comando) a ser executado no servidor. Ok, eu sei que é simples. Isto funciona muito bem quando o servidor se encontra numa maquina com SO windows e o cliente em windows ou linux. Quando o servidor se encontra numa maquina com SO Linux entao ai' e' que se da' o problema. Da-me um nullpointer exception que me está a partir a cabeça  Bom, chega de palavreado, aqui vai o codigo:

Cliente

import java.io.IOException;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

public class Client extends Message {

    /**
     *Construtor da class Client 
     */
    public Client() {
        clientException = null;
    }

    /**
     * Metodo responsável pela conexão do user ao servidor
     * @param host ip onde se vai ligar
     * @param port porta onde se vai ligar
     * @return caso não consiga ligar, retorna a excepção
     */
    public String connect(String host, int port) {
        try {

            //ligação ao socket do servidor localhost e porta 10000

            socket = new Socket(host, port);

            //Abertura da stream de entrada

            in = new Scanner(socket.getInputStream());

            //Abertura da stream de saida

            out = new PrintStream(socket.getOutputStream());
        } catch (Exception ex) {
            clientException = "Impossivel ligar => Servidor offline? || " + ex.toString() + "\n";
//            JOptionPane.showMessageDialog(null, clientException);
        }
        return clientException;
    }

    /**
     * Metodo responsavel pelo fecho da ligação do user com o servidor
     * @return caso não consiga disconectar, retorna a excepção
     */
    public String disconnect() {
        if (socket == null) {
            clientException = "Nao existe nenhuma ligaçao.\n";
//            JOptionPane.showMessageDialog(null, clientException);
        }
        try {
            socket.close();
            in.close();
            out.close();
        } catch (Exception ex) {
            clientException = "Impossivel terminar a sessao => Existe sessao? || " + ex.toString() + "1n";
//            JOptionPane.showMessageDialog(null, clientException);
            System.out.println("Impossivel terminar a sessao => " + ex.toString());
        }
        return clientException;
    }

    /**
     * Metodo responsavel pelo envio do comando "ping" ao servidor
     * @param host ip do servidor a ser "pingado"
     * @param port porta do servidor a ser "pingado"
     * @return resposta do server
     */
    public String ping(String host, String port) throws IOException {
        connect(host, Integer.parseInt(port));
        send("ping");
        String msg = receive();
        disconnect();
        return msg;
    }

    public String executeCommand(String cmd) throws IOException {
        String[] str = cmd.split(" ");

        if (str[0].equalsIgnoreCase("ping")) {
            return ping(str[1], str[2]);
        } else {
            return "Unknown command\n";
        }
    }

    public static void main(String[] args) throws IOException {
        Client c = new Client();
        System.out.println(c.executeCommand("ping 192.168.10.140 10000"));
    }
}

Servidor

import java.io.IOException;
import java.io.PrintStream;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.UnknownHostException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Server extends Message {

    ServerSocket server;

    public Server() {
    }

    public void startServer(int Port) {
        try {
            String tmp1 = Inet4Address.getLocalHost().toString();
            String[] tmp = tmp1.split("/");
            String ip = "";
            for (String s1 : tmp) {
                ip = s1;
            }
            server = new ServerSocket(Port, 0, InetAddress.getByName(ip));
            System.out.println("Device is ready");
        } catch (Exception ex) {
            System.out.println("Device isnt ready => " + ex.toString());
        }
    }

    public void listen() {
        try {
            while (true) {
                socket = server.accept();
                connect();
                executeCommand(receive());
            }
        } catch (Exception ex) {
            Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void connect() {
        try {
            in = new Scanner(socket.getInputStream());
            out = new PrintStream(socket.getOutputStream());
        } catch (Exception ex) {
            Logger.getLogger(Message.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void ping() {
        try {
            in = new Scanner(socket.getInputStream());
            out = new PrintStream(socket.getOutputStream());
            Inet4Address ip = (Inet4Address) Inet4Address.getLocalHost();
            String msg = "Device is online. IP: " + ip.getHostAddress() + "\n";
            out.println(msg);
        } catch (Exception ex) {
            Logger.getLogger(Message.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    /**
     * 
     * @return mensagem a dizer que o server se encontra online
     * @throws java.net.UnknownHostException
     */
//    public String ping() throws UnknownHostException, IOException {
//        Inet4Address ip = (Inet4Address) Inet4Address.getLocalHost();
////        String msg = "Device " + ip.getHostName() + " is online. IP: " + ip.getHostAddress() + "\n";
//        String msg = "Device is online. IP: " + ip.getHostAddress() + "\n";
////        Process p1 = Runtime.getRuntime().exec("ssh wireless@localhost ls -l");
////        BufferedReader stdInput = new BufferedReader(new InputStreamReader(p1.getInputStream()));
////        String msg = stdInput.readLine();
//        send(msg);
//        return msg;
//    }

    /**
     * Metodo responsavel pela execução dos comandos
     * @param command comando a ser executado pelo server
     * @throws java.net.UnknownHostException caso o host seja inválido
     */
    public void executeCommand(String command) throws UnknownHostException{
        String[] str = command.split(" ");
        if (str[0].equalsIgnoreCase("ping")) {
            ping();
        } else {
            System.out.println("Unknown command");
        }
    }

    public static void main(String[] args) {
        Server s = new Server();
        s.startServer(10000);
        s.listen();
    }
}

Message - Responsavel pela envio/recepção dos comandos

import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

public class Message {
    
    Socket socket;
    public PrintStream out;
    public Scanner in;
    
    public boolean flag;
    
    public String clientException;
    public String serverException;

    /**
     * Metodo responsavel pelo envio dos comandos
     * @param msg mensagem a ser enviada
     */
    
    public void send(String msg) {
        out.println(msg);
    }
    
/**
* Metodo responsavel pela recepção dos comandos
* @return proxima linha
*/
    
    public String receive() {
        flag = true;
        return in.nextLine();
    }
}

Bom, fico à espera de respostas. Obrigado desde ja'  

EDIT: Adicionado código GeShi

[s4l4s]

Ok, podem fechar este topico. Problema resolvido 👍

[jpaulino]

Ok, podem fechar este topico. Problema resolvido 👍

E qual era a solução ? (para outros utilizadores que tenham a mesma dúvida)