വിൻഡോസ് ക്ലയന്റ്-സെർവർ യൂട്ടിലിറ്റികളുടെ പ്രവർത്തനക്ഷമതയുള്ള റൈറ്റിംഗ് സോഫ്‌റ്റ്‌വെയർ, ഭാഗം 02

വിൻഡോസ് കൺസോൾ യൂട്ടിലിറ്റികളുടെ ഇഷ്‌ടാനുസൃത നിർവ്വഹണങ്ങൾക്കായി നീക്കിവച്ചിരിക്കുന്ന ലേഖനങ്ങളുടെ തുടർച്ചയായി തുടരുന്നു, ഞങ്ങൾക്ക് TFTP (ട്രിവിയൽ ഫയൽ ട്രാൻസ്ഫർ പ്രോട്ടോക്കോൾ) - ഒരു ലളിതമായ ഫയൽ ട്രാൻസ്ഫർ പ്രോട്ടോക്കോൾ സ്പർശിക്കാതിരിക്കാനാവില്ല.

കഴിഞ്ഞ തവണത്തെപ്പോലെ, നമുക്ക് സിദ്ധാന്തത്തിലേക്ക് ചുരുക്കമായി പോകാം, ആവശ്യമുള്ളതിന് സമാനമായ പ്രവർത്തനക്ഷമത നടപ്പിലാക്കുന്ന കോഡ് കാണുക, അത് വിശകലനം ചെയ്യുക. കൂടുതൽ വിശദാംശങ്ങൾ - കട്ട് കീഴിൽ

ഞാൻ റഫറൻസ് വിവരങ്ങൾ പകർത്തി ഒട്ടിക്കില്ല, ലേഖനത്തിന്റെ അവസാനം പരമ്പരാഗതമായി കണ്ടെത്താനാകുന്ന ലിങ്കുകൾ, അതിന്റെ കാമ്പിൽ, TFTP എന്നത് ആക്സസ് കൺട്രോൾ ക്രമീകരണം ഉള്ള FTP പ്രോട്ടോക്കോളിന്റെ ലളിതമായ ഒരു വ്യതിയാനമാണെന്ന് മാത്രമേ ഞാൻ പറയൂ. നീക്കം ചെയ്തു, വാസ്തവത്തിൽ ഇവിടെ ഒരു ഫയൽ സ്വീകരിക്കുന്നതിനും കൈമാറുന്നതിനുമുള്ള കമാൻഡുകൾ ഒഴികെ മറ്റൊന്നുമില്ല. എന്നിരുന്നാലും, ഞങ്ങളുടെ നിർവ്വഹണം കുറച്ചുകൂടി ഗംഭീരമാക്കുന്നതിനും കോഡ് എഴുതുന്നതിനുള്ള നിലവിലെ തത്വങ്ങളുമായി പൊരുത്തപ്പെടുന്നതിനും, വാക്യഘടനയിൽ ചെറിയ മാറ്റം വരുത്തിയിട്ടുണ്ട് - ഇത് പ്രവർത്തന തത്വങ്ങളെ മാറ്റില്ല, പക്ഷേ ഇന്റർഫേസ്, IMHO, കുറച്ചുകൂടി യുക്തിസഹവും FTP, TFTP എന്നിവയുടെ നല്ല വശങ്ങൾ സംയോജിപ്പിക്കുന്നു.

പ്രത്യേകിച്ചും, ആരംഭിക്കുമ്പോൾ, ക്ലയന്റ് സെർവറിന്റെ IP വിലാസവും ഇഷ്‌ടാനുസൃത TFTP തുറന്നിരിക്കുന്ന പോർട്ടും അഭ്യർത്ഥിക്കുന്നു (സാധാരണ പ്രോട്ടോക്കോളുമായുള്ള പൊരുത്തക്കേട് കാരണം, ഒരു പോർട്ട് തിരഞ്ഞെടുക്കാനുള്ള കഴിവ് ഉപയോക്താവിന് വിട്ടുകൊടുക്കുന്നത് ഉചിതമാണെന്ന് ഞാൻ കരുതി), അതിനുശേഷം a കണക്ഷൻ സംഭവിക്കുന്നു, അതിന്റെ ഫലമായി ക്ലയന്റ് കമാൻഡുകളിലൊന്ന് അയയ്ക്കാൻ കഴിയും - നേടുക അല്ലെങ്കിൽ ഇടുക, സെർവറിലേക്ക് ഒരു ഫയൽ സ്വീകരിക്കുന്നതിനോ അയയ്ക്കുന്നതിനോ. ലോജിക് ലളിതമാക്കാൻ എല്ലാ ഫയലുകളും ബൈനറി മോഡിൽ അയയ്ക്കുന്നു.

പ്രോട്ടോക്കോൾ നടപ്പിലാക്കാൻ, ഞാൻ പരമ്പരാഗതമായി 4 ക്ലാസുകൾ ഉപയോഗിച്ചു:

• TFTP ക്ലയന്റ്
• TFTPSസെർവർ
• TFTPClientTester
• TFTPServerTester

പ്രധാനവ ഡീബഗ്ഗുചെയ്യുന്നതിന് മാത്രമേ ടെസ്റ്റിംഗ് ക്ലാസുകൾ ഉള്ളൂ എന്ന വസ്തുത കാരണം, ഞാൻ അവ വിശകലനം ചെയ്യില്ല, പക്ഷേ കോഡ് ശേഖരത്തിലായിരിക്കും; അതിലേക്കുള്ള ഒരു ലിങ്ക് ലേഖനത്തിന്റെ അവസാനം കണ്ടെത്താനാകും. ഇപ്പോൾ ഞാൻ പ്രധാന ക്ലാസുകൾ നോക്കും.

