વિન્ડોઝ ક્લાયંટ-સર્વર યુટિલિટીઝની કાર્યક્ષમતા સાથે સોફ્ટવેર લખવાનું, ભાગ 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());
       }
    }

જો ક્લાયન્ટ વિન્ડોમાં 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();
            }
    }

પુટ મેથડ, જે 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