🔁 ⛅️ 👨🏽‍🤝‍👨🏻 गेम डेवलपर्स के लिए नेटवर्क प्रोग्रामिंग। भाग 2: डेटा पैकेट प्राप्त करना और प्रेषित करना 🧖 ⌚️ 🧟

अनुवादक से: यह गेम प्रोग्रामर श्रृंखला के लिए नेटवर्किंग के दूसरे लेख का अनुवाद है। मुझे वास्तव में लेखों की पूरी श्रृंखला पसंद है, साथ ही मैं हमेशा एक अनुवादक के रूप में खुद को आजमाना चाहता था। शायद, लेख अनुभवी डेवलपर्स के लिए बहुत स्पष्ट प्रतीत होगा, लेकिन, मेरी राय में, यह किसी भी मामले में उपयोगी होगा।
पहला लेख - http://habrahabr.ru/post/209144/

डेटा पैकेट प्राप्त करें और संचारित करें

परिचय

नमस्ते, मेरा नाम ग्लेन फिडलर है और मैं "गेम डेवलपर्स के लिए नेटवर्क प्रोग्रामिंग" श्रृंखला के अपने दूसरे लेख में आपका स्वागत करता हूं।

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

और अब मैं आपको बताने जा रहा हूं कि पैकेट भेजने और प्राप्त करने के लिए व्यवहार में यूडीपी का उपयोग कैसे करें।

बीएसडी की कुर्सियां

अधिकांश आधुनिक ऑपरेटिंग सिस्टम में बीएसडी सॉकेट्स (बर्कले सॉकेट्स) के आधार पर कुछ प्रकार के सॉकेट कार्यान्वयन हैं।

बीएसडी सॉकेट "सॉकेट", "बाइंड", "सेंडआउट" और "रिकर्वफ्रेम" जैसे सरल कार्यों के साथ काम करते हैं। बेशक, आप इन कार्यों को सीधे एक्सेस कर सकते हैं, लेकिन इस मामले में आपका कोड प्लेटफ़ॉर्म डिपेंडेंट होगा, क्योंकि अलग-अलग OS में उनके कार्यान्वयन थोड़े अलग हो सकते हैं।

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

विभिन्न ओएस की विशेषताएं

शुरू करने के लिए, हम एक कोड लिखेंगे जो वर्तमान ओएस को निर्धारित करेगा ताकि हम सॉकेट्स के संचालन में अंतरों को ध्यान में रख सकें:

// platform detection #define PLATFORM_WINDOWS 1 #define PLATFORM_MAC 2 #define PLATFORM_UNIX 3 #if defined(_WIN32) #define PLATFORM PLATFORM_WINDOWS #elif defined(__APPLE__) #define PLATFORM PLATFORM_MAC #else #define PLATFORM PLATFORM_UNIX #endif

अब सॉकेट्स के साथ काम करने के लिए आवश्यक हेडर फ़ाइलों को कनेक्ट करें। चूंकि आवश्यक हेडर फ़ाइलों का सेट वर्तमान ओएस पर निर्भर करता है, यहां हम यह निर्धारित करने के लिए ऊपर लिखे #define कोड का उपयोग करते हैं कि कौन सी फाइलें कनेक्ट होनी चाहिए।

  #if PLATFORM == PLATFORM_WINDOWS #include <winsock2.h> #elif PLATFORM == PLATFORM_MAC || PLATFORM == PLATFORM_UNIX #include <sys/socket.h> #include <netinet/in.h> #include <fcntl.h> #endif

UNIX प्रणालियों पर, सॉकेट फ़ंक्शंस मानक सिस्टम पुस्तकालयों में शामिल हैं, इसलिए हमें इस मामले में किसी तीसरे पक्ष के पुस्तकालयों की आवश्यकता नहीं है। हालांकि, विंडोज पर, इन उद्देश्यों के लिए हमें वाइनस्कॉक लाइब्रेरी को कनेक्ट करने की आवश्यकता है।

यहाँ थोड़ा चाल है कि परियोजना या मेकफाइल को बदलने के बिना यह कैसे करें:

  #if PLATFORM == PLATFORM_WINDOWS #pragma comment( lib, "wsock32.lib" ) #endif

मुझे यह तकनीक पसंद है क्योंकि मैं आलसी हूं। बेशक, आप लाइब्रेरी को प्रोजेक्ट या मेकफाइल से जोड़ सकते हैं।

सॉकेट प्रारंभ

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

