כתיבת תוכנה עם הפונקציונליות של כלי עזר של Windows לקוח-שרת, חלק 01

Приветствую.

היום ברצוני להסתכל על תהליך כתיבת יישומי שרת-לקוח המבצעים את הפונקציות של כלי עזר סטנדרטיים של Windows, כגון Telnet, TFTP וכו' וכו' ב-Java טהור. ברור שלא אביא שום דבר חדש - כל השירותים האלה עובדים בהצלחה כבר יותר משנה, אבל אני מאמין שלא כולם יודעים מה קורה מתחת למכסה המנוע.

זה בדיוק מה שנדון תחת הקיצוץ.

במאמר זה, כדי לא לגרור את זה, בנוסף למידע כללי, אכתוב רק על שרת Telnet, אבל כרגע יש גם חומר על כלי עזר אחרים - זה יהיה בחלקים נוספים של הסדרה.

קודם כל, אתה צריך להבין מה זה Telnet, למה זה נחוץ ולמה הוא משמש. לא אצטט מקורות מילולית (במידת הצורך אצרף בסוף המאמר קישור לחומרים בנושא), רק אגיד שטלנט מספקת גישה מרחוק לשורת הפקודה של המכשיר. בגדול, כאן מסתיימת הפונקציונליות שלו (שתקתי בכוונה לגבי הגישה ליציאת השרת; על כך בהמשך). זה אומר שכדי ליישם את זה, אנחנו צריכים לקבל שורה בלקוח, להעביר אותה לשרת, לנסות להעביר אותה לשורת הפקודה, לקרוא את תגובת שורת הפקודה, אם יש כזו, להעביר אותה בחזרה ללקוח ו הצג אותו על המסך, או, אם יש שגיאות, יידע את המשתמש שמשהו לא בסדר.

כדי ליישם את האמור לעיל, בהתאם, אנו זקוקים ל-2 מחלקות עבודה ומחלקת בדיקה כלשהי שממנה נשיק את השרת ודרכה יעבוד הלקוח.
בהתאם, נכון לעכשיו מבנה הבקשה כולל:

• TelnetClient
• TelnetClientTester
• TelnetServer
• TelnetServerTester

בואו נעבור על כל אחד מהם:

TelnetClient

כל מה שהכיתה הזו אמורה להיות מסוגלת לעשות הוא לשלוח פקודות שהתקבלו ולהראות את התגובות שהתקבלו. בנוסף, אתה צריך להיות מסוגל להתחבר ליציאה שרירותית (כפי שהוזכר לעיל) של מכשיר מרוחק ולהתנתק ממנו.

כדי להשיג זאת, יושמו הפונקציות הבאות:

פונקציה שלוקחת כתובת socket כארגומנט, פותחת חיבור ומתחילה זרמי קלט ופלט (משתני זרם מוצהרים למעלה, מקורות מלאים נמצאים בסוף המאמר).

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

עומס יתר על אותה פונקציה, חיבור ליציאת ברירת המחדל - עבור telnet זה 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();
    }
}

TelnetServer

מחלקה זו חייבת להיות בעלת פונקציונליות של קבלת פקודה משקע, שליחתה לביצוע ושליחת תגובה מהפקודה חזרה אל השקע. התוכנית לא בודקת בכוונה את נתוני הקלט, כי ראשית, אפילו ב-"boxed telnet" ניתן לפרמט את דיסק השרת, ושנית, נושא האבטחה במאמר זה נשמט באופן עקרוני, וזו הסיבה שאין מילה על הצפנה או 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;
    }

אני לא אתן כאן שיעורי מבחן, הם למטה - כל מה שהם עושים זה לבדוק את הפונקציונליות של שיטות ציבוריות. הכל נמצא ב-Git.

לסיכום, בעוד כמה ערבים אתה יכול להבין את עקרונות הפעולה של כלי העזר העיקריים של הקונסולה. עכשיו, כשאנחנו טלנטים למחשב מרוחק, אנחנו מבינים מה קורה - הקסם נעלם)

אז הקישורים:
כל המקורות היו, נמצאים ויהיו כאן
לגבי Telnet
עוד על Telnet

מקור: www.habr.com