गैर-अवरुद्ध सॉकेट्स के साथ क्रॉस-प्लेटफ़ॉर्म https सर्वर

यह लेख मेरे लेख का एक निरंतरता है एसएसएल समर्थन के साथ सबसे सरल क्रॉस-प्लेटफ़ॉर्म सर्वर ।
इसलिए, आगे पढ़ने के लिए पिछले लेख के कम से कम भाग को पढ़ना बहुत उचित है। लेकिन अगर आप ऐसा महसूस नहीं करते हैं, तो यहां एक संक्षिप्त सारांश है: मैंने ओपनएसएसएल स्रोतों से एक उदाहरण फ़ाइल "serv.cpp" ली और इसे एक सरल क्रॉस-प्लेटफ़ॉर्म सर्वर बनाया जो क्लाइंट से एक वर्ण प्राप्त कर सकता है।
अब मैं आगे जाना चाहता हूं और सर्वर को मजबूर करना चाहता हूं:
1. ब्राउज़र से संपूर्ण http हेडर प्राप्त करें।
2. एचटीएमएल पेज ब्राउजर को भेजें जिसमें http हैडर प्रदर्शित होगा।
3. इसके अलावा, मैं चाहता हूं कि सॉकेट सर्वर प्रक्रिया को अवरुद्ध न करें और इसके लिए मैं उन्हें तथाकथित "गैर-अवरुद्ध मोड" में स्थानांतरित कर दूंगा।

आरंभ करने के लिए, मुझे पिछले लेख में संशोधित serv.cpp फ़ाइल की आवश्यकता होगी।
गैर-अवरोधक मोड में सॉकेट्स लगाने के लिए क्रॉस-प्लेटफ़ॉर्म मैक्रोज़ लिखने वाली पहली चीज़ है:

इस कोड की लाइन के लिए

#ifndef WIN32 #define closesocket close #endif 

निम्नलिखित में परिवर्तन करें:

 #ifdef WIN32 #define SET_NONBLOCK(socket) \ if (true) \ { \ DWORD dw = true; \ ioctlsocket(socket, FIONBIO, &dw); \ } #else #include <fcntl.h> #define SET_NONBLOCK(socket) \ if (fcntl( socket, F_SETFL, fcntl( socket, F_GETFL, 0 ) | O_NONBLOCK ) < 0) \ printf("error in fcntl errno=%i\n", errno); #define closesocket(socket) close(socket) #endif 

हो गया! अब, "सुनने" सॉकेट को गैर-अवरोधक मोड में डालने के लिए, यह लाइन के बाद पर्याप्त है

 listen_sd = socket (AF_INET, SOCK_STREAM, 0); CHK_ERR(listen_sd, "socket"); 

