Кроссплатформенный https сервер с неблокирующими сокетами. Часть 2

Эта статья является продолжением статей:
Простейший кросcплатформенный сервер с поддержкой ssl
Кроссплатформенный https сервер с неблокирующими сокетами
В этих статьях я постепенно из простенького примера, входящего в состав OpenSSL стараюсь сделать полноценный однопоточный веб-сервер.
В предыдущей статье я «научил» сервер принимать соединение от одного клиента и отсылать обратно html страницу с заголовками запроса.
Сегодня я исправлю код сервера так, чтобы он мог обрабатывать соединения от произвольного количества клиентов в одном потоке.

Для начала я разобью код на два файла: serv.cpp и server.h
При этом файл serv.cpp будет содержать такой вот «высокоинтелектуальный» код:

#include "server.h"

int main()
{
	server::CServer();
	return 0;
}

Да, можете пинать меня ногами, но я все равно писал, пишу и буду писать код в заголовочных файлах если мне это удобно. За то я собственно и люблю с++, что он дает свободу выбора, но это отдельный разговор…

Переходим к файлу 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=%in", 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 внутри namespace server:

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 keyn");
		}

Инициализацию библиотек, создание и привязку слушающего сокета перенесем с минимальными изменениями в конструктор CServer:

		CServer()
		{
#ifdef WIN32
			WSADATA wsaData;
			if ( WSAStartup( MAKEWORD( 2, 2 ), &wsaData ) != 0 )
			{
				printf("Could not to find usable WinSock in WSAStartupn");
				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, '', 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");
		}

Дальше в этом же конструкторе я предлагаю принимать входящие TCP соединения.
Мне никто до сих пор не привел ни одного аргумента против, поэтому слушать TCP соединения мы будем в бесконечном цикле, как и в предыдущей статье.
После каждого вызова accept мы можем что-нибудь сделать с вновь подключившимся и с уже подключенными клиентами, вызвав callback функцию.
Добавим в конструктор CServer после функции listen код:

			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);
			}

А сразу после конструктора, собственно callback функцию:

	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.
Важно заметить, что для критичных к скорости проектов, вместо перебора всех клиентов в цикле, надо перебирать только тех клиентов, чьи сокеты готовы для чтения или записи.
Сделать этот перебор легко с помощью функций select в Windows или epoll в Linux. Я покажу как это делается в следующей статье,
А пока (рискуя опять нарваться на критику) все таки ограничусь простым циклом.

Переходим к основной «рабочей лошадке» нашего сервера: к классу 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;
		}

Здесь Continue() это пока только функция-заглушка, чуть ниже мы ее научим выполнять все действия с подключенным клиентом.

В конструкторе изменим:

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)

В зависимости от текущего состояния, клиент вызывает разные функции. Договоримся, что состояния клиента можно менять только в конструкторе и в функции Continue(), это немного увеличит размер кода, но зато сильно облегчит его отладку.

Итак первое состояние, которое клиент получает при создании в конструкторе: S_ACCEPTED_TCP.
Напишем функцию, которая будет вызываться клиентом до тех пор, пока у него это состояние:
Для этого строки:

				case S_ACCEPTED_TCP:
					break;

изменим на следующие:

				case S_ACCEPTED_TCP:
				{
					switch (AcceptSSL())
					{
						case RET_READY:
							printf ("SSL connection using %sn", 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(), которая в этом случае вернет false вызвавшей ее функции CServer::Callback, которая в этом случае удалит клиента из памяти сервера.
2. В случае удачного подключения функция CClient::AcceptSSL() вернет код RET_READY в вызвавшую ее функцию CClient::Continue(), которая в этом случае изменит состояние клиента на S_ACCEPTED_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: %sn", str);
				OPENSSL_free (str);
    
				str = X509_NAME_oneline (X509_get_issuer_name  (client_cert), 0, 0);
				if (!str)
					return RET_ERROR;

				printf ("t issuer: %sn", 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;
		}

Эта функция, в отличие от предыдущей, вызовется всего один раз и вернет в CClient::Continue либо RET_ERROR либо RET_READY. Соответственно CClient::Continue вернет либо false, либо изменит состояние клиента на 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("rnrn") != -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("rnrn")) + 
				  "</pre></body></html>";

			//Добавляем в начало ответа http заголовок
 			std::ostringstream strStream;
			strStream << 
					"HTTP/1.1 200 OKrn"
					<< "Content-Type: text/html; charset=utf-8rn"
					<< "Content-Length: " << strHTML.length() << "rn" <<
					"rn" <<
					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 сервер на неблокирующих сокетах, который может обрабатывать произвольное (ограниченное лишь памятью и настройками операционной системы) количество соединений.

Архив с проектом для Visual Studio 2012 можно скачать здесь: 00.3s3s.org
Чтобы скомпилировать в Linux надо скопировать в одну директорию файлы: serv.cpp, server.h, ca-cert.pem и в командной строке набрать: «g++ -std=c++0x -L/usr/lib -lssl -lcrypto serv.cpp»

Автор: 3s3s

Источник