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

यह लेख मेरे पिछले वाले जारी रखते हैं:
Ssl समर्थन के साथ सबसे सरल क्रॉस-प्लेटफ़ॉर्म सर्वर
गैर-अवरुद्ध सॉकेट्स के साथ क्रॉस-प्लेटफ़ॉर्म https सर्वर
गैर-अवरुद्ध सॉकेट्स के साथ क्रॉस-प्लेटफ़ॉर्म https सर्वर। भाग २
गैर-अवरुद्ध सॉकेट्स के साथ क्रॉस-प्लेटफ़ॉर्म https सर्वर। भाग ३

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


1. मैंने std :: cout के पक्ष में प्रिंटफ फ़ंक्शन से छुटकारा पाने के लिए युक्तियां सुनीं।
2. स्मार्ट लोगों ने मुझे साबित किया है कि std :: memcpy और std :: कॉपी कंपाइलर के लिए समान हैं।
मेमसीपी मेरे लिए अधिक सुविधाजनक है, इसलिए मैं इसका उपयोग करना जारी रखूंगा।
3. मैंने पहले की सभी रिलीज़ों को स्थानांतरित कर दिया है और भविष्य के लोगों को GitHub में स्थानांतरित किया जाएगा , हालांकि उनके लिए विंडोज क्लाइंट, मेरी राय में, भयानक है।
4. कौन मानता है कि लाइनें

const char on = 1; setsockopt(listen_sd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) ); 

सर्वर के एक आपातकालीन पुनरारंभ के दौरान "पता पहले से ही उपयोग में त्रुटि" से बचने में मदद करें - वे गंभीर रूप से गलत हैं। वे मदद नहीं करेंगे।
5. उन लोगों के लिए जो मानते हैं कि विभिन्न वर्गों को हमेशा अलग-अलग फ़ाइलों में वितरित किया जाना चाहिए, कुछ तेल जोड़ें: मैं CClient वर्ग को CServer वर्ग के निजी अनुभाग में स्थानांतरित करना चाहता हूं!

यह था:

 CClient { *** }; CServer { *** }; 

यह बन गया:

 CServer { CClient { *** }; *** }; 

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

6. और मेरी राय में, मुख्य () फ़ंक्शन एसआई प्रोग्रामर द्वारा विरासत में मिला एक नास्तिकता है। C ++ में, यह शानदार है। लेकिन दुर्भाग्य से, कंपाइलरों को अभी तक यह पता नहीं है।
लेकिन मैंने इस अनावश्यक समारोह को "दंडित" करने का फैसला किया, कुछ करने की क्षमता से दूर ले जाकर - मैंने फ़ाइल को बदल दिया।

 #include "server.h" const server::CServer s(8085, 1111); int main() {return 0;} 

अब मुख्य बात के बारे में ...

समर्थन सर्वर पर अनएन्क्रिप्टेड tcp कनेक्शन जोड़ना

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

के बदले

 struct epoll_event m_ListenEvent; 

सर्वर वर्ग में लिखें

 struct epoll_event m_ListenEventTCP, m_ListenEventSSL; 