TFTP ക്ലയന്റ്

ഒരു വിദൂര സെർവറിലേക്ക് അതിന്റെ ഐപിയും പോർട്ട് നമ്പറും ഉപയോഗിച്ച് കണക്റ്റുചെയ്യുക, ഇൻപുട്ട് സ്ട്രീമിൽ നിന്ന് ഒരു കമാൻഡ് വായിക്കുക (ഈ സാഹചര്യത്തിൽ, കീബോർഡ്), അത് പാഴ്‌സ് ചെയ്യുക, സെർവറിലേക്ക് മാറ്റുക, കൂടാതെ നിങ്ങളാണോ എന്നതിനെ ആശ്രയിച്ച്, ഈ ക്ലാസിന്റെ ചുമതല ഒരു ഫയൽ അയയ്‌ക്കുകയോ സ്വീകരിക്കുകയോ ചെയ്യണം, അത് കൈമാറുകയോ നേടുകയോ ചെയ്യണം.

സെർവറിലേക്ക് കണക്റ്റുചെയ്യുന്നതിനും ഇൻപുട്ട് സ്ട്രീമിൽ നിന്നുള്ള ഒരു കമാൻഡിനായി കാത്തിരിക്കുന്നതിനും ക്ലയന്റ് സമാരംഭിക്കുന്നതിനുള്ള കോഡ് ഇതുപോലെ കാണപ്പെടുന്നു. ഇവിടെ ഉപയോഗിച്ചിരിക്കുന്ന നിരവധി ആഗോള വേരിയബിളുകൾ ലേഖനത്തിന് പുറത്ത്, പ്രോഗ്രാമിന്റെ പൂർണ്ണ വാചകത്തിൽ വിവരിച്ചിരിക്കുന്നു. അവരുടെ നിസ്സാരത കാരണം, ലേഖനം ഓവർലോഡ് ചെയ്യാതിരിക്കാൻ ഞാൻ അവ ഉദ്ധരിക്കുന്നില്ല.

 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 ബൈറ്റുകൾ ഇവിടെ സ്വീകരിക്കുന്നു, അവ പിന്നീട് ഒരു സംഖ്യയായി പരിവർത്തനം ചെയ്യപ്പെടുന്നു. ഇത് വളരെ ജാവ സമീപനമല്ല, എസ്‌ഐക്ക് ഇത് സമാനമാണ്, പക്ഷേ ഇത് അതിന്റെ പ്രശ്നം പരിഹരിക്കുന്നു.

അപ്പോൾ എല്ലാം നിസ്സാരമാണ് - സോക്കറ്റിൽ നിന്ന് ഞങ്ങൾക്ക് അറിയാവുന്ന ഒരു എണ്ണം ബൈറ്റുകൾ ലഭിക്കുകയും അവ ഒരു ഫയലിലേക്ക് എഴുതുകയും ചെയ്യുന്നു, അതിനുശേഷം ഞങ്ങൾ ഒരു വിജയ സന്ദേശം പ്രദർശിപ്പിക്കും.

   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++ ൽ നിന്നുള്ള ഫംഗ്‌ഷൻ പോയിന്ററുകൾ അല്ലെങ്കിൽ at ഏറ്റവും ഭയാനകവും ഭയങ്കരവുമായ ഗോട്ടോ, ഇത് മനോഹരമായി നടപ്പിലാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. കോഡ് എങ്ങനെ കുറച്ചുകൂടി മനോഹരമാക്കാമെന്ന് നിങ്ങൾക്കറിയാമെങ്കിൽ, അഭിപ്രായങ്ങളിലെ വിമർശനങ്ങളെ ഞാൻ സ്വാഗതം ചെയ്യുന്നു. ഇവിടെ ഒരു സ്ട്രിംഗ്-ഡെലിഗേറ്റ് നിഘണ്ടു ആവശ്യമാണെന്ന് എനിക്ക് തോന്നുന്നു, പക്ഷേ ഡെലിഗേറ്റ് ഇല്ല...

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

ചുരുക്കി പറഞ്ഞാൽ:

ഒരു ലളിതമായ ഡാറ്റാ ട്രാൻസ്ഫർ പ്രോട്ടോക്കോളിൽ ഞങ്ങൾ ഞങ്ങളുടെ സ്വന്തം വ്യതിയാനം എഴുതി, അത് എങ്ങനെ പ്രവർത്തിക്കണമെന്ന് കണ്ടുപിടിച്ചു. തത്വത്തിൽ, ഞാൻ ഇവിടെ അമേരിക്ക കണ്ടെത്തിയില്ല, കൂടുതൽ പുതിയ കാര്യങ്ങൾ എഴുതിയില്ല, പക്ഷേ ഹബ്രെയെക്കുറിച്ച് സമാനമായ ലേഖനങ്ങളൊന്നും ഉണ്ടായിരുന്നില്ല, കൂടാതെ cmd യൂട്ടിലിറ്റികളെക്കുറിച്ചുള്ള ലേഖനങ്ങളുടെ ഒരു പരമ്പര എഴുതുന്നതിന്റെ ഭാഗമായി അതിൽ സ്പർശിക്കാതിരിക്കാൻ കഴിയില്ല.

റെഫറൻസുകൾ:

സോഴ്സ് കോഡ് ശേഖരം
ടിഎഫ്ടിപിയെക്കുറിച്ച് ചുരുക്കത്തിൽ
അതേ കാര്യം, പക്ഷേ റഷ്യൻ ഭാഷയിൽ

അവലംബം: www.habr.com