ਵਿੰਡੋਜ਼ ਕਲਾਇੰਟ-ਸਰਵਰ ਉਪਯੋਗਤਾਵਾਂ ਦੀ ਕਾਰਜਸ਼ੀਲਤਾ ਦੇ ਨਾਲ ਸੌਫਟਵੇਅਰ ਲਿਖਣਾ, ਭਾਗ 01

ਨਮਸਕਾਰ।

ਅੱਜ ਮੈਂ ਕਲਾਇੰਟ-ਸਰਵਰ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਲਿਖਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਵੇਖਣਾ ਚਾਹਾਂਗਾ ਜੋ ਮਿਆਰੀ ਵਿੰਡੋਜ਼ ਉਪਯੋਗਤਾਵਾਂ ਦੇ ਫੰਕਸ਼ਨ ਕਰਦੇ ਹਨ, ਜਿਵੇਂ ਕਿ ਸ਼ੁੱਧ ਜਾਵਾ ਵਿੱਚ ਟੈਲਨੈੱਟ, ਟੀਐਫਟੀਪੀ, ਆਦਿ, ਆਦਿ। ਇਹ ਸਪੱਸ਼ਟ ਹੈ ਕਿ ਮੈਂ ਕੁਝ ਨਵਾਂ ਨਹੀਂ ਲਿਆਵਾਂਗਾ - ਇਹ ਸਾਰੀਆਂ ਉਪਯੋਗਤਾਵਾਂ ਇੱਕ ਸਾਲ ਤੋਂ ਵੱਧ ਸਮੇਂ ਤੋਂ ਸਫਲਤਾਪੂਰਵਕ ਕੰਮ ਕਰ ਰਹੀਆਂ ਹਨ, ਪਰ ਮੇਰਾ ਮੰਨਣਾ ਹੈ ਕਿ ਹਰ ਕੋਈ ਨਹੀਂ ਜਾਣਦਾ ਕਿ ਹੁੱਡ ਦੇ ਹੇਠਾਂ ਕੀ ਹੋ ਰਿਹਾ ਹੈ।

ਇਹ ਬਿਲਕੁਲ ਉਹੀ ਹੈ ਜੋ ਕੱਟ ਦੇ ਅਧੀਨ ਚਰਚਾ ਕੀਤੀ ਜਾਵੇਗੀ.

