libhttpserver/src/httpserver/http_utils.hpp at master · BeardOverflow/libhttpserver · GitHub

History

408 lines (349 loc) · 13.5 KB

Raw

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

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

This file is part of libhttpserver

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301

USA

#if !defined (_HTTPSERVER_HPP_INSIDE_) && !defined (HTTPSERVER_COMPILATION)

#error "Only <httpserver.hpp> or <httpserverpp> can be included directly."

#endif

#ifndef SRC_HTTPSERVER_HTTP_UTILS_HPP_

#define SRC_HTTPSERVER_HTTP_UTILS_HPP_

#ifdef HAVE_GNUTLS

#include <gnutls/gnutls.h>

#endif

// needed to force Vista as a bare minimum to have inet_ntop (libmicro defines

// this to include XP support as a lower version).

#if defined(__MINGW32__) || defined(__CYGWIN32__)

#define _WINDOWS

#undef _WIN32_WINNT

#define _WIN32_WINNT 0x600

#endif

// needed to have the fd_set definition ahead of microhttpd.h import

#if defined(__CYGWIN__)

#include <sys/select.h>

#endif

#include <microhttpd.h>

#include <stddef.h>

#if !defined(__MINGW32__)

#include <sys/socket.h>

#endif

#include <algorithm>

#include <cctype>

#include <iosfwd>

#include <map>

#include <string>

#include <vector>

#include "httpserver/http_arg_value.hpp"

#define DEFAULT_MASK_VALUE 0xFFFF

#if MHD_VERSION < 0x00097002

typedef int MHD_Result;

#endif

