विंडोज क्लायंट-सर्व्हर युटिलिटीजच्या कार्यक्षमतेसह सॉफ्टवेअर लिहिणे, भाग 02

विंडोज कन्सोल युटिलिटीजच्या सानुकूल अंमलबजावणीसाठी समर्पित लेखांची चालू मालिका सुरू ठेवून, आम्ही TFTP (ट्रिव्हियल फाइल ट्रान्सफर प्रोटोकॉल) वर स्पर्श करू शकत नाही - एक साधा फाइल ट्रान्सफर प्रोटोकॉल.

मागच्या वेळेप्रमाणे, थ्योरीवर थोडक्‍यात जाऊ, आवश्यक प्रमाणेच कार्यक्षमता लागू करणारा कोड पाहू आणि त्याचे विश्लेषण करू. अधिक तपशील - कट अंतर्गत

मी संदर्भ माहिती कॉपी-पेस्ट करणार नाही, ज्याचे दुवे पारंपारिकपणे लेखाच्या शेवटी आढळू शकतात, मी फक्त एवढेच सांगेन की, TFTP हे FTP प्रोटोकॉलचे एक सरलीकृत रूपांतर आहे, ज्यामध्ये प्रवेश नियंत्रण सेटिंग काढून टाकले गेले आहे, आणि प्रत्यक्षात फाइल प्राप्त करण्यासाठी आणि हस्तांतरित करण्याच्या आदेशांशिवाय येथे काहीही नाही. तथापि, आमची अंमलबजावणी थोडी अधिक मोहक आणि लेखन कोडच्या वर्तमान तत्त्वांशी जुळवून घेण्यासाठी, वाक्यरचना किंचित बदलली गेली आहे - यामुळे ऑपरेशनची तत्त्वे बदलत नाहीत, परंतु इंटरफेस, IMHO, थोडा अधिक तार्किक बनतो आणि FTP आणि TFTP चे सकारात्मक पैलू एकत्र करते.

विशेषतः, लॉन्च केल्यावर, क्लायंट सर्व्हरच्या IP पत्त्याची आणि सानुकूल TFTP उघडलेल्या पोर्टची विनंती करतो (मानक प्रोटोकॉलशी विसंगततेमुळे, मी वापरकर्त्यास पोर्ट निवडण्याची क्षमता सोडणे योग्य मानले), त्यानंतर ए. कनेक्शन उद्भवते, परिणामी क्लायंट कमांडपैकी एक पाठवू शकतो - सर्व्हरवर फाइल प्राप्त करण्यासाठी किंवा पाठविण्यासाठी - मिळवा किंवा ठेवा. तर्क सोपे करण्यासाठी सर्व फाइल्स बायनरी मोडमध्ये पाठवल्या जातात.

प्रोटोकॉल लागू करण्यासाठी, मी पारंपारिकपणे 4 वर्ग वापरले:

• TFTPCक्लायंट
• TFTPS सर्व्हर
• TFTPClientTester
• TFTPSसर्व्हर टेस्टर

चाचणी वर्ग केवळ मुख्य डीबगिंगसाठी अस्तित्त्वात आहेत या वस्तुस्थितीमुळे, मी त्यांचे विश्लेषण करणार नाही, परंतु कोड रेपॉजिटरीमध्ये असेल; लेखाच्या शेवटी त्याची एक लिंक आढळू शकते. आता मी मुख्य वर्ग बघेन.

TFTPCक्लायंट

या वर्गाचे कार्य म्हणजे रिमोट सर्व्हरला त्याच्या आयपी आणि पोर्ट नंबरद्वारे कनेक्ट करणे, इनपुट प्रवाह (या प्रकरणात, कीबोर्ड) वरून कमांड वाचणे, त्याचे विश्लेषण करणे, ते सर्व्हरवर स्थानांतरित करणे आणि आपण की नाही यावर अवलंबून फाइल पाठवायची किंवा प्राप्त करायची, ती हस्तांतरित करायची किंवा मिळवायची.

सर्व्हरशी कनेक्ट होण्यासाठी क्लायंट लाँच करण्यासाठी आणि इनपुट प्रवाहातील आदेशाची प्रतीक्षा करण्याचा कोड यासारखा दिसतो. येथे वापरल्या जाणार्‍या अनेक जागतिक व्हेरिएबल्सचे वर्णन लेखाच्या बाहेर, प्रोग्रामच्या पूर्ण मजकुरात केले आहे. त्यांच्या क्षुल्लकपणामुळे, लेखावर जास्त भार पडू नये म्हणून मी त्यांचा उल्लेख करत नाही.

 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 बाइट्स स्वीकारले जातात, जे नंतर एका संख्येत रूपांतरित केले जातात. हा फारसा जावा दृष्टीकोन नाही, तो 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());
       }
    }

जर क्लायंट विंडोमध्ये गेट किंवा पुट व्यतिरिक्त इतर कमांड एंटर केली असेल, तर 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());
        }
    }

निवडकर्ता हे एक फंक्शन आहे जे प्रविष्ट केलेल्या स्ट्रिंगवर अवलंबून प्रोग्रामच्या क्रिया निर्धारित करते. येथे सर्व काही फार सुंदर नाही आणि कोड ब्लॉकच्या बाहेर सक्तीने बाहेर पडण्यासाठी वापरलेली युक्ती सर्वोत्तम नाही, परंतु याचे मुख्य कारण म्हणजे काही गोष्टींची Java मध्ये अनुपस्थिती आहे, जसे की 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();
            }
    }

पुट मेथड, जी 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());
        }
    }

गेट पद्धत सर्व्हर फाइल पुनर्प्राप्त करते. प्रोग्रामच्या क्लायंट बाजूच्या विभागात आधीच नमूद केल्याप्रमाणे, एखादी फाईल यशस्वीरित्या हस्तांतरित करण्यासाठी तुम्हाला तिचा आकार माहित असणे आवश्यक आहे, एक लांब पूर्णांक मध्ये संग्रहित आहे, म्हणून मी ते 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