Windows client-server utilities အပိုင်း 02 ၏ လုပ်ဆောင်နိုင်စွမ်းဖြင့် ဆော့ဖ်ဝဲရေးခြင်း။

Windows console utilities များ၏ စိတ်ကြိုက်အကောင်အထည်ဖော်မှုများတွင် မြှုပ်နှံထားသည့် ဆောင်းပါးစီးရီးများကို ဆက်လက်လုပ်ဆောင်ခြင်းဖြင့် TFTP (Trivial File Transfer Protocol) - ရိုးရှင်းသောဖိုင်လွှဲပြောင်းမှုပရိုတိုကောကို ထိတွေ့ရန် ကျွန်ုပ်တို့ မကူညီနိုင်ပါ။

နောက်ဆုံးအကြိမ်အနေနဲ့၊ သီအိုရီကို အတိုချုံးကြည့်ရအောင်၊ လိုအပ်တဲ့လုပ်ဆောင်ချက်နဲ့ ဆင်တူတဲ့ လုပ်ဆောင်နိုင်စွမ်းကို အကောင်အထည်ဖော်တဲ့ ကုဒ်ကိုကြည့်ပြီး ခွဲခြမ်းစိတ်ဖြာကြည့်ရအောင်။ အသေးစိတ်အချက်များ - ဖြတ်တောက်မှုအောက်တွင်

အကိုးအကားအချက်အလက်ကို ကူးယူကူးထည့်မည်မဟုတ်ပါ၊ ဆောင်းပါး၏အဆုံးတွင် အစဉ်အလာအရတွေ့နိုင်သောလင့်ခ်များကို ၎င်း၏အဓိကတွင်၊ TFTP သည် ဝင်ရောက်ထိန်းချုပ်မှုဆက်တင်တွင် ပါရှိသည့် FTP ပရိုတိုကော၏ ရိုးရှင်းသောပြောင်းလဲမှုတစ်ခုဖြစ်သည်၊ ဖယ်ရှားလိုက်ပြီဖြစ်ပြီး အမှန်တကယ်တော့ ဖိုင်တစ်ခုလက်ခံခြင်းနှင့် လွှဲပြောင်းခြင်းအတွက် အမိန့်များမှလွဲ၍ ဤနေရာတွင် ဘာမှမရှိပါ။ သို့သော်၊ ကျွန်ုပ်တို့၏အကောင်အထည်ဖော်မှုကို အနည်းငယ်ပိုမိုပြေပြစ်စေရန်နှင့် လက်ရှိကုဒ်ရေးသားခြင်းဆိုင်ရာ အခြေခံမူများနှင့် လိုက်လျောညီထွေဖြစ်စေရန်အတွက် syntax သည် အနည်းငယ်ပြောင်းလဲသွားသည် - ၎င်းသည် လုပ်ဆောင်မှု၏အခြေခံမူများကို မပြောင်းလဲစေဘဲ၊ Interface သည် ဘာမှလည်း အနည်းငယ်ပိုယုတ္တိရှိလာပြီး၊ FTP နှင့် TFTP ၏ အပြုသဘောဆောင်သော ရှုထောင့်များကို ပေါင်းစပ်ထားသည်။

အထူးသဖြင့်၊ စတင်သောအခါတွင်၊ သုံးစွဲသူသည် ဆာဗာ၏ IP လိပ်စာနှင့် စိတ်ကြိုက် TFTP ကိုဖွင့်ထားသည့် port ကို တောင်းဆိုသည် (စံပရိုတိုကောနှင့် မကိုက်ညီသောကြောင့် အသုံးပြုသူအား ပို့တ်ရွေးချယ်နိုင်မှုကို ချန်ထားရန် သင့်လျော်သည်ဟု ကျွန်ုပ်ယူဆပါသည်) ထို့နောက်၊ client သည် command များထဲမှ တစ်ခုကို ပေးပို့နိုင်သည် - get သို့မဟုတ် put ၊ server သို့ ဖိုင်တစ်ခု လက်ခံရန် သို့မဟုတ် ပေးပို့ရန် ရလဒ်အဖြစ် ချိတ်ဆက်မှု ဖြစ်ပေါ်ပါသည်။ ယုတ္တိဗေဒကို ရိုးရှင်းစေရန် ဖိုင်အားလုံးကို ဒွိမုဒ်တွင် ပို့ထားသည်။

ပရိုတိုကောကို အကောင်အထည်ဖော်ရန်အတွက် ကျွန်ုပ်သည် ရှေးယခင်က အတန်း ၄ ခုကို အသုံးပြုခဲ့သည်-

