Programvaruutveckling med funktionalitet för klient-serververktyg Windows, del 01

Hej.

I dagens avsnitt skulle jag vilja diskutera processen för att skriva klient-serverapplikationer som utför funktioner för standardverktyg i Windows, såsom Telnet, TFTP, etc. Det är klart att jag inte kommer att bidra med något nytt – alla dessa verktyg har fungerat framgångsrikt i flera år, men jag tror att inte alla vet vad som händer under huven.

Det är precis vad det här handlar om nedan.

I den här artikeln, för att inte dra ut på det, kommer jag att skriva bara om Telnet-servern, men för tillfället finns det ytterligare material om andra verktyg – det kommer i kommande delar av serien.

Först och främst är det viktigt att förstå vad Telnet är, varför det behövs och vad man använder det till. Jag kommer inte att citera källor ordagrant (om det behövs – jag kan bifoga länkar till material i slutet av artikeln), jag kommer bara att säga att Telnet möjliggör fjärråtkomst till kommandoraden på en enhet. I stort sett slutar dess funktionalitet där (jag har medvetet utelämnat nämna hur man ser på serverporten, om detta senare). Så, för att implementera detta, behöver vi ta emot en sträng på klienten, skicka den till servern, försöka bearbeta den i kommandoraden, läsa svar från kommandoraden, om det finns något, vidarebefordra det tillbaka till klienten och visa det på skärmen, eller om ett fel uppstår, låta användaren förstå att något är fel.

För att genomföra det ovanstående, behövs därför 2 arbetande klasser och en testklass, från vilken vi kommer att starta servern och genom vilken klienten kommer att fungera.
För närvarande inkluderar applikationens struktur:

• TelnetClient
• TelnetClientTester
• TelnetServer
• TelnetServerTester

Låt oss gå igenom var och en av dem:

TelnetClient

Allt som den här klassen ska kunna göra är att skicka mottagna kommandon och visa de mottagna svaren. Dessutom måste den kunna ansluta till en godtycklig (som nämnts ovan) port på den fjärrstyrda enheten och koppla ifrån den.

För detta har följande funktioner implementerats:

Funktionen som tar emot en socket-adress som argument, öppnar en anslutning och startar in- och utströmningar (variablerna för strömmen har deklarerats ovan, fullständiga källkoder finns i slutet av artikeln).

 public void run(String ip, int port)
    {
        try {
            Socket socket = new Socket(ip, port);
            InputStream sin = socket.getInputStream();
            OutputStream sout = socket.getOutputStream();
            Scanner keyboard = new Scanner(System.in);
            reader = new Thread(() -> read(keyboard, sout));
            writer = new Thread(() -> write(sin));
            reader.start();
            writer.start();
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

Överlagring av samma funktion som kopplar upp mot standardporten – för telnet är det 23

    public void run(String ip)
    {
        run(ip, 23);
    }

Funktionen läser tecken från tangentbordet och skickar dem till utgående socket – vilket är karaktäristiskt att göra i radläge, inte teckenläge:

    private void read(Scanner keyboard, OutputStream sout)
    {
        try {
            String input = new String();
            while (true) {
                input = keyboard.nextLine();
                for (char i : (input + " n").toCharArray())
                    sout.write(i);
            }
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

Funktionen tar emot data från socket och visar dem på skärmen

    private void write(InputStream sin)
    {
        try {
            int tmp;
            while (true){
                tmp = sin.read();
                System.out.print((char)tmp);
            }
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

Funktionen stoppar mottagning och överföring av data

    public void stop()
    {
        reader.stop();
        writer.stop();
    }
}

TelnetServer

Denna klass bör ha funktionalitet för att ta emot kommandon från socket, skicka dem för utförande och skicka svaret tillbaka till socket. Programmet har medvetet ingen inmatningskontroll, eftersom för det första finns det i "lådkontakt" möjlighet att formatera serverns disk och för det andra har säkerhetsfrågan utelämnats i denna artikel, och därför finns det inget ord om kryptering eller SSL.

Det finns totalt 2 funktioner (en av dem är överlagrad), och generellt är det inte en särskilt bra praxis, men inom ramen för denna uppgift tyckte jag att det var lämpligt att låta allt vara som det är.

 boolean isRunning = true;
    public void run(int port)    {

        (new Thread(() -> { try {
            ServerSocket ss = new ServerSocket(port); // Skapar en server socket och binder den till angiven port
            System.out.println("Port " + port + " väntar på anslutningar");

            Socket socket = ss.accept();
            System.out.println("Ansluten");
            System.out.println();

            // Hämtar in- och utströmmen för socketen, så nu kan vi ta emot och skicka data till klienten.
            InputStream sin = socket.getInputStream();
            OutputStream sout = socket.getOutputStream();

            Map env = System.getenv();
            String wayToTemp = env.get("TEMP") + "tmp.txt";
            for (int i : ("Connected

".toCharArray()))
                sout.write(i);
            sout.flush();

            String buffer = new String();
            while (isRunning) {

                int intReader = 0;
                while ((char) intReader != '\n') {
                    intReader = sin.read();
                    buffer += (char) intReader;
                }


                final String inputToSubThread = "cmd /c " + buffer.substring(0, buffer.length() - 2) + " 2>&1";


                new Thread(() -> {
                    try {

                        Process p = Runtime.getRuntime().exec(inputToSubThread);
                        InputStream out = p.getInputStream();
                        Scanner fromProcess = new Scanner(out);
                        try {

                            while (fromProcess.hasNextLine()) {
                                String temp = fromProcess.nextLine();
                                System.out.println(temp);
                                for (char i : temp.toCharArray())
                                    sout.write(i);
                                sout.write('\n');
                                sout.write('\r');
                            }
                        }
                        catch (Exception e) {
                            String output = "Något gick fel... Felkod: " + e.getStackTrace();
                            System.out.println(output);
                            for (char i : output.toCharArray())
                                sout.write(i);
                            sout.write('\n');
                            sout.write('\r');
                        }

                        p.getErrorStream().close();
                        p.getOutputStream().close();
                        p.getInputStream().close();
                        sout.flush();

                    }
                    catch (Exception e) {
                        System.out.println("Fel: " + e.getMessage());
                    }
                }).start();
                System.out.println(buffer);
                buffer = "";

            }
        }
        catch(Exception x) {
            System.out.println(x.getMessage());
        }})).start();

    }

Programmet öppnar en serverport, läser data från den tills det stöter på kommandoslutsymbolen, skickar kommandot till en ny process, och utdata från processen omdirigeras till socketen. Så enkelt som en Kalashnikov.

Därför finns det också en överlagring för den här funktionen med en standardport:

 public void run()
    {
        run(23);
    }

Och så finns det också en funktion som stoppar servern — den är också ganska trivial, den bryter den eviga cykeln genom att bryta dess villkor.

    public void stop()
    {
        System.out.println("Server was stopped");
        this.isRunning = false;
    }

Jag kommer inte att gå igenom testklasser här, de finns längre ner — allt de gör är att kontrollera att de publika metoderna fungerar. Allt finns på Git.

Sammanfattningsvis kan du förstå principerna för de grundläggande konsolverktygen på ett par kvällar. Nu när vi telnetar till den fjärrdatorn förstår vi vad som händer — magin har försvunnit.)

Så, länkar:
Alla källkoder har funnits, finns nu och kommer alltid finnas här
Om Telnet
Mer om Telnet

Källa: habr.com