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

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

सबसे पहले, मैं कोड को दो फाइलों में तोड़ दूंगा: serv.cpp और server.h
इस स्थिति में, serv.cpp फ़ाइल में ऐसा "अत्यधिक बुद्धिमान" कोड होगा:

#include "server.h" int main() { server::CServer(); return 0; } 

हां, आप मुझे लात मार सकते हैं, लेकिन मैंने अभी भी लिखा है, लिख रहा हूं और हेडर फाइलों में कोड लिखूंगा यदि यह मेरे लिए सुविधाजनक है। इसके लिए मैं वास्तव में C ++ से प्यार करता हूं कि यह पसंद की स्वतंत्रता देता है, लेकिन यह एक अलग बातचीत है ...

Server.h फ़ाइल पर जाएं
शुरुआत में, मैंने सभी हेडर, मैक्रोज़, और परिभाषाएँ, जो पहले serv.cpp में थीं, को स्थानांतरित कर दिया, और STL से कुछ और हेडर जोड़े:

 #ifndef _SERVER #define _SERVER #include <stdio.h> #include <stdlib.h> #include <memory.h> #include <errno.h> #include <sys/types.h> #ifndef WIN32 #include <unistd.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <netdb.h> #else #include <io.h> #include <Winsock2.h> #pragma comment(lib, "ws2_32.lib") #endif #include <openssl/rsa.h> /* SSLeay stuff */ #include <openssl/crypto.h> #include <openssl/x509.h> #include <openssl/pem.h> #include <openssl/ssl.h> #include <openssl/err.h> #include <vector> #include <string> #include <sstream> #include <map> #include <memory> #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) #define Sleep(a) usleep(a*1000) #define SOCKET int #define INVALID_SOCKET -1 #endif /* define HOME to be dir for key and cert files... */ #define HOME "./" /* Make these what you want for cert & key files */ #define CERTF HOME "ca-cert.pem" #define KEYF HOME "ca-cert.pem" #define CHK_ERR(err,s) if ((err)==-1) { perror(s); exit(1); } 

