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

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

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

אני לא אעתיק-הדבק מידע הפניות, שבאופן מסורתי ניתן למצוא קישורים אליו בסוף המאמר, אני רק אגיד שבבסיסו, TFTP הוא גרסה פשוטה של ​​פרוטוקול ה-FTP, שבו הגדרת בקרת הגישה כוללת הוסרו, ולמעשה אין כאן שום דבר מלבד פקודות לקבלה והעברה של קובץ. עם זאת, על מנת להפוך את היישום שלנו לקצת יותר אלגנטי ומותאם לעקרונות העכשוויים של כתיבת קוד, התחביר שונה מעט - זה לא משנה את עקרונות הפעולה, אבל הממשק, IMHO, הופך להיות קצת יותר הגיוני ו. משלב את ההיבטים החיוביים של FTP ו-TFTP.

בפרט, בעת ההשקה, הלקוח מבקש את כתובת ה-IP של השרת ואת הפורט שבו פתוח TFTP מותאם אישית (בשל חוסר התאמה לפרוטוקול הסטנדרטי, ראיתי לנכון להשאיר למשתמש את האפשרות לבחור פורט), ולאחר מכן נוצר חיבור, וכתוצאה מכך הלקוח יכול לשלוח את אחת הפקודות - get או put, כדי לקבל או לשלוח קובץ לשרת. כל הקבצים נשלחים במצב בינארי כדי לפשט את ההיגיון.

כדי ליישם את הפרוטוקול, השתמשתי באופן מסורתי ב-4 מחלקות:

• TFTPClient
• שרת TFTPS
• TFTPClientTester
• TFTPServerTester

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

TFTPClient

