क्लाइंट-सर्वर उपयोगिताओं की कार्यक्षमता के साथ सॉफ्टवेयर लिखना विंडोज, भाग 02

विंडोज में कंसोल उपयोगिताओं के कस्टम कार्यान्वयन पर लेखों की श्रृंखला जारी रखना, TFTP (ट्राइबियल फाइल ट्रांसफर प्रोटोकॉल) एक सरल फाइल ट्रांसफर प्रोटोकॉल है।

पिछली बार की तरह, हम संक्षेप में सिद्धांत पर चलते हैं, एक कोड देखते हैं जो आवश्यक के समान कार्यात्मक लागू करता है, और इसका विश्लेषण करता है। और पढ़ें - कट के नीचे

मैंने संदर्भ जानकारी को कॉपी-पेस्ट नहीं किया है, जिनके लिंक पारंपरिक रूप से लेख के अंत में पाए जा सकते हैं, मैं सिर्फ इतना कहूंगा कि संक्षेप में TFTP एफ़टीपी प्रोटोकॉल का एक सरलीकृत रूपांतर है जिसमें एक्सेस कंट्रोल सेटिंग हटा दी जाती है, और वास्तव में फ़ाइल प्राप्त करने और स्थानांतरित करने के लिए कमांड के अलावा यहां कुछ भी नहीं है। । हालांकि, हमारे कार्यान्वयन को थोड़ा और सुरुचिपूर्ण बनाने और कोड लिखने के वर्तमान सिद्धांतों के लिए अनुकूलित करने के लिए, वाक्यविन्यास को थोड़ा बदल दिया गया है - यह काम के सिद्धांतों को नहीं बदलता है, लेकिन इंटरफ़ेस, आईएमएचओ, थोड़ा अधिक तार्किक हो जाता है और एफ़टीपी और टीएफटीपी के सकारात्मक पहलुओं को जोड़ता है।

विशेष रूप से, जब शुरू होता है, क्लाइंट सर्वर के आईपी पते और उस पोर्ट के लिए पूछता है जिस पर कस्टम TFTP खुला है (मानक प्रोटोकॉल के साथ असंगति के कारण, मैंने उपयोगकर्ता को पोर्ट का चयन करने के लिए विकल्प को छोड़ना उचित समझा), जिसके बाद कनेक्शन होता है, जिसके परिणामस्वरूप क्लाइंट आदेशों में से एक भेज सकता है - सर्वर पर फ़ाइल प्राप्त करने या भेजने के लिए प्राप्त करें या डाल दें। तर्क को सरल बनाने के लिए सभी फाइलें बाइनरी मोड में भेजी जाती हैं।

प्रोटोकॉल के कार्यान्वयन के लिए, मैंने पारंपरिक रूप से 4 वर्गों का उपयोग किया है:

• TFTPClient
• TFTPServer
• TFTPClientTester
• TFTPServerTester

इस तथ्य के कारण कि परीक्षण कक्षाएं केवल मुख्य लोगों को डिबग करने के लिए मौजूद हैं, मैं उनका विश्लेषण नहीं करूंगा, लेकिन कोड रिपॉजिटरी में होगा, इसका एक लिंक लेख के अंत में पाया जा सकता है। और अब मैं मुख्य वर्गों को समझूंगा।

TFTPClient

इस वर्ग का कार्य अपने आईपी और पोर्ट नंबर द्वारा दूरस्थ सर्वर से कनेक्ट करना है, इनपुट स्ट्रीम (इस मामले में, कीबोर्ड) से एक कमांड पढ़ें, इसे पार्स करें, इसे सर्वर पर स्थानांतरित करें, और इस पर निर्भर करता है कि आप फ़ाइल को स्थानांतरित करना चाहते हैं या प्राप्त करना चाहते हैं, इस पर निर्भर करता है या इसे स्थानांतरित करें। प्राप्त करना।

