httpserver/src/Server.h at master · hibecki/httpserver · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#pragma once

#include "SocketList.h"
#include "DataVariantAbstract.h"
#include "ServerApplicationsTree.h"
#include "ServerApplicationDefaultSettings.h"
#include "Module.h"
#include "Event.h"
#include "SocketAdapter.h"
#include "ServerStructuresArguments.h"

#include <cstddef>
#include <memory>
#include <vector>
#include <queue>
#include <csignal>
#include <atomic>

#include <gnutls/gnutls.h>

namespace HttpServer
{
	class Server
	{
	protected:
		std::unordered_map<std::string, DataVariantAbstract *> variants;

		std::unordered_map<std::string, std::string> settings;
		std::unordered_map<std::string, std::string> mimes_types;

		std::unordered_map<int, std::tuple<gnutls_certificate_credentials_t, gnutls_priority_t> > tls_data;

		std::vector<Module> modules;

		ServerApplicationsTree apps_tree;

		std::vector<Socket> server_sockets;

		Event *eventNotFullQueue;
		Event *eventProcessQueue;
		Event *eventUpdateModule;

		mutable std::atomic_size_t threads_working_count;
		mutable std::mutex sockets_queue_mtx;

		// Флаг, означающий - активированы ли главные циклы сервера
		// (с помощью этого флага можно деактивировать циклы, чтобы завершить работу сервера)
		sig_atomic_t process_flag;
		sig_atomic_t restart_flag;

	protected:
		static const int CONNECTION_CLOSED = 0;
		static const int CONNECTION_KEEP_ALIVE = 1;
		static const int CONNECTION_UPGRADE = 2;

	protected:
		int cycleQueue(std::queue<std::tuple<Socket, struct sockaddr_in > > &sockets);

		int threadRequestProc(SocketAdapter &clientSocket, const struct sockaddr_in &clientAddr) const;

		static bool getRequest(const SocketAdapter &clientSocket, std::vector<char> &buf, std::string &str_buf, struct request_parameters &rp);

		int getRequestHeaders(std::string &str_buf, struct request_parameters &rp) const;

		static void runApplication(const SocketAdapter &clientSocket, const ServerApplicationSettings &appSets, struct request_parameters &rp);

		int getRequestData(const SocketAdapter &clientSocket, std::string &str_buf, const ServerApplicationSettings &appSets, struct request_parameters &rp) const;

		const ServerApplicationSettings *getApplicationSettings(const struct request_parameters &rp) const;

		static void getConnectionParams(struct request_parameters &rp);

		void xSendfile(const SocketAdapter &clientSocket, struct request_parameters &rp) const;

		static bool isConnectionKeepAlive(const struct request_parameters &rp);
		static bool isConnectionUpgrade(const struct request_parameters &rp);

		void threadRequestCycle(std::queue<std::tuple<Socket, struct sockaddr_in> > &sockets, Event &eventThreadCycle) const;

		std::string getMimeTypeByFileName(const std::string &fileName) const;

		std::vector<std::tuple<size_t, size_t> > getRanges(
			const std::string &rangeHeader,
			const size_t posSymEqual,
			const size_t fileSize,
			std::string &resultRangeHeader,
			size_t &contentLength
		) const;

		int transferFilePart(
			const SocketAdapter &clientSocket,
			const std::chrono::milliseconds &timeout,
			const std::string &fileName,
			const time_t fileTime,
			const size_t fileSize,
			const std::string &rangeHeader,
			const std::string &connectionHeader,
			const std::string &dateHeader,
			const bool headersOnly
		) const;

		int transferFile(
			const SocketAdapter &clientSocket,
			const std::string &fileName,
			const std::string &connectionHeader,
			const bool headersOnly,
			struct request_parameters &rp
		) const;

		static bool parseIncomingVars(std::unordered_multimap<std::string, std::string> &params, const std::string &uriParams);
		static void sendStatus(const SocketAdapter &clientSocket, const std::chrono::milliseconds &timeout, const size_t statusCode);

		static bool tlsInit(const ServerApplicationSettings &app, std::tuple<gnutls_certificate_credentials_t, gnutls_priority_t> &data);

		bool tryBindPort(const int port, std::unordered_set<int> &ports);
		void initAppsPorts();

		bool init();
		int run();
		void clear();

		static System::native_processid_type getServerProcessId(const std::string &serverName);

		void updateModules();
		bool updateModule(Module &module, std::unordered_set<ServerApplicationSettings *> &applications, const size_t moduleIndex);

	private:
		void addDataVariant(DataVariantAbstract *dataVariant);

		static bool get_start_args(const int argc, const char *argv[], struct server_start_args *st);

	public:
		Server();
		~Server() = default;

		void stopProcess();
		void unsetProcess();
		void setRestart();
		void setUpdateModule();
		void setProcessQueue();

		int command_help(const int argc, const char *argv[]) const;
		int command_start(const int argc, const char *argv[]);
		int command_restart(const int argc, const char *argv[]) const;
		int command_terminate(const int argc, const char *argv[]) const;
		int command_update_module(const int argc, const char *argv[]) const;
	};
};