המשימה של מחלקה זו היא להתחבר לשרת מרוחק לפי מספר ה-IP ומספר היציאה שלו, לקרוא פקודה מזרם הקלט (במקרה זה, המקלדת), לנתח אותה, להעביר אותה לשרת, ובהתאם אם אתה צריך לשלוח או לקבל קובץ, להעביר אותו או לקבל.

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

 public void run(String ip, int port)
    {
        this.ip = ip;
        this.port = port;
        try {
            inicialization();
            Scanner keyboard = new Scanner(System.in);
            while (isRunning) {
                getAndParseInput(keyboard);
                sendCommand();
                selector();
                }
            }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

בואו נעבור על השיטות הנקראות בגוש הקוד הזה:

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

private  void put(String sourcePath, String destPath)
    {

        File src = new File(sourcePath);
        try {

            InputStream scanner = new FileInputStream(src);
            byte[] bytes = scanner.readAllBytes();
            for (byte b : bytes)
                sout.write(b);
            sout.close();
            inicialization();
            System.out.println("nDonen");
            }

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

קטע קוד זה מתאר אחזור נתונים מהשרת. הכל שוב טריוויאלי, רק גוש הקוד הראשון מעניין. כדי להבין בדיוק כמה בתים צריך לקרוא מהשקע, צריך לדעת כמה שוקל הקובץ המועבר. גודל הקובץ בשרת מיוצג כמספר שלם ארוך, כך שמתקבלים כאן 4 בתים, המומרים לאחר מכן למספר אחד. זו לא גישת Java מאוד, היא די דומה עבור SI, אבל היא פותרת את הבעיה שלה.

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

   private void get(String sourcePath, String destPath){
        long sizeOfFile = 0;
        try {


            byte[] sizeBytes = new byte[Long.SIZE];
           for (int i =0; i< Long.SIZE/Byte.SIZE; i++)
           {
               sizeBytes[i] = (byte)sin.read();
               sizeOfFile*=256;
               sizeOfFile+=sizeBytes[i];
           }

           FileOutputStream writer = new FileOutputStream(new File(destPath));
           for (int i =0; i < sizeOfFile; i++)
           {
               writer.write(sin.read());
           }
           writer.close();
           System.out.println("nDONEn");
       }
       catch (Exception e){
            System.out.println(e.getMessage());
       }
    }

אם הוזנה פקודה שאינה get או put בחלון הלקוח, הפונקציה showErrorMessage תיקרא, מה שמציין שהקלט היה שגוי. בגלל טריוויאליות, אני לא אצטט את זה. קצת יותר מעניינת היא הפונקציה של קבלה ופיצול מחרוזת הקלט. אנו מעבירים לתוכו את הסורק, ממנו אנו מצפים לקבל שורה המופרדת בשני רווחים ומכילה את הפקודה, כתובת המקור וכתובת היעד.

    private void getAndParseInput(Scanner scanner)
    {
        try {

            input = scanner.nextLine().split(" ");
            typeOfCommand = input[0];
            sourcePath = input[1];
            destPath = input[2];
        }
        catch (Exception e) {
            System.out.println("Bad input");
        }
    }

שליחת פקודה - מעבירה את הפקודה שהוכנסה מהסורק לשקע ומאלצת אותה להישלח

    private void sendCommand()
    {
        try {

            for (String str : input) {
                for (char ch : str.toCharArray()) {
                    sout.write(ch);
                }
                sout.write(' ');
            }
            sout.write('n');
        }
        catch (Exception e) {
            System.out.print(e.getMessage());
        }
    }

בורר הוא פונקציה הקובעת את פעולות התוכנית בהתאם למחרוזת שהוזנה. הכל כאן לא מאוד יפה והטריק שבו משתמשים הוא לא הטוב ביותר עם יציאה מאולצת מחוץ לבלוק הקוד, אבל הסיבה העיקרית לכך היא היעדר בג'אווה של דברים מסוימים, כמו נציגים ב-C#, מצביעי פונקציות מ-C++ או ב- לפחות הגטו הנורא והנורא, שמאפשרים לך ליישם את זה בצורה יפה. אם אתה יודע איך להפוך את הקוד לקצת יותר אלגנטי, אשמח לביקורת בתגובות. נראה לי שצריך כאן מילון מחרוזת, אבל אין נציג...

    private void selector()
    {
        do{
            if (typeOfCommand.equals("get")){
                get(sourcePath, destPath);
                break;
            }
            if (typeOfCommand.equals("put")){
                put(sourcePath, destPath);
                break;
            }
            showErrorMessage();
        }
        while (false);
    }
}

שרת TFTPS

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

כדי להתחיל, נעשה שימוש בשיטת הריצה, שמקבלת יציאה כקלט ומעבדת את נתוני הקלט מהשקע בלולאה נצחית.

    public void run(int port) {
            this.port = port;
            incialization();
            while (true) {
                getAndParseInput();
                selector();
            }
    }

שיטת put, העוטפת את שיטת writeToFileFromSocket שפותחת זרם כתיבה לקובץ וכותבת את כל בייטי הקלט מהשקע, מציגה הודעה המציינת את סיום ההעברה בהצלחה עם השלמת הכתיבה.

    private  void put(String source, String dest){
            writeToFileFromSocket();
            System.out.print("nDonen");
    };
    private void writeToFileFromSocket()
    {
        try {
            FileOutputStream writer = new FileOutputStream(new File(destPath));
            byte[] bytes = sin.readAllBytes();
            for (byte b : bytes) {
                writer.write(b);
            }
            writer.close();
        }
        catch (Exception e){
            System.out.println(e.getMessage());
        }
    }

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

 private  void get(String source, String dest){
        File sending = new File(source);
        try {
            FileInputStream readFromFile = new FileInputStream(sending);
            byte[] arr = readFromFile.readAllBytes();
            byte[] bytes = ByteBuffer.allocate(Long.SIZE / Byte.SIZE).putLong(sending.length()).array();
            for (int i = 0; i<Long.SIZE / Byte.SIZE; i++)
                sout.write(bytes[i]);
            sout.flush();
            for (byte b : arr)
                sout.write(b);
        }
        catch (Exception e){
            System.out.println(e.getMessage());
        }
    };

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

    private void  incialization()
    {
        try {
            serverSocket = new ServerSocket(port);
            socket = serverSocket.accept();
            sin = socket.getInputStream();
            sout = socket.getOutputStream();
        }
        catch (Exception e) {
            System.out.print(e.getMessage());
        }
    }

לסכם:

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

קישורים:

מאגר קוד מקור
בקצרה על TFTP
אותו דבר, אבל ברוסית

מקור: www.habr.com