ਇਸ ਲੇਖ ਵਿਚ, ਇਸ ਨੂੰ ਬਾਹਰ ਨਾ ਖਿੱਚਣ ਲਈ, ਆਮ ਜਾਣਕਾਰੀ ਤੋਂ ਇਲਾਵਾ, ਮੈਂ ਸਿਰਫ ਟੇਲਨੈੱਟ ਸਰਵਰ ਬਾਰੇ ਲਿਖਾਂਗਾ, ਪਰ ਇਸ ਸਮੇਂ ਹੋਰ ਉਪਯੋਗਤਾਵਾਂ 'ਤੇ ਵੀ ਸਮੱਗਰੀ ਹੈ - ਇਹ ਲੜੀ ਦੇ ਅਗਲੇ ਹਿੱਸਿਆਂ ਵਿਚ ਹੋਵੇਗੀ.

ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਇਹ ਪਤਾ ਲਗਾਉਣ ਦੀ ਲੋੜ ਹੈ ਕਿ ਟੇਲਨੈੱਟ ਕੀ ਹੈ, ਇਸਦੀ ਕੀ ਲੋੜ ਹੈ, ਅਤੇ ਇਸਦੀ ਵਰਤੋਂ ਕਿਸ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਮੈਂ ਸਰੋਤਾਂ ਦਾ ਹਵਾਲਾ ਨਹੀਂ ਦੇਵਾਂਗਾ (ਜੇਕਰ ਜ਼ਰੂਰੀ ਹੈ, ਤਾਂ ਮੈਂ ਲੇਖ ਦੇ ਅੰਤ ਵਿੱਚ ਵਿਸ਼ੇ 'ਤੇ ਸਮੱਗਰੀ ਦਾ ਲਿੰਕ ਜੋੜਾਂਗਾ), ਮੈਂ ਸਿਰਫ ਇਹ ਕਹਾਂਗਾ ਕਿ ਟੇਲਨੈੱਟ ਡਿਵਾਈਸ ਦੀ ਕਮਾਂਡ ਲਾਈਨ ਤੱਕ ਰਿਮੋਟ ਪਹੁੰਚ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ. ਵੱਡੇ ਪੱਧਰ 'ਤੇ, ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਇਸਦੀ ਕਾਰਜਸ਼ੀਲਤਾ ਖਤਮ ਹੁੰਦੀ ਹੈ (ਮੈਂ ਜਾਣਬੁੱਝ ਕੇ ਸਰਵਰ ਪੋਰਟ ਨੂੰ ਐਕਸੈਸ ਕਰਨ ਬਾਰੇ ਚੁੱਪ ਰਿਹਾ; ਇਸ ਬਾਰੇ ਹੋਰ ਬਾਅਦ ਵਿੱਚ). ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਸਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਕਲਾਇੰਟ 'ਤੇ ਇੱਕ ਲਾਈਨ ਸਵੀਕਾਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਇਸਨੂੰ ਸਰਵਰ ਨੂੰ ਪਾਸ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਇਸਨੂੰ ਕਮਾਂਡ ਲਾਈਨ ਵਿੱਚ ਪਾਸ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ, ਕਮਾਂਡ ਲਾਈਨ ਜਵਾਬ ਨੂੰ ਪੜ੍ਹੋ, ਜੇਕਰ ਕੋਈ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਕਲਾਇੰਟ ਨੂੰ ਵਾਪਸ ਭੇਜੋ ਅਤੇ ਇਸਨੂੰ ਸਕ੍ਰੀਨ 'ਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੋ, ਜਾਂ, ਜੇਕਰ ਗਲਤੀਆਂ ਹਨ, ਤਾਂ ਉਪਭੋਗਤਾ ਨੂੰ ਦੱਸੋ ਕਿ ਕੁਝ ਗਲਤ ਹੈ।

ਉਪਰੋਕਤ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ, ਇਸ ਅਨੁਸਾਰ, ਸਾਨੂੰ 2 ਵਰਕਿੰਗ ਕਲਾਸਾਂ ਅਤੇ ਕੁਝ ਟੈਸਟ ਕਲਾਸਾਂ ਦੀ ਲੋੜ ਹੈ ਜਿੱਥੋਂ ਅਸੀਂ ਸਰਵਰ ਲਾਂਚ ਕਰਾਂਗੇ ਅਤੇ ਜਿਸ ਰਾਹੀਂ ਕਲਾਇੰਟ ਕੰਮ ਕਰੇਗਾ।
ਇਸ ਅਨੁਸਾਰ, ਇਸ ਸਮੇਂ ਐਪਲੀਕੇਸ਼ਨ ਢਾਂਚੇ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:

• ਟੇਲਨੈੱਟ ਕਲਾਇੰਟ
• ਟੇਲਨੈੱਟ ਕਲਾਇੰਟ ਟੈਸਟਰ
• ਟੇਲਨੈੱਟ ਸਰਵਰ
• ਟੈਲਨੈੱਟ ਸਰਵਰ ਟੈਸਟਰ

ਆਉ ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਵਿੱਚੋਂ ਲੰਘੀਏ:

ਟੇਲਨੈੱਟ ਕਲਾਇੰਟ

ਇਹ ਸਭ ਕਲਾਸ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਪ੍ਰਾਪਤ ਕੀਤੀਆਂ ਕਮਾਂਡਾਂ ਭੇਜਣਾ ਅਤੇ ਪ੍ਰਾਪਤ ਜਵਾਬਾਂ ਨੂੰ ਦਿਖਾਉਣਾ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਤੁਹਾਨੂੰ ਕਿਸੇ ਰਿਮੋਟ ਡਿਵਾਈਸ ਦੇ ਆਰਬਿਟਰੇਰੀ (ਜਿਵੇਂ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ) ਪੋਰਟ ਨਾਲ ਜੁੜਨ ਅਤੇ ਇਸ ਤੋਂ ਡਿਸਕਨੈਕਟ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣ ਦੀ ਲੋੜ ਹੈ।

ਇਸ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਹੇਠ ਦਿੱਤੇ ਫੰਕਸ਼ਨ ਲਾਗੂ ਕੀਤੇ ਗਏ ਸਨ:

ਇੱਕ ਫੰਕਸ਼ਨ ਜੋ ਇੱਕ ਸਾਕਟ ਐਡਰੈੱਸ ਨੂੰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਲੈਂਦਾ ਹੈ, ਇੱਕ ਕਨੈਕਸ਼ਨ ਖੋਲ੍ਹਦਾ ਹੈ ਅਤੇ ਇਨਪੁਟ ਅਤੇ ਆਉਟਪੁੱਟ ਸਟ੍ਰੀਮ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ (ਸਟ੍ਰੀਮ ਵੇਰੀਏਬਲ ਉੱਪਰ ਘੋਸ਼ਿਤ ਕੀਤੇ ਗਏ ਹਨ, ਪੂਰੇ ਸਰੋਤ ਲੇਖ ਦੇ ਅੰਤ ਵਿੱਚ ਹਨ)।

 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());
        }
    }