आइए दो नई सुविधाएँ जोड़ें:

  inline bool InitializeSockets() { #if PLATFORM == PLATFORM_WINDOWS WSADATA WsaData; return WSAStartup( MAKEWORD(2,2), &WsaData ) == NO_ERROR; #else return true; #endif } inline void ShutdownSockets() { #if PLATFORM == PLATFORM_WINDOWS WSACleanup(); #endif }

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

एक सॉकेट बनाएं

अब हम एक यूडीपी सॉकेट बना सकते हैं। यह इस प्रकार किया जाता है:

  int handle = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP ); if ( handle <= 0 ) { printf( "failed to create socket\n" ); return false; }

अगला, हमें सॉकेट को एक विशिष्ट पोर्ट संख्या (उदाहरण के लिए, 30000) से बांधना चाहिए। प्रत्येक सॉकेट का अपना एक विशिष्ट पोर्ट होना चाहिए, क्योंकि जब कोई नया पैकेट आता है, तो पोर्ट संख्या निर्धारित करती है कि किस सॉकेट को आगे भेजना है। 1024 से छोटे पोर्ट नंबर का उपयोग न करें - वे सिस्टम द्वारा आरक्षित हैं।

यदि आपको परवाह नहीं है कि सॉकेट के लिए किस पोर्ट नंबर का उपयोग करना है, तो आप बस फ़ंक्शन को "0" पास कर सकते हैं, और फिर सिस्टम स्वयं आपको कुछ निर्बाध पोर्ट देगा।

  sockaddr_in address; address.sin_family = AF_INET; address.sin_addr.s_addr = INADDR_ANY; address.sin_port = htons( (unsigned short) port ); if ( bind( handle, (const sockaddr*) &address, sizeof(sockaddr_in) ) < 0 ) { printf( "failed to bind socket\n" ); return false; }

अब हमारा सॉकेट डेटा पैकेट भेजने और प्राप्त करने के लिए तैयार है।

लेकिन इस रहस्यमय "htons" फ़ंक्शन को कोड में क्या कहा जाता है? यह सिर्फ एक छोटा सहायक कार्य है जो बाइट ऑर्डर को 16-बिट पूर्णांक में - वर्तमान (छोटे या बड़े-एंडियन) से बड़े-एंडियन में अनुवाद करता है, जिसका उपयोग नेटवर्क संचार के लिए किया जाता है। जब आप सीधे सॉकेट्स के साथ काम करते हैं तो आपको हर बार पूर्णांक का उपयोग करने की आवश्यकता होती है।

आप इस लेख में कई बार "htons" फ़ंक्शन और इसके 32-बिट डबल - "htonl" देखेंगे, इसलिए सावधान रहें।

एक सॉकेट को नॉन-ब्लॉकिंग मोड में डालना

डिफ़ॉल्ट रूप से, सॉकेट तथाकथित "ब्लॉकिंग मोड" में हैं। इसका मतलब है कि यदि आप "रिकवरफ्रॉम" का उपयोग करके इससे डेटा पढ़ने की कोशिश करते हैं, तो फ़ंक्शन तब तक एक मान नहीं लौटाएगा जब तक सॉकेट को डेटा के साथ एक पैकेट प्राप्त नहीं होता है जिसे पढ़ा जा सकता है। यह व्यवहार हमें बिल्कुल भी पसंद नहीं है। खेल 30 से 60 फ्रेम प्रति सेकंड की गति के साथ वास्तविक समय के अनुप्रयोग हैं, और खेल बस रुक नहीं सकता है और एक डेटा पैकेट आने तक प्रतीक्षा कर सकता है!

इसके निर्माण के बाद सॉकेट को "नॉन-ब्लॉकिंग मोड" में डालकर इस समस्या को हल किया जा सकता है। इस मोड में, "recvfrom" फ़ंक्शन, यदि सॉकेट से पढ़ने के लिए कोई डेटा नहीं है, तो तुरंत एक निश्चित मान देता है जो दर्शाता है कि सॉकेट पर डेटा दिखाई देने पर इसे फिर से कॉल करना आवश्यक होगा।