• TTPClient
• TFTPSserver
• TTPClientTester
• TFTPServerTester

စမ်းသပ်ခြင်းအတန်းများသည် ပင်မအရာများကို အမှားရှာခြင်းအတွက်သာ တည်ရှိသောကြောင့်၊ ၎င်းတို့အား ငါခွဲခြမ်းစိတ်ဖြာမည်မဟုတ်သော်လည်း၊ ကုဒ်သည် သိုလှောင်ခန်းထဲတွင် ရှိနေလိမ့်မည်၊ ၎င်းနှင့်ပတ်သက်သည့် လင့်ခ်ကို ဆောင်းပါး၏အဆုံးတွင် တွေ့နိုင်ပါသည်။ အခု ကျွန်တော် အဓိက အတန်းတွေကို ကြည့်မယ်။

TTPClient

ဤအတန်း၏တာဝန်မှာ ၎င်း၏ ip နှင့် ပို့တ်နံပါတ်ဖြင့် အဝေးထိန်းဆာဗာသို့ ချိတ်ဆက်ရန်၊ အဝင်စီးကြောင်း (ဤကိစ္စတွင်၊ ကီးဘုတ်) မှ command တစ်ခုကို ဖတ်ရန်၊ ၎င်းကို ခွဲခြမ်းစိပ်ဖြာရန်၊ ၎င်းကို ဆာဗာသို့ လွှဲပြောင်းရန်နှင့် သင်ရှိမရှိအပေါ် မူတည်သည်။ ဖိုင်တစ်ခုပေးပို့ရန် သို့မဟုတ် လက်ခံရန်၊ ၎င်းကို လွှဲပြောင်းရန် သို့မဟုတ် ရယူရန် လိုအပ်သည်။

ဆာဗာသို့ချိတ်ဆက်ရန်နှင့် ထည့်သွင်းမှုစီးကြောင်းမှ ညွှန်ကြားချက်တစ်ခုကို စောင့်ရန် ကုဒ်သည် ဤကဲ့သို့ဖြစ်သည်။ ဤနေရာတွင် အသုံးပြုသည့် ကမ္ဘာလုံးဆိုင်ရာ ကိန်းရှင်များစွာကို ပရိုဂရမ်၏ စာသားအပြည့်အစုံတွင် ဆောင်းပါးအပြင်ဘက်တွင် ဖော်ပြထားပါသည်။ သူတို့ရဲ့အသေးအဖွဲလေးတွေကြောင့် ဆောင်းပါးကို လွန်လွန်ကဲကဲမဖြစ်မိစေဖို့ သူတို့ကို ကိုးကားပါတယ်။

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

ဤကုဒ်ဘလော့ခ်တွင် ခေါ်သည့် နည်းလမ်းများကို ကြည့်ကြပါစို့။

ဤနေရာတွင် ဖိုင်ကို ပို့လိုက်သည် - စကင်နာကို အသုံးပြု၍ ကျွန်ုပ်တို့သည် ဖိုင်၏ အကြောင်းအရာများကို ဘိုက်အခင်းတစ်ခုအဖြစ် တင်ပြကာ socket သို့ တစ်ခုပြီးတစ်ခု ရေးပေးကာ ၎င်းကိုပိတ်ပြီးနောက် ၎င်းကို ပြန်ဖွင့်ပါ (အထင်ရှားဆုံး ဖြေရှင်းချက်မဟုတ်သော်လည်း၊ ၎င်းသည် အရင်းအမြစ်များ ထုတ်ပေးခြင်းကို အာမခံသည်) ပြီးနောက် အောင်မြင်သော လွှဲပြောင်းခြင်းဆိုင်ရာ မက်ဆေ့ချ်ကို ကျွန်ုပ်တို့ ပြသသည်။

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