क्लाइंट सर्वर से कनेक्ट करने के लिए कोड लॉन्च करता है और इनपुट स्ट्रीम से कमांड का इंतजार करता है। कार्यक्रम के पूर्ण पाठ में लेख के बाहर उपयोग किए जाने वाले कई वैश्विक चर लेख के बाहर वर्णित हैं। उनकी तुच्छता के कारण, मैं लेख को अधिभार न देने के लिए बोली नहीं देता।

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("\nDone\n"); } 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("\nDONE\n"); } catch (Exception e){ System.out.println(e.getMessage()); } } 

यदि क्लाइंट विंडो में गेट या पुट के अलावा कोई कमांड दर्ज की गई थी, तो इनपुट की गलतियाँ दिखाते हुए शो-मेयरमैसेज फ़ंक्शन को कॉल किया जाएगा। तुच्छता के कारण - मैं बोली नहीं। कुछ और दिलचस्प है इनपुट स्ट्रिंग को प्राप्त करने और विभाजित करने का कार्य। हम इसके लिए एक स्कैनर पास करते हैं, जिसमें से हम दो स्थानों से अलग एक लाइन प्राप्त करने और एक कमांड, स्रोत पते और गंतव्य पते को प्राप्त करने की अपेक्षा करते हैं।

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

एक चयनकर्ता एक फ़ंक्शन है जो इनपुट स्ट्रिंग के आधार पर एक कार्यक्रम की क्रियाओं को निर्धारित करता है। यहां सब कुछ बहुत सुंदर नहीं है और कोड ब्लॉक को मजबूर करने के साथ इतनी अच्छी-अच्छी चाल का उपयोग नहीं किया जाता है, लेकिन इसका मुख्य कारण कुछ चीजों के जावा में अनुपस्थिति है, जैसे सी # में प्रतिनिधियों, सी ++ से एक फ़ंक्शन को इंगित करता है, या कम से कम डरावना और भयानक गोटो, जो आप इसे खूबसूरती से महसूस करते हैं। यदि आप जानते हैं कि कोड को और अधिक सुरुचिपूर्ण कैसे बनाया जाए, तो मैं टिप्पणियों में आलोचना का इंतजार कर रहा हूं। यह मुझे लगता है कि एक स्ट्रिंग-प्रतिनिधि डिक्शनरी की आवश्यकता यहाँ है, लेकिन कोई प्रतिनिधि नहीं है ...

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

TFTPServer

सर्वर की कार्यक्षमता क्लाइंट की कार्यक्षमता से भिन्न होती है और केवल उसी में बड़ी होती है जो इसके लिए आदेश कीबोर्ड से नहीं, बल्कि सॉकेट से आती है। कुछ विधियाँ मेल खाती हैं, इसलिए मैंने उन्हें नहीं दिया; मैं केवल मतभेदों का उल्लेख करूँगा।

यहां शुरू करने के लिए, रन विधि का उपयोग किया जाता है, जो इनपुट के लिए एक पोर्ट प्राप्त करता है और एक अनन्त चक्र में सॉकेट से इनपुट डेटा को संसाधित करता है।

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

पुट विधि, जो राइटटॉयलेफ्रॉम सॉकेट विधि का एक आवरण है, जो एक फ़ाइल में लिखने की धारा को खोलता है और सॉकेट से सभी इनपुट बाइट्स लिखता है, रिकॉर्डिंग पूरी होने के बाद, हस्तांतरण के सफल समापन के बारे में एक संदेश प्रदर्शित करता है।

  private void put(String source, String dest){ writeToFileFromSocket(); System.out.print("\nDone\n"); }; 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()); } } 

संक्षेप में:

हमने सिर्फ एक साधारण डेटा ट्रांसफर प्रोटोकॉल पर अपनी भिन्नता लिखी है और यह पता लगाया है कि यह कैसे काम करना चाहिए। सिद्धांत रूप में, मैंने अमेरिका की खोज नहीं की थी और बहुत नया नहीं लिखा था, लेकिन - हेबे पर इस तरह के लेख नहीं थे, और सीएमडी उपयोगिताओं के बारे में लेखों की एक श्रृंखला लिखने के भाग के रूप में, उस पर स्पर्श करना असंभव नहीं था।

संदर्भ:

स्रोत कोड रिपोजिटरी
TFTP के बारे में संक्षेप में
एक ही बात है, लेकिन रूसी में