ਉਸੇ ਫੰਕਸ਼ਨ ਨੂੰ ਓਵਰਲੋਡ ਕਰਨਾ, ਡਿਫੌਲਟ ਪੋਰਟ ਨਾਲ ਜੁੜਨਾ - ਟੈਲਨੈੱਟ ਲਈ ਇਹ 23 ਹੈ

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

ਫੰਕਸ਼ਨ ਕੀਬੋਰਡ ਤੋਂ ਅੱਖਰਾਂ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਆਉਟਪੁੱਟ ਸਾਕਟ ਵਿੱਚ ਭੇਜਦਾ ਹੈ - ਜੋ ਕਿ ਆਮ ਹੈ, ਲਾਈਨ ਮੋਡ ਵਿੱਚ, ਅੱਖਰ ਮੋਡ ਵਿੱਚ ਨਹੀਂ:

    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());
        }
    }

ਫੰਕਸ਼ਨ ਸਾਕਟ ਤੋਂ ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਸਕ੍ਰੀਨ 'ਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ

    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());
        }
    }

ਫੰਕਸ਼ਨ ਡਾਟਾ ਰਿਸੈਪਸ਼ਨ ਅਤੇ ਪ੍ਰਸਾਰਣ ਨੂੰ ਰੋਕਦਾ ਹੈ

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

ਟੇਲਨੈੱਟ ਸਰਵਰ

ਇਸ ਕਲਾਸ ਵਿੱਚ ਸਾਕਟ ਤੋਂ ਕਮਾਂਡ ਪ੍ਰਾਪਤ ਕਰਨ, ਇਸਨੂੰ ਚਲਾਉਣ ਲਈ ਭੇਜਣ, ਅਤੇ ਕਮਾਂਡ ਤੋਂ ਜਵਾਬ ਨੂੰ ਸਾਕਟ ਵਿੱਚ ਵਾਪਸ ਭੇਜਣ ਦੀ ਕਾਰਜਸ਼ੀਲਤਾ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਜਾਣਬੁੱਝ ਕੇ ਇੰਪੁੱਟ ਡੇਟਾ ਦੀ ਜਾਂਚ ਨਹੀਂ ਕਰਦਾ, ਕਿਉਂਕਿ ਪਹਿਲਾਂ, "ਬਾਕਸਡ ਟੇਲਨੈੱਟ" ਵਿੱਚ ਵੀ ਸਰਵਰ ਡਿਸਕ ਨੂੰ ਫਾਰਮੈਟ ਕਰਨਾ ਸੰਭਵ ਹੈ, ਅਤੇ ਦੂਜਾ, ਇਸ ਲੇਖ ਵਿੱਚ ਸੁਰੱਖਿਆ ਦੇ ਮੁੱਦੇ ਨੂੰ ਸਿਧਾਂਤ ਵਿੱਚ ਛੱਡ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਇਸ ਲਈ ਇੱਥੇ ਨਹੀਂ ਹੈ. ਏਨਕ੍ਰਿਪਸ਼ਨ ਜਾਂ SSL ਬਾਰੇ ਇੱਕ ਸ਼ਬਦ।