ဤကုဒ်အပိုင်းအစသည် ဆာဗာမှ ဒေတာများ ပြန်လည်ရယူခြင်းကို ဖော်ပြသည်။ အရာအားလုံးသည် အသေးအဖွဲဖြစ်နေပြန်သည်၊ ကုဒ်၏ပထမဘလောက်ကိုသာ စိတ်ဝင်စားသည်။ socket မှ ဘိုက်မည်မျှဖတ်ရန် လိုအပ်သည်ကို အတိအကျနားလည်ရန်၊ လွှဲပြောင်းထားသောဖိုင်သည် အလေးချိန်မည်မျှရှိသည်ကို သိရန် လိုအပ်သည်။ ဆာဗာရှိ ဖိုင်အရွယ်အစားကို ရှည်လျားသော ကိန်းပြည့်အဖြစ် ကိုယ်စားပြုသည်၊ ထို့ကြောင့် 4 bytes ကို ဤနေရာတွင် လက်ခံပြီး နောက်ပိုင်းတွင် နံပါတ်တစ်ခုအဖြစ်သို့ ပြောင်းလဲသွားပါသည်။ ၎င်းသည် အလွန် Java ချဉ်းကပ်မှု မဟုတ်ပါ၊ ၎င်းသည် SI အတွက် အတော်လေး ဆင်တူသည်၊ သို့သော် ၎င်းသည် ၎င်း၏ ပြဿနာကို ဖြေရှင်းပေးသည်။

ထို့နောက် အရာအားလုံးသည် အသေးအဖွဲဖြစ်သည် - ကျွန်ုပ်တို့သည် socket မှ သိထားသော bytes အရေအတွက်ကို လက်ခံရရှိပြီး အောင်မြင်မှုစာတိုကို ပြသပြီးနောက် ၎င်းတို့ကို ဖိုင်တစ်ခုသို့ ရေးချပါ။

   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 မှလွဲ၍ အခြား command တစ်ခုကို client window ထဲသို့ ထည့်သွင်းခဲ့ပါက၊ input မမှန်ကြောင်း ညွှန်ပြသော showErrorMessage လုပ်ဆောင်ချက်ကို ခေါ်ပါမည်။ အသေးအဖွဲကြောင့်၊ ငါအဲဒါကို မကိုးကားပါဘူး။ ပို၍စိတ်ဝင်စားစရာကောင်းသည်မှာ input string ကိုလက်ခံခြင်းနှင့်ခွဲခြမ်းခြင်း၏လုပ်ဆောင်ချက်ဖြစ်သည်။ ကျွန်ုပ်တို့သည် နေရာလွတ်နှစ်ခုဖြင့် ခြားထားသော မျဉ်းတစ်ကြောင်းကို လက်ခံရရှိရန်နှင့် အမိန့်ပေးမှု၊ ရင်းမြစ်လိပ်စာနှင့် ဦးတည်ရာလိပ်စာတို့ပါ၀င်သော စကင်နာကို ၎င်းထဲသို့ ကျွန်ုပ်တို့ ဖြတ်သန်းပါသည်။

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

ညွှန်ကြားချက်တစ်ခုပေးပို့ခြင်း- စကင်နာမှထည့်သွင်းထားသောအမိန့်ကို socket သို့ပို့ပြီး ပေးပို့ရန် တွန်းအားပေးသည်။

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

Selector သည် ထည့်သွင်းထားသော စာကြောင်းပေါ်မူတည်၍ ပရိုဂရမ်၏ လုပ်ဆောင်ချက်များကို ဆုံးဖြတ်ပေးသည့် လုပ်ဆောင်ချက်တစ်ခုဖြစ်သည်။ ဤနေရာရှိ အရာအားလုံးသည် အလွန်လှပခြင်းမရှိသည့်အပြင် အသုံးပြုထားသောလှည့်ကွက်သည် ကုဒ်ပိတ်ဆို့ခြင်းအပြင်ဘက်သို့ အတင်းအကျပ်ထွက်ရန် အကောင်းဆုံးမဟုတ်သော်လည်း၊ C# ရှိ ကိုယ်စားလှယ်များ၊ C++ မှ လုပ်ဆောင်ချက်ညွှန်ပြချက်များ သို့မဟုတ် အချို့အရာများ၏ အဓိကအကြောင်းရင်းမှာ Java တွင် မရှိခြင်းဖြစ်သောကြောင့်၊ ဤအရာကို လှလှပပ အကောင်အထည်ဖော်နိုင်စေမည့် ကြောက်မက်ဖွယ်ကောင်းသော ချောက်ချားစရာ goto အနည်းဆုံးဖြစ်သည်။ ကုဒ်ကို ပိုပြေပြစ်အောင် ဘယ်လိုလုပ်ရမလဲဆိုတာ သိရင် comment မှာ ဝေဖန်ပေးပါနော်။ ဒီနေရာမှာ String-delegate အဘိဓာန် လိုအပ်တယ်ထင်ရပေမယ့် ကိုယ်စားလှယ်မရှိဘူး...

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

TFTPSserver

