"Boost.Asio C ++ नेटवर्क प्रोग्रामिंग।" अध्याय 2: Boost.Asio की मूल बातें भाग 1

सभी को नमस्कार!
मैं जॉन टोरजो की पुस्तक Boost.Asio C ++ नेटवर्क प्रोग्रामिंग का अनुवाद करना जारी रखता हूं। दूसरा अध्याय बड़ा निकला, इसलिए मैं इसे दो भागों में तोड़ूंगा। इस भाग में, हम विशेष रूप से Boost.Asio की मूल बातों के बारे में बात करेंगे, और दूसरे भाग में हम एसिंक्रोनस प्रोग्रामिंग के बारे में बात करेंगे।

सामग्री:

• अध्याय 1: Boost.Asio के साथ शुरुआत करना
• अध्याय 2: बूस्ट.आसियो मूल बातें
  
  • भाग 1: Boost.Asio की मूल बातें
  • भाग 2: अतुल्यकालिक प्रोग्रामिंग
• अध्याय 3: इको सर्वर / क्लाइंट
• अध्याय 4: क्लाइंट और सर्वर
• अध्याय 5: सिंक्रोनस बनाम एसिंक्रोनस
• अध्याय 6: Boost.Asio - अन्य विशेषताएं
• अध्याय 7: Boost.Asio - अतिरिक्त विषय

इस अध्याय में, हम Boost.Asio का उपयोग करके आपको जो कुछ भी जानना आवश्यक है, उसे कवर करेंगे। हम अतुल्यकालिक प्रोग्रामिंग में तल्लीन करेंगे, जो सिंक्रोनस की तुलना में बहुत अधिक जटिल है और बहुत अधिक दिलचस्प है।

नेटवर्क एपीआई

यह अनुभाग दिखाता है कि Boost.Asio का उपयोग करके नेटवर्क एप्लिकेशन लिखने के लिए आपको क्या जानना चाहिए।

बूस्ट.असियो नेमस्पेस

Boost.Asio में सब कुछ बढ़ रहा है boost::asio नाम स्थान या उसके उप-स्थान, उन पर विचार करें:

• boost::asio : यह वह जगह है जहां सभी मुख्य कक्षाएं और फ़ंक्शन स्थित हैं। मुख्य वर्ग io_service और io_service हैं। यहाँ read, read_at, read_until , उनकी एसिंक्रोनस read, read_at, read_until फ़ंक्शंस और उनकी एसिंक्रोनस read, read_at, read_until जैसे फ़ंक्शंस हैं।
• boost::asio::ip : यह वह जगह है जहाँ पुस्तकालय का नेटवर्क भाग रहता है। मुख्य वर्ग address, endpoint, tcp, udp, icmp async_connect हैं, और मुख्य कार्य connect और async_connect । ध्यान दें कि socket को boost::asio::ip::tcp::socket केवल boost::asio::ip::tcp अंदर typedef गया है boost::asio::ip::tcp class।
• boost::asio::error : इस नाम स्थान में त्रुटि कोड हैं जो आपको I / O रूटीन को कॉल करते समय प्राप्त हो सकते हैं
• boost::asio::ssl : इस नाम स्थान में एसएसएल के साथ काम करने वाले वर्ग हैं।
• boost::asio::local : इस नाम स्थान में POSIX- विशिष्ट कक्षाएं हैं
• boost::asio::windows : इस नाम स्थान में Windows- विशिष्ट कक्षाएं हैं

आईपी ​​पते

आईपी ​​पते के साथ काम करने के लिए, Boost.Asio कक्षाओं को ip::address, ip::address_v4 और ip::address_v6 पता_v6 प्रदान करता है।
वे कई सुविधाएँ प्रदान करते हैं। यहाँ सबसे महत्वपूर्ण हैं:

• ip::address(v4_or_v6_address) : यह फ़ंक्शन v4 या v6 पते को ip::address पते में कनवर्ट करता है।
• ip::address:from_string(str) : यह फ़ंक्शन IPv4 एड्रेस (पीरियड्स से अलग) या IPv6 (हेक्साडेसिमल फॉर्मेट) से एक एड्रेस बनाता है।
• ip::address::to_string() : यह फ़ंक्शन अनुकूल स्ट्रिंग रूप में पता देता है
• ip::address_v4::broadcast([addr, mask]) : यह फ़ंक्शन एक broadcast पता बनाता है
• ip::address_v4::any() : यह फ़ंक्शन एक पता देता है जो किसी भी पते का प्रतिनिधित्व करता है
• ip::address_v4::loopback(), ip_address_v6::loopback() : यह फ़ंक्शन पतों का एक लूप लौटाता है (v4 / v6 प्रोटोकॉल से)
• ip::host_name() : यह फ़ंक्शन स्ट्रिंग के रूप में वर्तमान होस्ट का नाम देता है

सबसे अधिक संभावना है कि आप सबसे अधिक संभावना ip::address::from_string उपयोग करेंगे ip::address::from_string :

 ip::address addr = ip::address::from_string("127.0.0.1"); 

यदि आपको होस्ट नाम से कनेक्ट करने की आवश्यकता है, तो पढ़ें। निम्नलिखित कोड काम नहीं करेगा:

 // throws an exception ip::address addr = ip::address::from_string("www.yahoo.com"); 