इसके बाद, हम पहली बार नामस्थान सर्वर के अंदर CServer और CClient क्लासेस बनाते हैं:

 using namespace std; namespace server { class CClient { //   SOCKET m_hSocket; //        vector<unsigned char> m_vRecvBuffer; //        vector<unsigned char> m_vSendBuffer; //    OpenSSL SSL_CTX* m_pSSLContext; SSL* m_pSSL; //       explicit CClient(const CClient &client) {} public: CClient(const SOCKET hSocket) : m_hSocket(hSocket), m_pSSL(NULL), m_pSSLContext(NULL) {} ~CClient() { if(m_hSocket != INVALID_SOCKET) closesocket(m_hSocket); if (m_pSSL) SSL_free (m_pSSL); if (m_pSSLContext) SSL_CTX_free (m_pSSLContext); } }; class CServer { //      map<SOCKET, shared_ptr<CClient> > m_mapClients; //       explicit CServer(const CServer &server) {} public: CServer() {} }; } #endif 

जैसा कि आप देख सकते हैं, यह हमारे सर्वर के लिए सिर्फ एक रिक्त है। हम इस वर्कपीस को धीरे-धीरे कोड के साथ भरना शुरू करेंगे, जिनमें से अधिकांश पहले से ही पिछले लेख में हैं ।
प्रत्येक क्लाइंट का अपना SSL संदर्भ होता है, यह स्पष्ट है कि आपको CClient वर्ग के कंस्ट्रक्टर में ऐसा करने की आवश्यकता है

  CClient(const SOCKET hSocket) : m_hSocket(hSocket), m_pSSL(NULL), m_pSSLContext(NULL) { #ifdef WIN32 const SSL_METHOD *meth = SSLv23_server_method(); #else SSL_METHOD *meth = SSLv23_server_method(); #endif m_pSSLContext = SSL_CTX_new (meth); if (!m_pSSLContext) ERR_print_errors_fp(stderr); if (SSL_CTX_use_certificate_file(m_pSSLContext, CERTF, SSL_FILETYPE_PEM) <= 0) ERR_print_errors_fp(stderr); if (SSL_CTX_use_PrivateKey_file(m_pSSLContext, KEYF, SSL_FILETYPE_PEM) <= 0) ERR_print_errors_fp(stderr); if (!SSL_CTX_check_private_key(m_pSSLContext)) fprintf(stderr,"Private key does not match the certificate public key\n"); } 

हम लायब्रेरी के आरंभीकरण को हस्तांतरित करेंगे, CServer निर्माता को कम से कम परिवर्तनों के साथ सुनने वाले सॉकेट के निर्माण और बंधन:

  CServer() { #ifdef WIN32 WSADATA wsaData; if ( WSAStartup( MAKEWORD( 2, 2 ), &wsaData ) != 0 ) { printf("Could not to find usable WinSock in WSAStartup\n"); return; } #endif SSL_load_error_strings(); SSLeay_add_ssl_algorithms(); /* ----------------------------------------------- */ /* Prepare TCP socket for receiving connections */ SOCKET listen_sd = socket (AF_INET, SOCK_STREAM, 0); CHK_ERR(listen_sd, "socket"); SET_NONBLOCK(listen_sd); struct sockaddr_in sa_serv; memset (&sa_serv, '\0', sizeof(sa_serv)); sa_serv.sin_family = AF_INET; sa_serv.sin_addr.s_addr = INADDR_ANY; sa_serv.sin_port = htons (1111); /* Server Port number */ int err = ::bind(listen_sd, (struct sockaddr*) &sa_serv, sizeof (sa_serv)); CHK_ERR(err, "bind"); /* Receive a TCP connection. */ err = listen (listen_sd, 5); CHK_ERR(err, "listen"); } 

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

 while(true) { Sleep(1); struct sockaddr_in sa_cli; size_t client_len = sizeof(sa_cli); #ifdef WIN32 const SOCKET sd = accept (listen_sd, (struct sockaddr*) &sa_cli, (int *)&client_len); #else const SOCKET sd = accept (listen_sd, (struct sockaddr*) &sa_cli, &client_len); #endif Callback(sd); } 

और सही निर्माता के बाद, वास्तविक कॉलबैक फ़ंक्शन:

  private: void Callback(const SOCKET hSocket) { if (hSocket != INVALID_SOCKET) m_mapClients[hSocket] = shared_ptr<CClient>(new CClient(hSocket)); //   auto it = m_mapClients.begin(); while (it != m_mapClients.end()) //   { if (!it->second->Continue()) // -   m_mapClients.erase(it++); //   false,    else it++; } } 

यह CServer क्लास कोड पूरा करता है! अन्य सभी आवेदन तर्क CClient वर्ग में होंगे।
यह ध्यान रखना महत्वपूर्ण है कि परियोजनाओं को गति देने के लिए, सभी क्लाइंट को लूप में एन्यूमरेट करने के बजाय, केवल उन क्लाइंट्स को एन्यूमरेट करना आवश्यक है, जिनके सॉकेट पढ़ने या लिखने के लिए तैयार हैं।
यह जानवर बल विंडोज पर चुनिंदा कार्यों के साथ या लिनक्स पर एपोल के साथ करना आसान है। मैं यह दिखाऊंगा कि अगले लेख में यह कैसे करना है,
इस बीच, (फिर से आलोचना में दौड़ने के जोखिम पर), सभी समान, मैं खुद को एक सरल चक्र तक सीमित करूंगा।

हम अपने सर्वर के मुख्य "वर्कहॉर्स" को पास करते हैं: CClient वर्ग को।
CClient क्लास को न केवल अपने सॉकेट के बारे में जानकारी होनी चाहिए, बल्कि सर्वर के साथ उसका इंटरेक्शन किस स्टेज पर है, इसकी भी जानकारी होनी चाहिए।
CClient वर्ग परिभाषा में निम्नलिखित कोड जोड़ें:

  private: //    .     . enum STATES { S_ACCEPTED_TCP, S_ACCEPTED_SSL, S_READING, S_ALL_READED, S_WRITING, S_ALL_WRITED }; STATES m_stateCurrent; //    //      void SetState(const STATES state) {m_stateCurrent = state;} const STATES GetState() const {return m_stateCurrent;} public: //      const bool Continue() { if (m_hSocket == INVALID_SOCKET) return false; switch (GetState()) { case S_ACCEPTED_TCP: break; case S_ACCEPTED_SSL: break; case S_READING: break; case S_ALL_READED: break; case S_WRITING: break; case S_ALL_WRITED: break; default: return false; } return true; } 

यहां जारी है () अभी भी सिर्फ एक स्टब फ़ंक्शन है, थोड़ा कम हम इसे सिखाएंगे कि कैसे एक कनेक्टेड क्लाइंट के साथ सभी क्रियाएं करें।

निर्माता में, बदलें:

 CClient(const SOCKET hSocket) : m_hSocket(hSocket), m_pSSL(NULL), m_pSSLContext(NULL) 

पर

 CClient(const SOCKET hSocket) : m_hSocket(hSocket), m_pSSL(NULL), m_pSSLContext(NULL), m_stateCurrent(S_ACCEPTED_TCP) 

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

तो पहला स्टेट जो क्लाइंट को कंस्ट्रक्टर में बनाए जाने पर मिलता है: S_ACCEPTED_TCP।
हम एक फ़ंक्शन लिखते हैं जिसे क्लाइंट द्वारा तब तक कॉल किया जाएगा जब तक कि उसके पास यह स्थिति न हो:
इस लाइन के लिए:

  case S_ACCEPTED_TCP: break; 

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

  case S_ACCEPTED_TCP: { switch (AcceptSSL()) { case RET_READY: printf ("SSL connection using %s\n", SSL_get_cipher (m_pSSL)); SetState(S_ACCEPTED_SSL); break; case RET_ERROR: return false; } return true; } 

और CClient वर्ग में निम्नलिखित कोड भी जोड़ें:

  private: enum RETCODES { RET_WAIT, RET_READY, RET_ERROR }; const RETCODES AcceptSSL() { if (!m_pSSLContext) //     SSL return RET_ERROR; if (!m_pSSL) { m_pSSL = SSL_new (m_pSSLContext); if (!m_pSSL) return RET_ERROR; SSL_set_fd (m_pSSL, m_hSocket); } const int err = SSL_accept (m_pSSL); const int nCode = SSL_get_error(m_pSSL, err); if ((nCode != SSL_ERROR_WANT_READ) && (nCode != SSL_ERROR_WANT_WRITE)) return RET_READY; return RET_WAIT; } 

अब AcceptSSL () फ़ंक्शन क्लाइंट द्वारा तब तक कॉल किया जाएगा जब तक कि एक एन्क्रिप्टेड कनेक्शन नहीं होता है या कोई त्रुटि उत्पन्न होती है।

1. एक त्रुटि के मामले में, CClient :: AcceptSSL () फ़ंक्शन RET_ERROR कोड को CClient :: Continue () फ़ंक्शन पर कॉल करेगा, जो इस स्थिति में CServer :: कॉल करने वाले फ़ंक्शन को गलत लौटाएगा, जिसने इसे कॉल किया है, जो इस स्थिति में क्लाइंट को सर्वर की मेमोरी से हटा देगा।
2. यदि कनेक्शन सफल होता है, CClient :: AcceptSSL () फ़ंक्शन RET_READY कोड को CClient :: Continue () फ़ंक्शन पर लौटाएगा, जिसने इसे कॉल किया है, जो इस स्थिति में क्लाइंट स्थिति को S_ACCEEDED_SSL में बदल देगा।

अब राज्य प्रसंस्करण फ़ंक्शन S_ACCEPTED_SSL जोड़ें। इस लाइन के लिए

 case S_ACCEPTED_SSL: break; 

निम्नलिखित के लिए ठीक करें:

  case S_ACCEPTED_SSL: { switch (GetSertificate()) { case RET_READY: SetState(S_READING); break; case RET_ERROR: return false; } return true; } 

और CClient में एक फ़ंक्शन जोड़ें:

  const RETCODES GetSertificate() { if (!m_pSSLContext || !m_pSSL) //     SSL return RET_ERROR; /* Get client's certificate (note: beware of dynamic allocation) - opt */ X509* client_cert = SSL_get_peer_certificate (m_pSSL); if (client_cert != NULL) { printf ("Client certificate:\n"); char* str = X509_NAME_oneline (X509_get_subject_name (client_cert), 0, 0); if (!str) return RET_ERROR; printf ("\t subject: %s\n", str); OPENSSL_free (str); str = X509_NAME_oneline (X509_get_issuer_name (client_cert), 0, 0); if (!str) return RET_ERROR; printf ("\t issuer: %s\n", str); OPENSSL_free (str); /* We could do all sorts of certificate verification stuff here before deallocating the certificate. */ X509_free (client_cert); } else printf ("Client does not have certificate.\n"); return RET_READY; } 

यह फ़ंक्शन, पिछले एक के विपरीत, केवल एक बार कॉल किया जाएगा और RET_ERROR या RET_READY को CClient :: Continue पर लौटाएगा। तदनुसार, CClient :: जारी या तो गलत हो जाएगा या क्लाइंट की स्थिति को S_READING पर बदल देगा।

फिर सब कुछ समान है: कोड बदलें

  case S_READING: break; case S_ALL_READED: break; case S_WRITING: break; 

इस पर:

  case S_READING: { switch (ContinueRead()) { case RET_READY: SetState(S_ALL_READED); break; case RET_ERROR: return false; } return true; } case S_ALL_READED: { switch (InitRead()) { case RET_READY: SetState(S_WRITING); break; case RET_ERROR: return false; } return true; } case S_WRITING: { switch (ContinueWrite()) { case RET_READY: SetState(S_ALL_WRITED); break; case RET_ERROR: return false; } return true; } 

और इसी राज्य प्रसंस्करण कार्यों को जोड़ने:

  const RETCODES ContinueRead() { if (!m_pSSLContext || !m_pSSL) //     SSL return RET_ERROR; unsigned char szBuffer[4096]; const int err = SSL_read (m_pSSL, szBuffer, 4096); //      if (err > 0) { //     m_vRecvBuffer m_vRecvBuffer.resize(m_vRecvBuffer.size()+err); memcpy(&m_vRecvBuffer[m_vRecvBuffer.size()-err], szBuffer, err); //  http     const std::string strInputString((const char *)&m_vRecvBuffer[0]); if (strInputString.find("\r\n\r\n") != -1) return RET_READY; return RET_WAIT; } const int nCode = SSL_get_error(m_pSSL, err); if ((nCode != SSL_ERROR_WANT_READ) && (nCode != SSL_ERROR_WANT_WRITE)) return RET_ERROR; return RET_WAIT; } const RETCODES InitRead() { if (!m_pSSLContext || !m_pSSL) //     SSL return RET_ERROR; //      const std::string strInputString((const char *)&m_vRecvBuffer[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(); // ,    m_vSendBuffer.resize(strStream.str().length()); memcpy(&m_vSendBuffer[0], strStream.str().c_str(), strStream.str().length()); return RET_READY; } const RETCODES ContinueWrite() { if (!m_pSSLContext || !m_pSSL) //     SSL return RET_ERROR; int err = SSL_write (m_pSSL, &m_vSendBuffer[0], m_vSendBuffer.size()); if (err > 0) { //    ,      if (err == m_vSendBuffer.size()) return RET_READY; //    ,      ,     vector<unsigned char> vTemp(m_vSendBuffer.size()-err); memcpy(&vTemp[0], &m_vSendBuffer[err], m_vSendBuffer.size()-err); m_vSendBuffer = vTemp; return RET_WAIT; } const int nCode = SSL_get_error(m_pSSL, err); if ((nCode != SSL_ERROR_WANT_READ) && (nCode != SSL_ERROR_WANT_WRITE)) return RET_ERROR; return RET_WAIT; } 

हमारा सर्वर अब तक केवल क्लाइंट को उसके http अनुरोध के शीर्ष लेख दिखाने के लिए है।
सर्वर ने अपने उद्देश्य को पूरा करने के बाद, यह कनेक्शन बंद कर सकता है और क्लाइंट के बारे में भूल सकता है।
इसलिए, अंतिम छोटा परिवर्तन हमारे कोड में रहता है:

 case S_ALL_WRITED: break; 

ठीक करने की जरूरत है

  case S_ALL_WRITED: return false; 

वह सब है! अब हमारे पास नॉन-ब्लॉकिंग सॉकेट्स पर एक क्रॉस-प्लेटफ़ॉर्म सिंगल-थ्रेडेड https सर्वर है, जो कनेक्शन की एक मनमानी (केवल मेमोरी और ऑपरेटिंग सिस्टम सेटिंग्स द्वारा सीमित) को संभाल सकता है।

विज़ुअल स्टूडियो 2012 के लिए प्रोजेक्ट के साथ संग्रह यहां डाउनलोड किया जा सकता है: 01.3s3s.org
लिनक्स पर संकलित करने के लिए, आपको फ़ाइलों को एक निर्देशिका में कॉपी करने की आवश्यकता है: serv.cpp, server.h, ca-cert.pem और कमांड लाइन में टाइप करें: "g ++ -std = c ++ 0x -L / usr / lib -lssl -lcrypto सर्व" .cpp »

विस्तार