सर्वर कंस्ट्रक्टर में, लिनक्स के लिए पोर्ट नंबर और कोड जोड़ें, जो टीसीपी पोर्टल में त्रुटि के मामले में सर्वर को क्रैश करने की अनुमति नहीं देगा:

  CServer(const int nPortTCP, const int nPortSSL) { #ifndef WIN32 struct sigaction sa; memset(&sa, 0, sizeof(sa)); sa.sa_handler = SIG_IGN; sigaction(SIGPIPE, &sa, NULL); #else WSADATA wsaData; if ( WSAStartup( MAKEWORD( 2, 2 ), &wsaData ) != 0 ) { cout << "Could not to find usable WinSock in WSAStartup\n"; return; } #endif 

हम सुनने के सॉकेट आरंभ करने और एक नए ग्राहक को जोड़ने के लिए अलग-अलग कार्य लिखेंगे:

  private: void InitListenSocket(const int nPort, struct epoll_event &eventListen) { SOCKET listen_sd = socket (AF_INET, SOCK_STREAM, 0); SET_NONBLOCK(listen_sd); const char on = 1; setsockopt(listen_sd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) ); 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 (nPort); /* Server Port number */ int err = ::bind(listen_sd, (struct sockaddr*) &sa_serv, sizeof (sa_serv)); if (err == -1) { cout << "bind error = " << errno << "\n"; return; } /* Receive a TCP connection. */ err = listen (listen_sd, SOMAXCONN); eventListen.data.fd = listen_sd; eventListen.events = EPOLLIN | EPOLLET; epoll_ctl (m_epoll, EPOLL_CTL_ADD, listen_sd, &eventListen); } void AcceptClient(const SOCKET hSocketIn, const bool bIsSSL) { cout << "AcceptClient"; struct sockaddr_in sa_cli; size_t client_len = sizeof(sa_cli); #ifdef WIN32 const SOCKET sd = accept (hSocketIn, (struct sockaddr*) &sa_cli, (int *)&client_len); #else const SOCKET sd = accept (hSocketIn, (struct sockaddr*) &sa_cli, (socklen_t *)&client_len); #endif if (sd != INVALID_SOCKET) { cout << "Accepted\n"; //      m_mapClients[sd] = shared_ptr<CClient>(new CClient(sd, bIsSSL)); auto it = m_mapClients.find(sd); if (it == m_mapClients.end()) return; //    epoll struct epoll_event ev = it->second->GetEvent(); epoll_ctl (m_epoll, EPOLL_CTL_ADD, it->first, &ev); } } 

अब क्लाइंट में हम वैरिएबल m_bIsSSL को जोड़ते हैं, जिसे हम कंस्ट्रक्टर में शुरू करेंगे, और फिर कॉलबैक फ़ंक्शन को बदलेंगे ताकि वे टीसीपी कनेक्शन के साथ काम कर सकें:
के बदले

  const RETCODES AcceptSSL() { if (!m_pSSLContext) //     SSL return RET_ERROR; 

अब यह होगा:

  const RETCODES AcceptSSL() { cout << "AcceptSSL\n"; if (!m_bIsSSL) return RET_READY; if (!m_pSSLContext) return RET_ERROR; 

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

  const RETCODES GetSertificate() { cout << "GetSertificate\n"; if (!m_bIsSSL) return RET_READY; 

किसी फ़ंक्शन में क्लाइंट से डेटा पढ़ता है, इसके बजाय ContinueRead () की आवश्यकता है

  unsigned char szBuffer[4096]; const int err = SSL_read (m_pSSL, szBuffer, 4096); //      

कोड लिखें:

  static char szBuffer[4096]; //      int err; if (m_bIsSSL) err = SSL_read (m_pSSL, szBuffer, 4096); else { errno = 0; err = recv(m_hSocket, szBuffer, 4096, 0); } m_nLastSocketError = GetLastError(err); 

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

 #ifndef _WIN32 #define S_OK 0 #define WSAEWOULDBLOCK EWOULDBLOCK #define WSAGetLastError() errno #endif 

और ContinueRead फ़ंक्शन में ऐसा कोड:

  if (!m_bIsSSL) { if ((err == 0) || ((m_nLastSocketError != WSAEWOULDBLOCK) && (m_nLastSocketError != S_OK))) return RET_ERROR; } else { if ((err == 0) || ((m_nLastSocketError != SSL_ERROR_WANT_READ) && (m_nLastSocketError != SSL_ERROR_WANT_WRITE))) return RET_ERROR; } 

और CClient :: GetLastError फ़ंक्शन हम निम्नानुसार परिभाषित करते हैं

  private: int GetLastError(int err) const { if (m_bIsSSL) return SSL_get_error(m_pSSL, err); else return WSAGetLastError(); } 

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

Sendfile फ़ंक्शन का अनुकरण करें

1. खाली फाइलें "sendfile.h", "sendfile.cpp" बनाएं और उन्हें विजुअल स्टूडियो प्रोजेक्ट में जोड़ें।
2. sendfile.h में हम निम्नलिखित कोड डालते हैं:

 #ifndef __linux__ #ifndef _SENDFILE_H #define _SENDFILE_H #include <sys/types.h> unsigned long long sendfile(int out_fd, int in_fd, off_t *offset, size_t count); #endif #endif 

3. sendfile.cpp में, इसे डालें:

 #include <io.h> #include <Winsock2.h> #pragma comment(lib, "ws2_32.lib") #endif unsigned long long sendfile(int out_fd, int in_fd, off_t *offset, size_t count) { static unsigned char buffer[4096]; if (count > 4096) count = 4096; off_t lPos = _lseek(in_fd, *offset, SEEK_SET); if (lPos == -1) return -1; const int nReaded = _read(in_fd, buffer, count); if (nReaded == 0) return nReaded; if (nReaded == -1) return -1; *offset += nReaded; errno = 0; const int nSended = send(out_fd, (const char *)buffer, nReaded, 0); if (nSended != SOCKET_ERROR) return nSended; if (WSAGetLastError() != WSAEWOULDBLOCK) return -1; return 0; } #endif 

4. सर्वर वर्ग में आवश्यक समावेशन जोड़ें ताकि लिनक्स में मानक कार्यों का उपयोग किया जाता है, और हमारा उपयोग अन्य प्रणालियों में किया जाता है।
इसके अलावा, हम फ़ाइलों के साथ काम करने के लिए एक समावेशन जोड़ते हैं और उस फ़ाइल का पथ निर्धारित करते हैं जिसे हम क्लाइंट को भेजेंगे:

 #ifdef __linux__ #include <sys/epoll.h> #include <sys/sendfile.h> #define O_BINARY 0 #else #include "epoll.h" #include "sendfile.h" #endif #include <sys/stat.h> #define SEND_FILE "./wwwroot/festooningloops.jpg" 

अनुकरण भेजने के साथ समाप्त हो गया।

फ़ाइल भेजें

5. ग्राहक वर्ग में एक फ़ाइल डिस्क्रिप्टर और वर्तमान स्थिति जोड़ें

  class CClient { int m_nSendFile; off_t m_nFilePos; unsigned long long m_nFileSize; 

6. InitRead फ़ंक्शन बदलें ()

  const RETCODES InitRead() { if (m_bIsSSL && (!m_pSSLContext || !m_pSSL)) return RET_ERROR; m_nSendFile = _open(SEND_FILE, O_RDONLY|O_BINARY); if (m_nSendFile == -1) return RET_ERROR; struct stat stat_buf; if (fstat(m_nSendFile, &stat_buf) == -1) return RET_ERROR; m_nFileSize = stat_buf.st_size; //    http  std::ostringstream strStream; strStream << "HTTP/1.1 200 OK\r\n" << "Content-Type: image/jpeg\r\n" << "Content-Length: " << m_nFileSize << "\r\n" << "\r\n"; //  m_vSendBuffer.resize(strStream.str().length()); memcpy(&m_vSendBuffer[0], strStream.str().c_str(), strStream.str().length()); return RET_READY; } 

7. tcp और ssl प्रोटोकॉल का उपयोग करके फ़ाइल भेजने के लिए फ़ंक्शन जोड़ें:

  const RETCODES SendFileSSL(const int nFile, off_t *offset) { if (nFile == -1 || m_vSendBuffer.size()) return ContinueWrite(); if (!m_bIsSSL || !m_pSSLContext || !m_pSSL) return RET_ERROR; static unsigned char buffer[4096]; off_t lPos = _lseek(nFile, *offset, SEEK_SET); if (lPos == -1) return RET_ERROR; const int nReaded = _read(nFile, buffer, 4096); if (nReaded == -1) return RET_ERROR; if (nReaded > 0) { *offset += nReaded; m_vSendBuffer.resize(nReaded); memcpy(&m_vSendBuffer[0], buffer, nReaded); } return RET_WAIT; } const RETCODES SendFileTCP(const int nFile, off_t *offset) { if (nFile == -1 || m_vSendBuffer.size()) return ContinueWrite(); const unsigned long long nSended = sendfile(m_hSocket, nFile, offset, 4096); if (nSended == (unsigned long long)-1) return RET_ERROR; m_nLastSocketError = WSAEWOULDBLOCK; return RET_WAIT; } const bool IsAllWrited() const { if (m_nSendFile == -1 && m_vSendBuffer.size()) return true; if (m_nFileSize == (unsigned long long)m_nFilePos) return true; return false; } 

8. ग्राहक के कॉलबैक फ़ंक्शन का तर्क बदलें:

  case S_WRITING: { if (!m_bIsSSL && (SendFileTCP(m_nSendFile, &m_nFilePos) == RET_ERROR)) return false; else if (m_bIsSSL && (SendFileSSL(m_nSendFile, &m_nFilePos) == RET_ERROR)) return false; if (IsAllWrited()) SetState(S_ALL_WRITED, pCurrentEvent); return true; } 

हमारा सर्वर तैयार है!
अब वह न केवल बफर भेज सकता है, बल्कि फाइलें भी भेज सकता है। शायद किसी ने देखा कि क्लाइंट वर्ग में "m_nLastSocketError" चर जोड़ा गया था ...
तथ्य यह है कि सर्वर के पिछले संस्करणों में हमने हमेशा सॉकेट्स से किसी भी ईवेंट की अपेक्षा की थी, अब m_nLastSocketError वैरिएबल हमें CClient :: SetState फ़ंक्शन को संशोधित करने में मदद करेगा ताकि एपोल फ़ंक्शन
वर्तमान में आवश्यक घटनाओं के लिए इंतजार कर रहे सॉकेट्स से।

  void SetState(const STATES state, struct epoll_event *pCurrentEvent) { m_stateCurrent = state; pCurrentEvent->events = EPOLLERR | EPOLLHUP; if (m_bIsSSL) { if (m_nLastSocketError == SSL_ERROR_WANT_READ) pCurrentEvent->events |= EPOLLIN; if (m_nLastSocketError == SSL_ERROR_WANT_WRITE) pCurrentEvent->events |= EPOLLOUT; return; } if (m_nLastSocketError == WSAEWOULDBLOCK) { if (m_stateCurrent == S_READING) pCurrentEvent->events |= EPOLLIN; if (m_stateCurrent == S_WRITING) pCurrentEvent->events |= EPOLLOUT; return; } pCurrentEvent->events |= EPOLLIN | EPOLLOUT; } 

सब कुछ तैयार है!
Visual Studio 2012 में संकलित करने के लिए , ssl_test.sln फ़ाइल खोलें और संकलित करें।
लिनक्स पर संकलित करने के लिए, फ़ाइलें epoll.h, epoll.cpp, sendfile.h और sendfile.cpp की जरूरत नहीं है , ताकि सब कुछ काम करे, बस फाइलों को उसी निर्देशिका में कॉपी करें: serv.cpp, server.h, ca-cert.pem, wwwroot निर्देशिका बनाएं और वहां ./wwwroot/festooningloops.jpg फ़ाइल की प्रतिलिपि बनाएँ, फिर कमांड प्रॉम्प्ट पर टाइप करें: "g ++ -std = c ++ 0x -L / usr / lib -lssl -lcrypto servpp" जो किसी कारण से संकलक चेतावनी देखना चाहता है, -Wall ऑप्शन को इसमें जोड़ें।

आप सर्वर को शुरू करने और ब्राउज़र के एड्रेस बार में टाइप करके स्थानीय कंप्यूटर पर सर्वर की जांच कर सकते हैं
localhost:1111
या
localhost:8085