लाइन डालें:

 SET_NONBLOCK(listen_sd); 

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

  int sd = -1; while(sd == -1) { Sleep(1); #ifdef WIN32 sd = accept (listen_sd, (struct sockaddr*) &sa_cli, (int *)&client_len); #else sd = accept (listen_sd, (struct sockaddr*) &sa_cli, &client_len); #endif } 

कार्यक्रम को 100% प्रोसेसर लोड करने से रोकने के लिए, मैंने स्लीप (1) को लूप में जोड़ा। विंडोज पर, इसका मतलब है 1 मिलीसेकंड ब्रेक। इसके लिए लिनक्स पर काम करें, फाइल की शुरुआत में जोड़ें:

 #ifndef WIN32 #define Sleep(a) usleep(a*1000) #endif 

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

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

 SET_NONBLOCK(sd); 

अब क्लाइंट के साथ संचार के लिए सॉकेट नॉन-ब्लॉकिंग, फंक्शन है

 err = SSL_accept (ssl); 

इस प्रक्रिया को निलंबित नहीं करेगा, लेकिन गलती से कॉल के तुरंत बाद वापस आ जाएगा = SSL_ERROR_WANT_READ या SSL_ERROR_WANT_WRITE
एन्क्रिप्टेड संदेश प्राप्त करने के लिए, हमें एक और अनंत लूप की आवश्यकता है:

  while(1) { Sleep(1); err = SSL_accept (ssl); const int nCode = SSL_get_error(ssl, err); if ((nCode != SSL_ERROR_WANT_READ) && (nCode != SSL_ERROR_WANT_WRITE)) break; } CHK_SSL(err); 

केवल जब प्रोग्राम इस चक्र से बाहर निकलता है, तो आप यह सुनिश्चित कर सकते हैं कि एन्क्रिप्टेड कनेक्शन स्थापित है और आप संदेश प्राप्त करना और भेजना शुरू कर सकते हैं।
हम एक ब्राउज़र का उपयोग करके सर्वर से कनेक्ट करेंगे, इसलिए क्लाइंट संदेशों में http हेडर और अनुरोध बॉडी शामिल हैं।
इस स्थिति में, http शीर्षक "\ r \ n \ r \ n" स्ट्रिंग के साथ समाप्त होना चाहिए।
हम अपना कोड ठीक करेंगे ताकि सर्वर पूरे http हेडर को पढ़े, न कि केवल उसके पहले अक्षर को।

कोड को छोटा करने के लिए, मैं अद्भुत एसटीएल लाइब्रेरी का उपयोग करने का सुझाव देता हूं:
1. तीन हेडर फाइलें जोड़ें:

 #include <vector> #include <string> #include <sstream> 

2. लाइनों को बदलें

  err = SSL_read (ssl, buf, sizeof(buf) - 1); CHK_SSL(err); buf[err] = '\0'; printf ("Got %d chars:'%s'\n", err, buf); 

निम्नलिखित कोड के लिए:

  std::vector<unsigned char> vBuffer(4096); //     memset(&vBuffer[0], 0, vBuffer.size()); //   size_t nCurrentPos = 0; while (nCurrentPos < vBuffer.size()-1) { err = SSL_read (ssl, &vBuffer[nCurrentPos], vBuffer.size() - nCurrentPos - 1); //        if (err > 0) { nCurrentPos += err; const std::string strInputString((const char *)&vBuffer[0]); if (strInputString.find("\r\n\r\n") != -1) //   http ,     break; continue; } const int nCode = SSL_get_error(ssl, err); if ((nCode != SSL_ERROR_WANT_READ) && (nCode != SSL_ERROR_WANT_WRITE)) break; } 

इस चक्र में, सर्वर क्लाइंट से डेटा पढ़ता है जब तक कि वह http हेडर "\ r \ n \ r \ n" के अंत के लिए वर्ण प्राप्त नहीं करता है, या जब तक बफर स्पेस बाहर नहीं निकलता है।
यह मेरे लिए सुविधाजनक है कि बफर को std :: वेक्टर के रूप में आवंटित किया जाए, यदि केवल इसलिए कि मुझे इसकी लंबाई याद रखने के लिए एक अलग चर की आवश्यकता नहीं है।
लूप से बाहर निकलने के बाद, पूरे http हेडर और, संभवतः, अनुरोध बॉडी का हिस्सा बफर में संग्रहित किया जाना चाहिए।

3. ब्राउज़र में html पेज भेजें, जिसमें हम इसके अनुरोध के http हेडर लिखते हैं।
स्ट्रिंग बदलें

 err = SSL_write (ssl, "I hear you.", strlen("I hear you.")); CHK_SSL(err); 

निम्नलिखित कोड के लिए:

  //      const std::string strInputString((const char *)&vBuffer[0]); // html     const std::string strHTML = "<html><body><h2>Hello! Your HTTP headers is:</h2><br><pre>" + strInputString.substr(0, strInputString.find("\r\n\r\n")) + "</pre></body></html>"; //    http  std::ostringstream strStream; strStream << "HTTP/1.1 200 OK\r\n" << "Content-Type: text/html; charset=utf-8\r\n" << "Content-Length: " << strHTML.length() << "\r\n" << "\r\n" << strHTML.c_str(); //    . nCurrentPos = 0; while(nCurrentPos < strStream.str().length()) { err = SSL_write (ssl, strStream.str().c_str(), strStream.str().length()); if (err > 0) { nCurrentPos += err; continue; } const int nCode = SSL_get_error(ssl, err); if ((nCode != SSL_ERROR_WANT_READ) && (nCode != SSL_ERROR_WANT_WRITE)) break; } 

चूंकि हमारे पास गैर-अवरुद्ध सॉकेट हैं, इसलिए कोई गारंटी नहीं है कि उत्तर पूरी तरह से पहली बार भेजा जाएगा। इसलिए, आपको SSL_write को लूप में कॉल करना होगा।
वह सब है। अब आप हमारे सर्वर को शुरू कर सकते हैं, और ब्राउज़र में टाइप कर सकते हैं localhost:1111
जवाब में, ब्राउज़र अपने http अनुरोध के साथ एक पृष्ठ प्रदर्शित करेगा।

संग्रह 3_.3s3s.org में विजुअल स्टूडियो 2012 के लिए प्रोजेक्ट।
लिनक्स के तहत संकलित करने के लिए, संग्रह में से "ca-cert.pem" और "serv.cpp" फ़ाइलों को एक निर्देशिका में कॉपी करें और संकलक चलाएं: "g ++ -L / usr / lib -lsl -lcrypto serv.cpp

पुनश्च: इस लेख का एक निरंतरता लिखा है