आप सॉकेट को गैर-ब्लॉकिंग मोड में रख सकते हैं:

  #if PLATFORM == PLATFORM_MAC || PLATFORM == PLATFORM_UNIX int nonBlocking = 1; if ( fcntl( handle, F_SETFL, O_NONBLOCK, nonBlocking ) == -1 ) { printf( "failed to set non-blocking socket\n" ); return false; } #elif PLATFORM == PLATFORM_WINDOWS DWORD nonBlocking = 1; if ( ioctlsocket( handle, FIONBIO, &nonBlocking ) != 0 ) { printf( "failed to set non-blocking socket\n" ); return false; } #endif

जैसा कि आप देख सकते हैं, विंडोज पर "fcntl" फ़ंक्शन नहीं है, इसलिए हम एक साथ "ioctlsocket" का उपयोग करते हैं।

पैकेज भेज रहा है

यूडीपी एक कनेक्शन रहित प्रोटोकॉल है, इसलिए हर बार जब हम एक पैकेट भेजते हैं, तो हमें प्राप्तकर्ता पते को निर्दिष्ट करने की आवश्यकता होती है। पैकेट को अलग-अलग आईपी पते पर भेजने के लिए आप एक ही यूडीपी सॉकेट का उपयोग कर सकते हैं - सॉकेट के दूसरे छोर पर एक कंप्यूटर होना आवश्यक नहीं है।

आप एक विशिष्ट पते पर एक पैकेट को इस प्रकार अग्रेषित कर सकते हैं:

  int sent_bytes = sendto( handle, (const char*)packet_data, packet_size, 0, (sockaddr*)&address, sizeof(sockaddr_in) ); if ( sent_bytes != packet_size ) { printf( "failed to send packet: return value = %d\n", sent_bytes ); return false; }

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

उपरोक्त कोड में, हम गंतव्य पते के रूप में "sockaddr_in" संरचना पास करते हैं। हमें यह संरचना कैसे मिलती है?

मान लीजिए हम एक पैकेट को पते पर भेजना चाहते हैं 207.45.186.98। 0000।

हम निम्नलिखित रूप में पता लिखते हैं:

  unsigned int a = 207; unsigned int b = 45; unsigned int c = 186; unsigned int d = 98; unsigned short port = 30000;

और आपको एक ऐसे रूप में लाने के लिए कुछ और अधिक परिवर्तन करने की आवश्यकता है जो कि Sendto समझता है:

  unsigned int destination_address = ( a << 24 ) | ( b << 16 ) | ( c << 8 ) | d; unsigned short destination_port = port; sockaddr_in address; address.sin_family = AF_INET; address.sin_addr.s_addr = htonl( destination_address ); address.sin_port = htons( destination_port );

जैसा कि आप देख सकते हैं, पहले हम संख्याओं को ए, बी, सी, डी (जो कि सीमा [0, 255] में है) को एक पूर्णांक में जोड़ते हैं जिसमें प्रत्येक बाइट मूल संख्याओं में से एक है। फिर हम "htonl" और "htons" फ़ंक्शंस का उपयोग करके बाइट ऑर्डर को बदलने के लिए भूलकर, अपने गंतव्य पते और पोर्ट के साथ "sockaddr_in" संरचना को इनिशियलाइज़ करते हैं।

अलग-अलग, यह उस मामले को उजागर करने के लायक है जब आपको पैकेट को खुद को स्थानांतरित करने की आवश्यकता होती है: आपको स्थानीय मशीन का आईपी पता खोजने की आवश्यकता नहीं है, लेकिन आप केवल 127.0.0.1 पते (स्थानीय लूप का पता) के रूप में उपयोग कर सकते हैं, और पैकेट स्थानीय कंप्यूटर पर भेजा जाएगा।

पैकेट प्राप्त करना

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

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