ਇੱਥੇ ਸਿਰਫ 2 ਫੰਕਸ਼ਨ ਹਨ (ਉਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਓਵਰਲੋਡ ਹੈ), ਅਤੇ ਆਮ ਤੌਰ 'ਤੇ ਇਹ ਇੱਕ ਬਹੁਤ ਵਧੀਆ ਅਭਿਆਸ ਨਹੀਂ ਹੈ, ਪਰ ਇਸ ਕਾਰਜ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ, ਇਹ ਮੇਰੇ ਲਈ ਉਚਿਤ ਜਾਪਦਾ ਹੈ ਕਿ ਹਰ ਚੀਜ਼ ਨੂੰ ਜਿਵੇਂ ਕਿ ਇਹ ਹੈ ਛੱਡ ਦੇਣਾ.

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

        (new Thread(()->{ try {
            ServerSocket ss = new ServerSocket(port); // создаем сокет сервера и привязываем его к вышеуказанному порту
            System.out.println("Port "+port+" is waiting for connections");

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

            // Берем входной и выходной потоки сокета, теперь можем получать и отсылать данные клиенту.
            InputStream sin = socket.getInputStream();
            OutputStream sout = socket.getOutputStream();

            Map<String, String> env = System.getenv();
            String wayToTemp = env.get("TEMP") + "tmp.txt";
            for (int i :("Connectednnr".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 = "Something gets wrong... Err code: "+ 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("Error: " + e.getMessage());
                    }
                }).start();
                System.out.println(buffer);
                buffer = "";

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

    }

ਪ੍ਰੋਗਰਾਮ ਸਰਵਰ ਪੋਰਟ ਨੂੰ ਖੋਲ੍ਹਦਾ ਹੈ, ਇਸ ਤੋਂ ਡੇਟਾ ਪੜ੍ਹਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇਹ ਕਮਾਂਡ ਅੰਤਮ ਅੱਖਰ ਦਾ ਸਾਹਮਣਾ ਨਹੀਂ ਕਰਦਾ, ਕਮਾਂਡ ਨੂੰ ਇੱਕ ਨਵੀਂ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਪਾਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਆਉਟਪੁੱਟ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਤੋਂ ਸਾਕਟ ਵਿੱਚ ਰੀਡਾਇਰੈਕਟ ਕਰਦਾ ਹੈ। ਹਰ ਚੀਜ਼ ਕਲਾਸ਼ਨੀਕੋਵ ਅਸਾਲਟ ਰਾਈਫਲ ਵਾਂਗ ਸਧਾਰਨ ਹੈ।

ਇਸ ਅਨੁਸਾਰ, ਇੱਕ ਡਿਫੌਲਟ ਪੋਰਟ ਦੇ ਨਾਲ ਇਸ ਫੰਕਸ਼ਨ ਲਈ ਇੱਕ ਓਵਰਲੋਡ ਹੈ:

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

ਠੀਕ ਹੈ, ਇਸਦੇ ਅਨੁਸਾਰ, ਸਰਵਰ ਨੂੰ ਰੋਕਣ ਵਾਲਾ ਫੰਕਸ਼ਨ ਵੀ ਮਾਮੂਲੀ ਹੈ, ਇਹ ਸਦੀਵੀ ਲੂਪ ਨੂੰ ਰੋਕਦਾ ਹੈ, ਇਸਦੀ ਸਥਿਤੀ ਦੀ ਉਲੰਘਣਾ ਕਰਦਾ ਹੈ.

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

ਮੈਂ ਇੱਥੇ ਟੈਸਟ ਕਲਾਸਾਂ ਨਹੀਂ ਦੇਵਾਂਗਾ, ਉਹ ਹੇਠਾਂ ਹਨ - ਉਹ ਸਿਰਫ ਜਨਤਕ ਤਰੀਕਿਆਂ ਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਨ। ਸਭ ਕੁਝ ਗਿੱਟ 'ਤੇ ਹੈ.

ਸੰਖੇਪ ਵਿੱਚ, ਕੁਝ ਸ਼ਾਮਾਂ ਵਿੱਚ ਤੁਸੀਂ ਮੁੱਖ ਕੰਸੋਲ ਉਪਯੋਗਤਾਵਾਂ ਦੇ ਸੰਚਾਲਨ ਦੇ ਸਿਧਾਂਤਾਂ ਨੂੰ ਸਮਝ ਸਕਦੇ ਹੋ. ਹੁਣ, ਜਦੋਂ ਅਸੀਂ ਇੱਕ ਰਿਮੋਟ ਕੰਪਿਊਟਰ ਤੇ ਟੈਲੀਨੈੱਟ ਕਰਦੇ ਹਾਂ, ਅਸੀਂ ਸਮਝਦੇ ਹਾਂ ਕਿ ਕੀ ਹੋ ਰਿਹਾ ਹੈ - ਜਾਦੂ ਅਲੋਪ ਹੋ ਗਿਆ ਹੈ)

ਇਸ ਲਈ, ਲਿੰਕ:
ਸਾਰੇ ਸਰੋਤ ਇੱਥੇ ਸਨ, ਹਨ ਅਤੇ ਹੋਣਗੇ
ਟੇਲਨੈੱਟ ਬਾਰੇ
ਟੇਲਨੈੱਟ ਬਾਰੇ ਹੋਰ

ਸਰੋਤ: www.habr.com