अंतिम बिंदु (अंतिम बिंदु)

समापन बिंदु बंदरगाह के साथ कनेक्शन का पता है। प्रत्येक सॉकेट प्रकार का अपना समापन बिंदु वर्ग होता है, उदाहरण के लिए, ip::tcp::endpoint, ip::udp::endpoint , और ip::icmp::endpoint ।
यदि आप पोर्ट 80 पर localhost से कनेक्ट करना चाहते हैं, तो आपको निम्नलिखित लिखना होगा:

 ip::tcp::endpoint ep( ip::address::from_string("127.0.0.1"), 80); 

आप तीन तरीकों से एक समापन बिंदु बना सकते हैं:

• endpoint() : डिफ़ॉल्ट कंस्ट्रक्टर और कभी-कभी यूडीपी / आईसीएमपी सॉकेट के लिए इस्तेमाल किया जा सकता है
• endpoint(protocol, port) : आमतौर पर नए कनेक्शन स्वीकार करने के लिए सर्वर सॉकेट पर उपयोग किया जाता है
• endpoint(addr, port) : एड्रेस और पोर्ट द्वारा एक एंडपॉइंट बनाएं

यहाँ कुछ उदाहरण हैं:

 ip::tcp::endpoint ep1; ip::tcp::endpoint ep2(ip::tcp::v4(), 80); ip::tcp::endpoint ep3( ip::address::from_string("127.0.0.1), 80); 

यदि आप होस्ट (आईपी पते से नहीं) से जुड़ना चाहते हैं, तो आपको निम्नलिखित कार्य करने होंगे:

  // outputs "87.248.122.122" io_service service; ip::tcp::resolver resolver(service); ip::tcp::resolver::query query("www.yahoo.com", "80"); ip::tcp::resolver::iterator iter = resolver.resolve( query); ip::tcp::endpoint ep = *iter; std::cout << ep.address().to_string() << std::endl; 

आप tcp को अपनी जरूरत के प्रकार के सॉकेट से बदल सकते हैं। सबसे पहले, उस नाम के साथ एक क्वेरी बनाएं जिसे आप कनेक्ट करना चाहते हैं, इसे resolve() फ़ंक्शन का उपयोग करके लागू किया जा सकता है। सफल होने पर, कम से कम एक रिकॉर्ड वापस कर दिया जाएगा।
समापन बिंदु प्राप्त करने के बाद, आप इसका पता, पोर्ट और IP प्रोटोकॉल (v4 या v6) प्राप्त कर सकते हैं:

 std::cout << ep.address().to_string() << ":" << ep.port() << "/" << ep.protocol() << std::endl; 

सॉकेट

Boost.Asio में तीन प्रकार के सॉकेट वर्ग शामिल हैं: ip::tcp, ip::udp , और ip::icmp , और निश्चित रूप से इसका विस्तार होता है। आप अपना स्वयं का सॉकेट क्लास बना सकते हैं, हालाँकि यह जटिल है। यदि आप अभी भी ऐसा करने का निर्णय लेते हैं, तो boost/ asio/ip/tcp.hpp , boost/asio/ip/udp.hpp , और boost/asio/ip/icmp.hpp । उनमें से सभी आंतरिक typedef खोजशब्दों के बजाय छोटे वर्ग हैं।
आप प्लेसहोल्डर के रूप में ip::tcp, ip::udp, ip::icmp क्लासेस के बारे में सोच सकते हैं; वे अन्य वर्गों / कार्यों को प्राप्त करना आसान बनाते हैं, जिन्हें निम्नानुसार परिभाषित किया गया है:

• ip :: tcp :: सॉकेट, ip :: tcp :: स्वीकर्ता, ip :: tcp :: समापन बिंदु, ip :: tcp :: resolver, ip :: tcp :: iostream
• आईपी ​​:: udp :: सॉकेट, आईपी :: udp :: समापन बिंदु, आईपी :: udp :: रिज़ॉल्वर
• ip :: icmp :: सॉकेट, ip :: icmp :: समापन बिंदु, ip :: icmp :: resolver

socket क्लास संबंधित सॉकेट बनाता है। आप हमेशा io_service को io_service उदाहरण देते हैं:

 io_service service; ip::udp::socket sock(service) sock.set_option(ip::udp::socket::reuse_address(true)); 

प्रत्येक सॉकेट नाम में एक typedef :

• ip::tcp::socket= basic_stream_socket
ip::udp::socket= basic_datagram_socket<ud p>
  ip::icmp::socket= basic_raw_socket
  
  
  

  तुल्यकालिक फ़ंक्शन त्रुटि कोड

  
  सभी सिंक्रोनस फ़ंक्शंस में ओवरलोड हैं जो अपवादों को फेंकते हैं या एक त्रुटि कोड लौटाते हैं, जैसा कि नीचे दिखाया गया है:
  
  

   sync_func( arg1, arg2 ... argN); // throws boost::system::error_code ec; sync_func( arg1 arg2, ..., argN, ec); // returns error code 

  
  अध्याय के शेष भाग में, आप कई समकालिक कार्य देखेंगे। चीजों को सरल रखने के लिए, मैंने एक त्रुटि कोड लौटाने वाले ओवरलोड के प्रदर्शन को छोड़ दिया, लेकिन वे मौजूद हैं।
  
  

  सॉकेट कार्य

  
  सभी कार्यों को कई समूहों में विभाजित किया गया है। प्रत्येक प्रकार के सॉकेट के लिए सभी सुविधाएँ उपलब्ध नहीं हैं। इस अनुभाग के अंत में सूची आपको दिखाएगी कि कौन से कार्य सॉकेट्स के किस वर्ग के हैं।
  ध्यान दें कि सभी अतुल्यकालिक कार्य तुरंत प्रतिक्रिया देते हैं, जबकि उनके सिंक्रोनस समकक्ष ऑपरेशन पूरा होने के बाद ही प्रतिक्रिया देते हैं।
  
  

  संयोजी बंधन कार्य

  
  ये वे कार्य हैं जो सॉकेट से कनेक्ट या कनेक्ट होते हैं, इसे डिस्कनेक्ट करें और कनेक्शन अनुरोध करें, चाहे वह सक्रिय हो या न हो:
  
  • assign(protocol,socket) : यह फ़ंक्शन सॉकेट उदाहरण के लिए एक कच्चा (प्राकृतिक) सॉकेट प्रदान करता है। विरासत कोड के साथ काम करते समय इसका उपयोग करें (अर्थात, जब कच्चे सॉकेट पहले से ही बनाए गए हों)।
  • open(protocol) : यह फ़ंक्शन निर्दिष्ट आईपी प्रोटोकॉल (v4 या v6) के साथ एक सॉकेट खोलता है। आप इसे मुख्य रूप से यूडीपी / आईसीएमपी सॉकेट या सर्वर सॉकेट के लिए उपयोग करेंगे
  • bind(endpoint) : यह फ़ंक्शन इस पते से संबद्ध है।
  • connect(endpoint) : यह फ़ंक्शन सिंक्रोनस इस पते से जुड़ता है।
  • async_connect(endpoint) : यह फ़ंक्शन असिंक्रोनस रूप से इस पते से जोड़ता है।
  • is_open() : यह फ़ंक्शन सही है यदि सॉकेट खुला है।
  • close() : यह फ़ंक्शन सॉकेट को बंद करता है। इस सॉकेट पर कोई भी एसिंक्रोनस ऑपरेशन तुरंत बंद हो जाता है और एक error::operation_aborted त्रुटि कोड वापस कर देता है।
  • shutdown(type_of_shutdown) : यह फ़ंक्शन कॉल के तुरंत बाद send , receive या दोनों ऑपरेशन को अक्षम करता है।
  • cancel() : यह फ़ंक्शन इस सॉकेट पर सभी अतुल्यकालिक संचालन को रद्द करता है। इस सॉकेट पर सभी अतुल्यकालिक संचालन तुरंत पूरे हो जाएंगे और एक error::operation_aborted त्रुटि कोड लौटाएगा।
  
  यहाँ एक छोटा सा उदाहरण है:
  
  

   ip::tcp::endpoint ep( ip::address::from_string("127.0.0.1"), 80); ip::tcp::socket sock(service); sock.open(ip::tcp::v4()); sock.connect(ep); sock.write_some(buffer("GET /index.html\r\n")); char buff[1024]; sock.read_some(buffer(buff,1024)); sock.shutdown(ip::tcp::socket::shutdown_receive); sock.close(); 

  
  
  

  पढ़ें / लिखें कार्य

  
  ये ऐसे कार्य हैं जो एक सॉकेट पर इनपुट / आउटपुट करते हैं।
  अतुल्यकालिक कार्यों के लिए, हैंडलर में निम्नलिखित हस्ताक्षर void handler(const boost::system::error_code& e, size_t bytes); । लेकिन कार्य खुद:
  
  • async_receive(buffer, [flags,] handler) : यह फ़ंक्शन सॉकेट से डेटा प्राप्त करने के अतुल्यकालिक संचालन को शुरू करता है।
  • async_read_some(buffer,handler) : यह फ़ंक्शन async_receive(buffer, handler) बराबर है।
  • async_receive_from(buffer, endpoint[, flags], handler) : यह फ़ंक्शन एक विशिष्ट पते से एसिंक्रोनस रूप से डेटा प्राप्त करना शुरू करता है।
  • async_send(buffer [, flags], handler) : यह फ़ंक्शन बफर से एसिंक्रोनस डेटा ट्रांसफर का संचालन शुरू करता है
  • async_write_some(buffer, handler) : यह फ़ंक्शन async_send(buffer, handler) बराबर है।
  • async_send_to(buffer, endpoint, handler) : यह फ़ंक्शन बफर से डेटा को एक विशिष्ट पते पर अतुल्यकालिक रूप से स्थानांतरित करने का संचालन शुरू करता है।
  • receive(buffer [, flags]) : यह फ़ंक्शन एक बफर में डेटा को सिंक्रोनाइज़ करता है। फ़ंक्शन तब तक अवरुद्ध होता है जब तक कि डेटा आना शुरू नहीं होता है या यदि कोई त्रुटि होती है
  • read_some(buffer) : यह फ़ंक्शन receive(buffer) करने के बराबर है।
  • receive_from(buffer, endpoint [, flags]) : यह फ़ंक्शन सिंक्रोनस इस बफर में एक विशिष्ट पते से डेटा प्राप्त करता है। फ़ंक्शन तब तक अवरुद्ध होता है जब तक कि डेटा आना शुरू नहीं हुआ या यदि कोई त्रुटि हुई।
  • send(buffer [, flags]) : यह फ़ंक्शन बाइनरी से डेटा को सिंक्रोनाइज़ करता है। यदि डेटा भेजा जा रहा है या कोई त्रुटि होती है, तो फ़ंक्शन ब्लॉक हो जाता है।
  • write_some(buffer) : यह फ़ंक्शन send(buffer) बराबर है।
  • send_to(buffer, endpoint [, flags]) : यह फ़ंक्शन बफर से डेटा को इस पते पर सिंक्रोनाइज़ करता है। यदि डेटा भेजा जा रहा है या कोई त्रुटि होती है, तो फ़ंक्शन ब्लॉक हो जाता है।
  • available() : यह फ़ंक्शन बाइट्स की संख्या को लौटाता है, जो बिना अवरोध के समकालिक रूप से पढ़ा जा सकता है।
  
  हम निकट भविष्य में बफ़र्स के बारे में बात करेंगे। आइए झंडे को देखें। झंडे के लिए डिफ़ॉल्ट मान 0 है, लेकिन संयोजन संभव हैं:
  
  • ip::socket_type::socket::message_peek : यह ध्वज केवल संदेश में दिखता है। यह संदेश वापस कर देगा, लेकिन अगली बार जब आप इसे कॉल करेंगे, तो आपको संदेश पढ़ने के लिए इसे फिर से पढ़ना होगा।
  • ip::socket_type::socket::message_out_of_band : यह ध्वज डेटा के बाहर होने की प्रक्रिया करता है। OOB डेटा वह डेटा है जिसे नियमित डेटा से अधिक महत्वपूर्ण के रूप में चिह्नित किया जाता है। OOB डेटा की एक चर्चा इस पुस्तक के दायरे से परे है।
  • ip::socket_type::socket::message_do_not_route : यह ध्वज इंगित करता है कि संदेश रूटिंग टेबल का उपयोग किए बिना भेजा जाना चाहिए।
  • ip::socket_type::socket::message_end_of_record: यह ध्वज इंगित करता है कि डेटा रिकॉर्डिंग के अंत के बारे में एक मार्कर के साथ चिह्नित है। यह विंडोज पर समर्थित नहीं है।
  
  यदि आपने कभी भी निम्नलिखित कोड लिखा हो, तो सबसे अधिक संभावना है कि आपने message_peek उपयोग किया है:
  
  

   char buff[1024]; sock.receive(buffer(buff), ip::tcp::socket::message_peek ); memset(buff,1024, 0); // re-reads what was previously read sock.receive(buffer(buff) ); 

  
  निम्नलिखित उदाहरण हैं जो विभिन्न प्रकार के सॉकेट्स के लिए सिंक्रोनस और अतुल्यकालिक रूप से पढ़ने के निर्देश देते हैं:
  
  • उदाहरण 1: टीसीपी सॉकेट में तुल्यकालिक पढ़ने और लिखने के लिए:
    

     ip::tcp::endpoint ep( ip::address::from_string("127.0.0.1"), 80); ip::tcp::socket sock(service); sock.connect(ep); sock.write_some(buffer("GET /index.html\r\n")); std::cout << "bytes available " << sock.available() << std::endl; char buff[512]; size_t read = sock.read_some(buffer(buff)); 

    
    
  • उदाहरण 2: यूडीपी सॉकेट के लिए तुल्यकालिक पढ़ना और लिखना:
    

     ip::udp::socket sock(service); sock.open(ip::udp::v4()); ip::udp::endpoint receiver_ep("87.248.112.181", 80); sock.send_to(buffer("testing\n"), receiver_ep); char buff[512]; ip::udp::endpoint sender_ep; sock.receive_from(buffer(buff), sender_ep); 

    
    ध्यान दें कि जब receive_from का उपयोग करके UDP सॉकेट से receive_from , तो आपको समापन बिंदु के डिफ़ॉल्ट निर्माता का उपयोग करने की आवश्यकता है, जैसा कि पिछले उदाहरण में दिखाया गया है।
    
  • उदाहरण 3: यूडीपी सर्वर सॉकेट से अतुल्यकालिक रूप से पढ़ना:
    

     using namespace boost::asio; io_service service; ip::udp::socket sock(service); boost::asio::ip::udp::endpoint sender_ep; char buff[512]; void on_read(const boost::system::error_code & err, std::size_t read_bytes) { std::cout << "read " << read_bytes << std::endl; sock.async_receive_from(buffer(buff), sender_ep, on_read); } int main(int argc, char* argv[]) { ip::udp::endpoint ep( ip::address::from_string("127.0.0.1"), 8001); sock.open(ep.protocol()); sock.set_option(boost::asio::ip::udp::socket::reuse_ address(true)); sock.bind(ep); sock.async_receive_from(buffer(buff,512), sender_ep, on_read); service.run(); } 

    
    
  
  
  

  सॉकेट प्रबंधन

  
  ये कार्य अतिरिक्त सॉकेट मापदंडों के साथ काम करते हैं:
  
  • get_io_service() : यह फ़ंक्शन io_service इंस्टेंस देता है जिसे io_service में स्वीकार किया गया था।
  • get_option(option) : यह फ़ंक्शन सॉकेट पैरामीटर लौटाता है
  • set_option(option) : यह फ़ंक्शन सॉकेट पैरामीटर सेट करता है
  • io_control(cmd) : यह फ़ंक्शन सॉकेट पर I / O कमांड निष्पादित करता है।
  
  निम्नलिखित पैरामीटर आप सॉकेट में प्राप्त / सेट कर सकते हैं:
  

  पहला नाम	परिभाषा	टाइप
  broadcast	यदि true , तो प्रसारण संदेशों की अनुमति देता है	bool
  debug	यदि true , तो सॉकेट स्तर डिबगिंग की अनुमति देता है	bool
  do_not_route	यदि true , तो यह रूटिंग को रोकता है और केवल स्थानीय इंटरफेस का उपयोग करता है	bool
  enable_connection_aborted	यदि true , तो डिस्कनेक्ट किए गए कनेक्शन को फिर से जोड़ता है	bool
  keep_alive	अगर true , तो keep-alives भेजें	bool
  linger	यदि true , तो सॉकेट close() से देरी हो रही है close() , अगर वहाँ सहेजे नहीं गए हैं डेटा	bool
  receive_buffer_size	बफ़र आकार प्राप्त करें	int
  receive_low_watemark	इनपुट सॉकेट को संसाधित करते समय न्यूनतम बाइट्स प्रदान करता है	int
  reuse_address	यदि true , तो सॉकेट एक पते से जुड़ा हो सकता है जो पहले से ही उपयोग में है	bool
  send_buffer_size	बफर आकार भेजें	int
  send_low_watermark	आउटपुट सॉकेट पर भेजने के लिए बाइट्स की न्यूनतम संख्या प्रदान करता है।	int
  ip::v6_only	यदि true , तो केवल IPv6 संचार का उपयोग किया जा सकता है।	bool

  
  प्रत्येक नाम सॉकेट या क्लास के आंतरिक typedef प्रतिनिधित्व करता है। यहां उनका उपयोग करने का तरीका बताया गया है:
  
  

   ip::tcp::endpoint ep( ip::address::from_string("127.0.0.1"), 80); ip::tcp::socket sock(service); sock.connect(ep); // TCP socket can reuse address ip::tcp::socket::reuse_address ra(true); sock.set_option(ra); // get sock receive buffer size ip::tcp::socket::receive_buffer_size rbs; sock.get_option(rbs); std::cout << rbs.value() << std::endl; // set sock's buffer size to 8192 ip::tcp::socket::send_buffer_size sbs(8192); sock.set_option(sbs); 

  
  पिछले फ़ंक्शन को काम करने के लिए सॉकेट खुला होना चाहिए, अन्यथा एक अपवाद फेंक दिया जाएगा।
  
  

  टीसीपी बनाम यूडीपी और आईसीएमपी

  
  जैसा कि मैंने कहा, सभी सॉकेट कक्षाओं के लिए सभी सदस्य कार्य उपलब्ध नहीं हैं। मैंने एक सूची संकलित की है जहाँ सदस्य कार्य भिन्न होते हैं। यदि यहां कोई सदस्य कार्य नहीं करता है, तो इसका मतलब है कि यह सभी सॉकेट वर्गों में मौजूद है:
  

  नाम	टीसीपी	यूडीपी	ICMP
  async_read_some	हां	-	-
  async_write_some	हां	-	-
  async_send_to	-	हां	हां
  read_some	हां	-	-
  receive_from	-	हां	हां
  write_some	हां	-	-
  send_to	-	हां	हां

  
  
  

  अन्य कार्य

  
  कनेक्शन या इनपुट / आउटपुट से संबंधित अन्य कार्य:
  
  • local_endpoint() : यह फ़ंक्शन एड्रेस को लौटाता है यदि सॉकेट स्थानीय रूप से जुड़ा हुआ है।
  • remote_endpoint() : यह फ़ंक्शन उन दूरस्थ पतों को लौटाता है जहाँ सॉकेट जुड़ा था।
  • native_handle() : यह फ़ंक्शन एक साफ सॉकेट लौटाता है। इसका उपयोग केवल तब किया जाना चाहिए जब आप Boost.Asio द्वारा समर्थित क्लीन सॉकेट्स के साथ काम करने के लिए फ़ंक्शन का उपयोग करना चाहते हैं।
  • non_blocking() : यह फ़ंक्शन true यदि सॉकेट नॉन-ब्लॉकिंग है, अन्यथा false ।
  • native_non_blocking() : यह फ़ंक्शन true यदि सॉकेट नॉन-ब्लॉकिंग है, अन्यथा false । हालांकि, यह एक प्राकृतिक सॉकेट के लिए एक शुद्ध एपीआई का आह्वान करेगा। एक नियम के रूप में, आपको इसकी आवश्यकता नहीं है ( non_blocking() हमेशा इस परिणाम को कैश करता है); आपको इसका उपयोग केवल तभी करना चाहिए जब आप native_handle() साथ सीधे काम कर रहे हों।
  • at_mark() : यह फ़ंक्शन true , यदि आप OOB सॉकेट में डेटा पढ़ने जा रहे हैं। उसकी जरूरत बहुत कम पड़ती है।
  
  
  

  अन्य विचार

  
  और अंत में, एक सॉकेट इंस्टेंस कॉपी नहीं किया जा सकता है, क्योंकि कॉपी कंस्ट्रक्टर और operator= उपलब्ध नहीं हैं।
  
  

   ip::tcp::socket s1(service), s2(service); s1 = s2; // compile time error ip::tcp::socket s3(s1); // compile time error 

  
  यह बहुत मायने रखता है, क्योंकि प्रत्येक इंस्टेंस स्टोर और संसाधनों को प्रबंधित करता है (स्वयं प्राकृतिक सॉकेट)। यदि हमने कॉपी कंस्ट्रक्टर का उपयोग किया है, तो अंत में हमारे पास एक ही सॉकेट के दो उदाहरण हैं; उन्हें किसी तरह स्वामित्व अधिकार का प्रबंधन करना होगा (या तो एक प्रति के पास स्वामित्व का अधिकार है, या संदर्भ गणना का उपयोग किया जाता है, या कुछ अन्य विधि)। Boost.Asio में, यह नकल को प्रतिबंधित करने के लिए प्रथागत था (यदि आप प्रतियां बनाना चाहते हैं, तो केवल साझा ( shared ) सूचक का उपयोग करें)।
  
  

   typedef boost::shared_ptr<ip::tcp::socket> socket_ptr; socket_ptr sock1(new ip::tcp::socket(service)); socket_ptr sock2(sock1); // ok socket_ptr sock3; sock3 = sock1; // ok 

  
  
  

  सॉकेट बफ़र्स

  
  सॉकेट को पढ़ते या लिखते समय, आपको एक बफर की आवश्यकता होती है जिसमें इनकमिंग या आउटगोइंग डेटा होगा। बफर मेमोरी को I / O संचालन से बचना चाहिए; आपको यह सुनिश्चित करना चाहिए कि जब तक इसे जारी नहीं किया जाता है, तब तक यह दायरे से बाहर नहीं जाएगा जबकि I / O संचालन जारी रहेगा।
  यह तुल्यकालिक संचालन के लिए बहुत सरल है; buff , buff को जीवित रहना चाहिए और संचालन receive करना चाहिए:
  
  

   char buff[512]; ... sock.receive(buffer(buff)); strcpy(buff, "ok\n"); sock.send(buffer(buff)); 

  
  और यह अतुल्यकालिक संचालन के लिए इतना सरल नहीं है, जैसा कि निम्नलिखित स्निपेट में दिखाया गया है:
  
  

   // very bad code ... void on_read(const boost::system::error_code & err, std::size_t read_ bytes) { ... } void func() { char buff[512]; sock.async_receive(buffer(buff), on_read); } 

  
  async_receive() कॉल करने के बाद, async_receive() दायरे से बाहर हो जाएगा, इसलिए इसकी मेमोरी को मुक्त कर दिया जाएगा। जब हम वास्तव में एक सॉकेट पर कुछ डेटा प्राप्त करने जा रहे हैं, तो हमें इसे मेमोरी में कॉपी करने की आवश्यकता है जो अब हमारे लिए नहीं है; इसे या तो मुक्त किया जा सकता है या अन्य डेटा के लिए कोड पर पुनर्वितरित किया जा सकता है, जबकि सभी में स्मृति भ्रष्टाचार है।
  समस्या के कई समाधान हैं:
  
  • वैश्विक बफर का उपयोग करें
  • एक बफर बनाएं और ऑपरेशन पूरा होने पर इसे नष्ट कर दें
  • सॉकेट और अतिरिक्त डेटा जैसे कि बफर (एस) का समर्थन करने के लिए एक संचार वस्तु है।
  
  पहला समाधान बहुत सुविधाजनक नहीं है, क्योंकि हम सभी जानते हैं कि वैश्विक चर खराब हैं। इसके अलावा, क्या होता है अगर दो हैंडलर एक ही बफर का उपयोग करते हैं?
  यहां बताया गया है कि आप दूसरा समाधान कैसे लागू कर सकते हैं:
  
  

   void on_read(char * ptr, const boost::system::error_code & err, std::size_t read_bytes) { delete[] ptr; } .... char * buff = new char[512]; sock.async_receive(buffer(buff, 512), boost::bind(on_ read,buff,_1,_2)); 

  
  यदि आप चाहते हैं कि ऑपरेशन पूरा होने पर बफर स्वतः स्कोप से बाहर जाए, तो एक shared pointer उपयोग करें:
  
  

   struct shared_buffer { boost::shared_array<char> buff; int size; shared_buffer(size_t size) : buff(new char[size]), size(size) {} mutable_buffers_1 asio_buff() const { return buffer(buff.get(), size); } }; // when on_read goes out of scope, the boost::bind object is released, // and that will release the shared_buffer as well void on_read(shared_buffer, const boost::system::error_code & err, std::size_t read_bytes) {} ... shared_buffer buff(512); sock.async_receive(buff.asio_buff(), boost::bind(on_read,buff,_1,_2)); 

  
  shared_buffer वर्ग में स्वयं shared_array<> किया गया shared_array<> , जो shared_buffer उदाहरण की एक प्रति है, इसलिए shared_array <> जीवित रहेगा; जब बाद वाला कार्यक्षेत्र से बाहर हो जाता है, तो shared_array <> स्वचालित रूप से ढह जाएगा, बस हम जो चाहते थे।
  यह Boost.Asio के रूप में अपेक्षित रूप से काम करता है, ऑपरेशन पूरा होने पर समाप्त होने वाले हैंडलर की एक प्रति रखेगा। यह कॉपी boost::bind फनकार है, जो आंतरिक रूप से हमारे shared_buffer उदाहरण की एक प्रति संग्रहीत करता है। यह बहुत साफ है!
  तीसरा विकल्प एक संचार वस्तु का उपयोग करना है जो सॉकेट का समर्थन करता है और इसमें अतिरिक्त डेटा होता है, जैसे कि बफ़र्स, यह आमतौर पर सही समाधान है, बल्कि जटिल है। इस अध्याय के अंत में इस पर चर्चा की जाएगी।
  
  

  बफर फंक्शन रैपर

  
  उस कोड में जो हमने पहले देखा था, हमें हमेशा पढ़ने / लिखने के संचालन के लिए एक बफर की आवश्यकता होती है, कोड एक वास्तविक बफर की वस्तु में बदल गया, buffer() को कॉल buffer() और इसे एक फ़ंक्शन में पास कर रहा है:
  
  

   char buff[512]; sock.async_receive(buffer(buff), on_read 

  
  असल में, हमारे पास जो भी बफर होता है, वह लिपटे हुए होते हैं, जो बफर के माध्यम से Boost.Asio से कार्य करने की अनुमति देता है। कहें कि आप निम्नलिखित कोड का उपयोग कर रहे हैं:
  
  

   sock.async_receive(some_buffer, on_read); 

  
  some_buffer की एक आवृत्ति को कुछ आवश्यकताओं को पूरा करना चाहिए, अर्थात् ConstBufferSequence या MutableBufferSequence (आप Boost.Asio पर प्रलेखन में उनके बारे में अधिक देख सकते हैं)। इन आवश्यकताओं को पूरा करने के लिए अपनी खुद की कक्षा बनाने का विवरण काफी जटिल है, लेकिन Boost.Asio में पहले से ही कुछ वर्ग हैं जो इन आवश्यकताओं को मॉडल करते हैं। आप उन्हें सीधे एक्सेस नहीं करते हैं; आप buffer() फ़ंक्शन का उपयोग करते हैं।
  यह कहने के लिए पर्याप्त है कि आप buffer() में निम्नलिखित लपेट सकते हैं buffer() फ़ंक्शन:
  
  • पात्रों की निरंतर सरणी
  • void* और चरित्र का आकार
  • string std::string
  • निरंतर सरणी POD [] (POD पुराने डेटा के लिए उपयुक्त है, अर्थात कंस्ट्रक्टर और विध्वंसक कुछ भी नहीं करते हैं)
  • सरणी std::vector किसी भी POD से
  • boost::array किसी भी POD से boost::array
  • सरणी std::array किसी भी POD से std::array
  
  निम्नलिखित कोड काम कर रहा है:
  
  

   struct pod_sample { int i; long l; char c; }; ... char b1[512]; void * b2 = new char[512]; std::string b3; b3.resize(128); pod_sample b4[16]; std::vector<pod_sample> b5; b5.resize(16); boost::array<pod_sample,16> b6; std::array<pod_sample,16> b7; sock.async_send(buffer(b1), on_read); sock.async_send(buffer(b2,512), on_read); sock.async_send(buffer(b3), on_read); sock.async_send(buffer(b4), on_read); sock.async_send(buffer(b5), on_read); sock.async_send(buffer(b6), on_read); sock.async_send(buffer(b7), on_read); 

  
  सामान्य तौर पर, ConstBufferSequence या MutableBufferSequence ConstBufferSequence की आवश्यकताओं को पूरा करने के लिए अपनी खुद की कक्षा बनाने के बजाय, आप एक ऐसा वर्ग बना सकते हैं जिसमें एक बफर आवश्यक हो और mutable_ buffers_1 का एक उदाहरण mutable_ buffers_1 , यह वही है जो हमने कक्षा में किया था। shared_buffer पहले।
  
  

  स्वतंत्र पढ़ने / लिखने / कार्यों को जोड़ने

  
  Boost.Asio आपको स्वतंत्र I / O फ़ंक्शन देता है। मैंने उन्हें चार समूहों में विभाजित किया।
  
  

  कनेक्टिविटी सुविधाएँ

  
  ये कार्य एक सॉकेट या अंतिम पते को जोड़ते हैं:
  
  • connect(socket, begin [, end] [, condition]) : , begin end . begin socket_type::resolver::query ( , « » ). , . condition , . Iterator connect_condition(const boost::system::error_code & err, Iterator next); । , , .
  • async_connect(socket, begin [, end] [, condition], handler): . void handler(const boost::system::error_code & err, Iterator iterator); । , ( end ).
  
  :
  
  

   using namespace boost::asio::ip; tcp::resolver resolver(service); tcp::resolver::iterator iter = resolver.resolve(tcp::resolver::query("www.yahoo.com","80")); tcp::socket sock(service); connect(sock, iter); 

  
  , connect async_connect , ; .
  
  

  /

  
  ( , ):
  
  • async_read(stream, buffer [, completion] ,handler) : . . void handler(const boost::system::error_code & err, size_t bytes); । completion . Completion read , Boost.Asio async_read ( , ). size_t completion (const boost::system::error_code& err, size_t bytes_transfered) . 0, , ; , , async_read_some . .
  • async_write(stream, buffer [, completion], handler) : . async_read .
  • read(stream, buffer [, completion]) : . async_read
  • write(stream, buffer [, completion]) : . async_read .
  • async_read(stream, stream_buffer [, completion], handler)
  • async_write(strean, stream_buffer [, completion], handler)
  • write(stream, stream_buffer [, completion])
  • read(stream, stream_buffer [, completion])
  
  - , . , . , Windows.
  :
  
  • ( ) ( ).
  • Completion 0 ( ).
  • .
  
  , '\n':
  
  

   io_service service; ip::tcp::socket sock(service); char buff[512]; int offset = 0; size_t up_to_enter(const boost::system::error_code &, size_t bytes) { for ( size_t i = 0; i < bytes; ++i) if ( buff[i + offset] == '\n') return 0; return 1; } void on_read(const boost::system::error_code &, size_t) {} ... async_read(sock, buffer(buff), up_to_enter, on_read); 

  
  , Boost.Asio completion :
  
  • transfer_at_least(n)
  • transfer_exactly(n)
  • transfer_all()
  
  :
  
  

   char buff[512]; void on_read(const boost::system::error_code &, size_t) {} // read exactly 32 bytes async_read(sock, buffer(buff), transfer_exactly(32), on_read); 

  
  stream_buffer Boost.Asio, std::streambuf . STL , :
  
  

   io_service service; void on_read(streambuf& buf, const boost::system::error_code &, size_t) { std::istream in(&buf); std::string line; std::getline(in, line); std::cout << "first line: " << line << std::endl; } int main(int argc, char* argv[]) { HANDLE file = ::CreateFile("readme.txt", GENERIC_READ, 0, 0, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,0); windows::stream_handle h(service, file); streambuf buf; async_read(h, buf, transfer_exactly(256), boost::bind(on_read,boost::ref(buf),_1,_2)); service.run(); } 

  
  , async_read ( - ) Windows. 256 . , on_read , std::istream , ( std::getline ) .
  
  

  read_until/async_read_until

  
  :
  
  • async_read_until(stream, stream_buffer, delim, handler) : . ( delim ). , std::string boost::regex . void handler(const boost::system::error_code & err, size_t bytes); ।
  • async_read_until(stream, stream_buffer, completion, handler) : , . pair<iterator,bool> completion(iterator begin, iterator end); , buffers_iterator<streambuf::const_buffers_type> . , . ( begin, end ) . ; ; true , , , false .
  • read_until(stream, stream_buffer, delim) : . async_read_until .
  
  :
  
  

   typedef buffers_iterator<streambuf::const_buffers_type> iterator; std::pair<iterator, bool> match_punct(iterator begin, iterator end) { while ( begin != end) if ( std::ispunct(*begin)) return std::make_pair(begin,true); return std::make_pair(end,false); } void on_read(const boost::system::error_code &, size_t) {} ... streambuf buf; async_read_until(sock, buf, match_punct, on_read); 

  
  , :
  
  

   async_read_until(sock, buff, ' ', on_read); 

  
  
  

  *_at

  
  / . , / ( ):
  
  • async_read_at(stream, offset, buffer [, completion], handler) : , offset . handler (const boost::system::error_code& err, size_t bytes); । buffer() streambuf . , Boost.Asio async_read_at operation ( , ). size_t completion(const boost::system::error_code& err, size_t bytes); । 0, , , , , async_read_some_at .
  • async_write_at(stream, offset, buffer [, completion], handler): यह फ़ंक्शन एसिंक्रोनस राइट ऑपरेशन शुरू करता है। विकल्प के समान हैं async_read_at।
  • read_at(stream, offset, buffer [, completion]): यह फ़ंक्शन इस स्ट्रीम में एक ऑफसेट के साथ पढ़ता है। विकल्प के समान हैं async_read_at।
  • read_at(stream, offset, buffer [, completion]): यह फ़ंक्शन इस स्ट्रीम में एक ऑफसेट के साथ पढ़ता है। विकल्प के समान हैं async_read_at।
  
  ये कार्य सॉकेट्स से नहीं निपटते हैं। वे यादृच्छिक अभिगम धाराओं से निपटते हैं; दूसरे शब्दों में, उन थ्रेड्स के साथ जिन्हें बेतरतीब ढंग से एक्सेस किया जा सकता है। सॉकेट्स स्पष्ट रूप से यह मामला नहीं है (सॉकेट्स हैं forward-only)।
  यहां बताया गया है कि आप एक फाइल से 128 बाइट कैसे पढ़ सकते हैं, जिसकी शुरुआत 256 से होती है:
  
  

   io_service service; int main(int argc, char* argv[]) { HANDLE file = ::CreateFile("readme.txt", GENERIC_READ, 0, 0, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,0); windows::random_access_handle h(service, file); streambuf buf; read_at(h, 256, buf, transfer_exactly(128)); std::istream in(&buf); std::string line; std::getline(in, line); std::cout << "first line: " << line << std::endl; } 

  
  
  अगली बार जब हम अतुल्यकालिक प्रोग्रामिंग के बारे में बात करेंगे, तो आप सभी के ध्यान के लिए धन्यवाद। सभी टिप्पणियाँ टिप्पणियों में लिखें। मैं जवाब जरूर दूंगा।
  
  सभी को शुभकामनाएँ!