एक लूप में पैकेट प्राप्त करने के लिए कोड:

  while ( true ) { unsigned char packet_data[256]; unsigned int maximum_packet_size = sizeof( packet_data ); #if PLATFORM == PLATFORM_WINDOWS typedef int socklen_t; #endif sockaddr_in from; socklen_t fromLength = sizeof( from ); int received_bytes = recvfrom( socket, (char*)packet_data, maximum_packet_size, 0, (sockaddr*)&from, &fromLength ); if ( received_bytes <= 0 ) break; unsigned int from_address = ntohl( from.sin_addr.s_addr ); unsigned int from_port = ntohs( from.sin_port ); // process received packet }

पैकेट जो प्राप्त बफ़र के आकार से बड़े हैं, उन्हें बस चुपचाप कतार से हटा दिया जाएगा। इसलिए यदि आप उपरोक्त उदाहरण में 256 बाइट्स के बफर का उपयोग करते हैं, और कोई आपको 300 बाइट का पैकेट भेजता है, तो उसे छोड़ दिया जाएगा। आपको पैकेट से सिर्फ पहले 256 बाइट नहीं मिलेंगे।

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

बंद सॉकेट

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

  #if PLATFORM == PLATFORM_MAC || PLATFORM == PLATFORM_UNIX close( socket ); #elif PLATFORM == PLATFORM_WINDOWS closesocket( socket ); #endif

इसे रखो, विंडोज!

सॉकेट क्लास

इसलिए, हमने सभी बुनियादी कार्यों का पता लगाया: एक सॉकेट बनाना, इसे एक बंदरगाह से बांधना, गैर-अवरुद्ध मोड में स्विच करना, पैकेट भेजना और प्राप्त करना, और, अंत में, सॉकेट को बंद करना।

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

इसलिए, हम इन सभी कार्यों के लिए एक "सॉकेट" आवरण वर्ग बनाएंगे। हम आईपी एड्रेस के साथ काम करना आसान बनाने के लिए "एड्रेस" क्लास भी बनाएंगे। यह हमें हर बार "sockaddr_in" के साथ सभी जोड़तोड़ नहीं करने की अनुमति देगा, जब हम एक पैकेट भेजना या प्राप्त करना चाहते हैं।

तो, हमारा सॉकेट क्लास:

  class Socket { public: Socket(); ~Socket(); bool Open( unsigned short port ); void Close(); bool IsOpen() const; bool Send( const Address & destination, const void * data, int size ); int Receive( Address & sender, void * data, int size ); private: int handle; };

और पता वर्ग:

  class Address { public: Address(); Address( unsigned char a, unsigned char b, unsigned char c, unsigned char d, unsigned short port ); Address( unsigned int address, unsigned short port ); unsigned int GetAddress() const; unsigned char GetA() const; unsigned char GetB() const; unsigned char GetC() const; unsigned char GetD() const; unsigned short GetPort() const; bool operator == ( const Address & other ) const; bool operator != ( const Address & other ) const; private: unsigned int address; unsigned short port; };

रिसेप्शन और ट्रांसमिशन के लिए उनका उपयोग निम्नानुसार करें:

  // create socket const int port = 30000; Socket socket; if ( !socket.Open( port ) ) { printf( "failed to create socket!\n" ); return false; } // send a packet const char data[] = "hello world!"; socket.Send( Address(127,0,0,1,port), data, sizeof( data ) ); // receive packets while ( true ) { Address sender; unsigned char buffer[256]; int bytes_read = socket.Receive( sender, buffer, sizeof( buffer ) ); if ( !bytes_read ) break; // process packet }

जैसा कि आप देख सकते हैं, यह सीधे बीएसडी सॉकेट्स के साथ काम करने की तुलना में बहुत आसान है। और यह कोड भी सभी OS के लिए समान होगा, क्योंकि सभी प्लेटफ़ॉर्म-निर्भर कार्यक्षमता सॉकेट और एड्रेस क्लासेस के अंदर होती है।

निष्कर्ष

अब हमारे पास UDP पैकेट भेजने और प्राप्त करने के लिए एक प्लेटफ़ॉर्म-स्वतंत्र उपकरण है।

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

आप आसानी से कार्यक्रम को कॉन्फ़िगर कर सकते हैं ताकि स्थानीय मशीन पर भी एक दूसरे के साथ पैकेट के आदान-प्रदान के कई नोड मिल सकें। ऐसा करने के लिए, उदाहरण के लिए, विभिन्न प्रोग्राम इंस्टेंस के लिए अलग-अलग पोर्ट निर्दिष्ट करें:

> नोड 30000
> नोड 30001
> नोड 30002
आदि ...

प्रत्येक नोड्स सभी अन्य नोड्स को पैकेट फॉरवर्ड करेंगे, एक मिनी पीयर-टू-पीयर सिस्टम की तरह कुछ बनाएंगे।

मैंने इस कार्यक्रम को MacOSX पर विकसित किया है, लेकिन इसे किसी भी यूनिक्स जैसे ओएस और विंडोज पर संकलित करना चाहिए, हालांकि अगर आपको इसके लिए कोई सुधार करने की आवश्यकता है, तो मुझे बताएं।

गेम डेवलपर्स के लिए नेटवर्क प्रोग्रामिंग। भाग 2: डेटा पैकेट प्राप्त करना और प्रेषित करना