ဆာဗာ၏လုပ်ဆောင်နိုင်စွမ်းသည် ဖောက်သည်၏လုပ်ဆောင်နိုင်စွမ်းနှင့် ကြီးမားသည်၊ ထိုအမိန့်တော်များတွင်သာ ကီးဘုတ်မှမဟုတ်ဘဲ ပေါက်ပေါက်မှလာပါသည်။ အချို့သောနည်းလမ်းများသည် ယေဘူယျအားဖြင့် တူညီကြသည်၊ ထို့ကြောင့် ၎င်းတို့ကို ကိုးကား၍ မပြောပါ၊ ကွဲပြားမှုများကိုသာ ရေးပါမည်။

စတင်ရန်အတွက်၊ အဝင်အထွက်အဖြစ် port တစ်ခုကို လက်ခံရရှိပြီး ထာဝရကွင်းဆက်တစ်ခုရှိ socket မှ input data များကို လုပ်ဆောင်ပေးသည့် run method ကိုအသုံးပြုသည်။

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

ဖိုင်တစ်ခုသို့ write stream တစ်ခုဖွင့်ပြီး socket မှ input bytes အားလုံးကိုရေးသည့် writeToFileFromSocket နည်းလမ်းကို ခြုံထားသည့် put method သည် ရေးပြီးသွားသောအခါ လွှဲပြောင်းမှုအောင်မြင်ကြောင်း ညွှန်ပြသည့် မက်ဆေ့ချ်ကို ပြသသည်။

    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 method သည် server ဖိုင်ကို ပြန်လည်ရယူသည်။ ပရိုဂရမ်၏ client ဘက်ခြမ်းရှိ ကဏ္ဍတွင် ဖော်ပြထားပြီးဖြစ်သည့်အတိုင်း၊ ဖိုင်တစ်ဖိုင်ကို အောင်မြင်စွာ လွှဲပြောင်းရန်၊ ရှည်လျားသော ကိန်းပြည့်ဖြင့် သိမ်းဆည်းထားသည့် ဖိုင်တစ်ဖိုင်ကို အောင်မြင်စွာ လွှဲပြောင်းရန် လိုအပ်သောကြောင့် ၎င်းကို 4 bytes ခင်းကျင်းခြင်းအဖြစ် ခွဲ၍ ၎င်းတို့ကို byte-by-byte လွှဲပြောင်းပါ။ socket သို့၊ ထို့နောက် ၎င်းတို့ကို client တွင် နံပါတ်တစ်ခုအဖြစ် လက်ခံ၍ စုစည်းပြီးနောက်၊ ကျွန်ုပ်သည် ဖိုင်ဖွဲ့စည်းသည့် bytes အားလုံးကို လွှဲပြောင်းပြီး ဖိုင်မှ input stream မှဖတ်သည်။

 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 method သည် client တွင်ကဲ့သို့ပင်ဖြစ်ပြီး၊ တစ်ခုတည်းသောကွာခြားချက်မှာ ကီးဘုတ်မှမဟုတ်ဘဲ socket မှဒေတာကိုဖတ်ခြင်းဖြစ်ပါသည်။ ကုဒ်သည် ရွေးချယ်သူကဲ့သို့ပင် သိုလှောင်မှုတွင် ရှိနေသည်။
ဤကိစ္စတွင်၊ အစပြုခြင်းအား သီးခြားကုဒ်တစ်ခုတွင် ထည့်သွင်းထားသောကြောင့် ဖြစ်သည်။ ဤအကောင်အထည်ဖော်မှုအတွင်း၊ လွှဲပြောင်းခြင်းပြီးမြောက်ပြီးနောက်၊ မှတ်ဉာဏ်ယိုစိမ့်မှုမှကာကွယ်မှုပေးရန်အတွက် အရင်းအမြစ်များကို ထုတ်လွှတ်ပေးပြီး တစ်ဖန်ပြန်လည်သိမ်းပိုက်ပါသည်။

    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 utilities များအကြောင်း ဆောင်းပါးများ ဆက်တိုက်ရေးခြင်း၏ တစ်စိတ်တစ်ပိုင်းအနေဖြင့် ၎င်းကို ထိတွေ့ရန် မဖြစ်နိုင်ပေ။

လင့်ခ်များ

အရင်းအမြစ်ကုဒ်သိုလှောင်မှု
TFTP အကြောင်း အတိုချုပ်
အတူတူပါပဲ၊ ဒါပေမယ့် ရုရှားဘာသာ

source: www.habr.com