namespace httpserver {

enum file_upload_target_T {

FILE_UPLOAD_MEMORY_ONLY,

FILE_UPLOAD_DISK_ONLY,

FILE_UPLOAD_MEMORY_AND_DISK,

};

typedef void(*unescaper_ptr)(std::string&);

namespace http {

struct generateFilenameException : public std::exception {

public:

explicit generateFilenameException(const std::string& message) noexcept : error_message(message) {

}

const char* what() const noexcept {

return error_message.c_str();

}

private:

std::string error_message;

};

class http_utils {

public:

enum cred_type_T {

NONE = -1

#ifdef HAVE_GNUTLS

, CERTIFICATE = GNUTLS_CRD_CERTIFICATE,

ANON = GNUTLS_CRD_ANON,

SRP = GNUTLS_CRD_SRP,

PSK = GNUTLS_CRD_PSK,

IA = GNUTLS_CRD_IA

#endif

};

enum start_method_T {

INTERNAL_SELECT = MHD_USE_SELECT_INTERNALLY | MHD_USE_AUTO,

THREAD_PER_CONNECTION = MHD_USE_THREAD_PER_CONNECTION | MHD_USE_AUTO

};

enum policy_T {

ACCEPT,

REJECT

};

enum IP_version_T {

IPV4 = 4,

IPV6 = 16

};

static const uint16_t http_method_connect_code;

static const uint16_t http_method_delete_code;

static const uint16_t http_method_get_code;

static const uint16_t http_method_head_code;

static const uint16_t http_method_options_code;

static const uint16_t http_method_post_code;

static const uint16_t http_method_put_code;

static const uint16_t http_method_trace_code;

static const uint16_t http_method_patch_code;

static const uint16_t http_method_unknown_code;

static const int http_continue;

static const int http_switching_protocol;

static const int http_processing;

static const int http_ok;

static const int http_created;

static const int http_accepted;

static const int http_non_authoritative_information;

static const int http_no_content;

static const int http_reset_content;

static const int http_partial_content;

static const int http_multi_status;

static const int http_multiple_choices;

static const int http_moved_permanently;

static const int http_found;

static const int http_see_other;

static const int http_not_modified;

static const int http_use_proxy;

static const int http_switch_proxy;

static const int http_temporary_redirect;

static const int http_bad_request;

static const int http_unauthorized;

static const int http_payment_required;

static const int http_forbidden;

static const int http_not_found;

static const int http_method_not_allowed;

static const int http_method_not_acceptable;

static const int http_proxy_authentication_required;

static const int http_request_timeout;

static const int http_conflict;

static const int http_gone;

static const int http_length_required;

static const int http_precondition_failed;

static const int http_request_entity_too_large;

static const int http_request_uri_too_long;

static const int http_unsupported_media_type;

static const int http_requested_range_not_satisfiable;

static const int http_expectation_failed;

static const int http_unprocessable_entity;

static const int http_locked;

static const int http_failed_dependency;

static const int http_upgrade_required;

static const int http_retry_with;

static const int http_internal_server_error;

static const int http_not_implemented;

static const int http_bad_gateway;

static const int http_service_unavailable;

static const int http_gateway_timeout;

static const int http_version_not_supported;

static const int http_variant_also_negotiated;

static const int http_insufficient_storage;

static const int http_bandwidth_limit_exceeded;

static const int http_not_extended;

static const int shoutcast_response;

// See also: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html

static const char* http_header_accept;

static const char* http_header_accept_charset;

static const char* http_header_accept_encoding;

static const char* http_header_accept_language;

static const char* http_header_accept_ranges;

static const char* http_header_age;

static const char* http_header_allow;

static const char* http_header_authorization;

static const char* http_header_cache_control;

static const char* http_header_connection;

static const char* http_header_content_encoding;

static const char* http_header_content_language;

static const char* http_header_content_length;

static const char* http_header_content_location;

static const char* http_header_content_md5;

static const char* http_header_content_range;

static const char* http_header_content_type;

static const char* http_header_date;

static const char* http_header_etag;

static const char* http_header_expect;

static const char* http_header_expires;

static const char* http_header_from;

static const char* http_header_host;

static const char* http_header_if_match;

static const char* http_header_if_modified_since;

static const char* http_header_if_none_match;

static const char* http_header_if_range;

static const char* http_header_if_unmodified_since;

static const char* http_header_last_modified;

static const char* http_header_location;

static const char* http_header_max_forwards;

static const char* http_header_pragma;

static const char* http_header_proxy_authenticate;

static const char* http_header_proxy_authentication;

static const char* http_header_range;

static const char* http_header_referer;

static const char* http_header_retry_after;

static const char* http_header_server;

static const char* http_header_te;

static const char* http_header_trailer;

static const char* http_header_transfer_encoding;

static const char* http_header_upgrade;

static const char* http_header_user_agent;

static const char* http_header_vary;

static const char* http_header_via;

static const char* http_header_warning;

static const char* http_header_www_authenticate;

static const char* http_version_1_0;

static const char* http_version_1_1;

static const char* http_method_connect;

static const char* http_method_delete;

static const char* http_method_head;

static const char* http_method_get;

static const char* http_method_options;

static const char* http_method_post;

static const char* http_method_put;

static const char* http_method_trace;

static const char* http_method_patch;

static const char* http_post_encoding_form_urlencoded;

static const char* http_post_encoding_multipart_formdata;

static const char* application_octet_stream;

static const char* text_plain;

static const char* upload_filename_template;

static const char path_separator;

static std::vector<std::string> tokenize_url(const std::string&, const char separator = '/');

static std::string standardize_url(const std::string&);

static const std::string generate_random_upload_filename(const std::string& directory);

};

#define COMPARATOR(x, y, op) { \

size_t l1 = (x).size(); \

size_t l2 = (y).size(); \

if (l1 < l2) return true; \

if (l1 > l2) return false; \

for (size_t n = 0; n < l1; n++) { \

int xc = op((x)[n]); \

int yc = op((y)[n]); \

if (xc < yc) return true; \

if (xc > yc) return false; \

} \

return false; \

}

class header_comparator {

public:

/**

* Operator used to compare strings.

* @param first string

* @param second string

**/

bool operator()(std::string_view x, std::string_view y) const {

COMPARATOR(x, y, std::toupper);

}

bool operator()(const std::string& x, const std::string& y) const {

COMPARATOR(x, y, std::toupper);

}

};

/**

* Operator Class that is used to compare two strings. The comparison can be sensitive or insensitive.

* The default comparison is case sensitive. To obtain insensitive comparison you have to pass in

* compilation phase the flag CASE_INSENSITIVE to the preprocessor.

**/

class arg_comparator {

public:

using is_transparent = std::true_type;

/**

* Operator used to compare strings.

* @param first string

* @param second string

**/

bool operator()(std::string_view x, std::string_view y) const {

#ifdef CASE_INSENSITIVE

COMPARATOR(x, y, std::toupper);

#else

COMPARATOR(x, y,); // NOLINT(whitespace/comma)

#endif

}

bool operator()(const std::string& x, const std::string& y) const {

return operator()(std::string_view(x), std::string_view(y));

}

bool operator()(std::string_view x, const std::string& y) const {

return operator()(x, std::string_view(y));

}

bool operator()(const std::string& x, std::string_view y) const {

return operator()(std::string_view(x), std::string(y));

}

};

using header_map = std::map<std::string, std::string, http::header_comparator>;

using header_view_map = std::map<std::string_view, std::string_view, http::header_comparator>;

using arg_map = std::map<std::string, http_arg_value, http::arg_comparator>;

using arg_view_map = std::map<std::string_view, http_arg_value, http::arg_comparator>;

struct ip_representation {

http_utils::IP_version_T ip_version;

uint16_t pieces[16];

uint16_t mask;

explicit ip_representation(http_utils::IP_version_T ip_version) :

ip_version(ip_version) {

mask = DEFAULT_MASK_VALUE;

std::fill(pieces, pieces + 16, 0);

}

explicit ip_representation(const std::string& ip);

explicit ip_representation(const struct sockaddr* ip);

bool operator<(const ip_representation& b) const;

int weight() const {

// variable-precision SWAR algorithm

uint16_t x = mask;

x = x - ((x >> 1) & 0x55555555);

x = (x & 0x33333333) + ((x >> 2) & 0x33333333);

return (((x + (x >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;

}

};

/**

* Method used to get an ip in form of string from a sockaddr structure

* @param sa The sockaddr object to find the ip address from

* @param maxlen Maxlen of the address (automatically discovered if not passed)

* @return string containing the ip address

**/

std::string get_ip_str(const struct sockaddr *sa);

/**

* Method used to get a port from a sockaddr

* @param sa The sockaddr object to find the port from

* @return short representing the port

**/

uint16_t get_port(const struct sockaddr* sa);

/**

* Method to output the contents of a headers map to a std::ostream

* @param os The ostream

* @param prefix Prefix to identify the map

* @param map

**/

void dump_header_map(std::ostream& os, const std::string& prefix, const http::header_view_map& map);

/**

* Method to output the contents of an arguments map to a std::ostream

* @param os The ostream

* @param prefix Prefix to identify the map

* @param map

**/

void dump_arg_map(std::ostream& os, const std::string& prefix, const http::arg_view_map& map);

/**

* Process escape sequences ('+'=space, %HH) Updates val in place; the

* result should be UTF-8 encoded and cannot be larger than the input.

* The result must also still be 0-terminated.

* @param val the string to unescape

* @return length of the resulting val (strlen(val) maybe

* shorter afterwards due to elimination of escape sequences)

size_t http_unescape(std::string* val);

const std::string load_file(const std::string& filename);

size_t base_unescaper(std::string*, unescaper_ptr unescaper);

} // namespace http

} // namespace httpserver

#endif // SRC_HTTPSERVER_HTTP_UTILS_HPP_

libhttpserver/src/httpserver/http_utils.hpp at master · BeardOverflow/libhttpserver · GitHub

Expand file tree

Breadcrumbs

http_utils.hpp

Latest commit

History

Breadcrumbs

http_utils.hpp

File metadata and controls