વિન્ડોઝ ક્લાયંટ-સર્વર યુટિલિટીઝની કાર્યક્ષમતા સાથે સોફ્ટવેર લખવાનું, ભાગ 01

શુભેચ્છાઓ.

આજે હું ક્લાયંટ-સર્વર એપ્લીકેશન લખવાની પ્રક્રિયાને જોવા માંગુ છું જે પ્રમાણભૂત વિન્ડોઝ યુટિલિટીઝના કાર્યો કરે છે, જેમ કે ટેલનેટ, TFTP, વગેરે વગેરે, શુદ્ધ જાવામાં. તે સ્પષ્ટ છે કે હું કંઈપણ નવું લાવીશ નહીં - આ બધી ઉપયોગિતાઓ એક વર્ષથી વધુ સમયથી સફળતાપૂર્વક કામ કરી રહી છે, પરંતુ હું માનું છું કે હૂડ હેઠળ શું થઈ રહ્યું છે તે દરેકને ખબર નથી.

આ બરાબર છે જેની કટ હેઠળ ચર્ચા કરવામાં આવશે.

આ લેખમાં, તેને બહાર ન ખેંચવા માટે, સામાન્ય માહિતી ઉપરાંત, હું ફક્ત ટેલનેટ સર્વર વિશે જ લખીશ, પરંતુ આ ક્ષણે અન્ય ઉપયોગિતાઓ પર પણ સામગ્રી છે - તે શ્રેણીના આગળના ભાગોમાં હશે.

સૌ પ્રથમ, તમારે એ જાણવાની જરૂર છે કે ટેલનેટ શું છે, તેની શું જરૂર છે અને તેનો ઉપયોગ શેના માટે થાય છે. હું સ્રોતોને શબ્દશઃ ટાંકીશ નહીં (જો જરૂરી હોય તો, હું લેખના અંતે વિષય પરની સામગ્રીની લિંક જોડીશ), હું ફક્ત એટલું જ કહીશ કે ટેલનેટ ઉપકરણની કમાન્ડ લાઇનને દૂરસ્થ ઍક્સેસ પ્રદાન કરે છે. મોટાભાગે, આ તે છે જ્યાં તેની કાર્યક્ષમતા સમાપ્ત થાય છે (મેં જાણીજોઈને સર્વર પોર્ટને ઍક્સેસ કરવા વિશે મૌન રાખ્યું; તેના પર પછીથી વધુ). આનો અર્થ એ છે કે તેને અમલમાં મૂકવા માટે, અમારે ક્લાયંટ પર એક લાઇન સ્વીકારવાની જરૂર છે, તેને સર્વર પર પાસ કરવી પડશે, તેને કમાન્ડ લાઇન પર પાસ કરવાનો પ્રયાસ કરવો પડશે, કમાન્ડ લાઇન પ્રતિસાદ વાંચવો પડશે, જો ત્યાં છે, તો તેને ક્લાયંટને પાછું મોકલો અને તેને સ્ક્રીન પર પ્રદર્શિત કરો, અથવા, જો ભૂલો હોય, તો વપરાશકર્તાને જણાવો કે કંઈક ખોટું છે.

ઉપરોક્ત અમલીકરણ માટે, તે મુજબ, અમને 2 કાર્યકારી વર્ગો અને કેટલાક પરીક્ષણ વર્ગની જરૂર છે જેમાંથી અમે સર્વર શરૂ કરીશું અને જેના દ્વારા ક્લાયંટ કામ કરશે.
તદનુસાર, આ ક્ષણે એપ્લિકેશન માળખામાં શામેલ છે:

• ટેલનેટ ક્લાયન્ટ
• TelnetClientTester
• ટેલનેટ સર્વર
• TelnetServerTester

ચાલો તે દરેકમાંથી પસાર થઈએ:

ટેલનેટ ક્લાયન્ટ

આ તમામ વર્ગ પ્રાપ્ત આદેશો મોકલવા અને પ્રાપ્ત પ્રતિસાદો બતાવવા માટે સક્ષમ હોવા જોઈએ. આ ઉપરાંત, તમારે રિમોટ ડિવાઇસના મનસ્વી (ઉપર જણાવ્યા મુજબ) પોર્ટ સાથે કનેક્ટ થવા અને તેનાથી ડિસ્કનેક્ટ થવામાં સક્ષમ હોવું જરૂરી છે.

આ હાંસલ કરવા માટે, નીચેના કાર્યો અમલમાં મૂકવામાં આવ્યા હતા:

એક ફંક્શન કે જે સોકેટ એડ્રેસને દલીલ તરીકે લે છે, કનેક્શન ખોલે છે અને ઇનપુટ અને આઉટપુટ સ્ટ્રીમ્સ શરૂ કરે છે (સ્ટ્રીમ વેરીએબલ ઉપર જાહેર કરવામાં આવ્યા છે, સંપૂર્ણ સ્ત્રોતો લેખના અંતે છે).

 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