Crow  1.1
A C++ microframework for the web
 
Loading...
Searching...
No Matches
utility.h
1#pragma once
2
3#include <cstdint>
4#include <stdexcept>
5#include <tuple>
6#include <type_traits>
7#include <cstring>
8#include <cctype>
9#include <functional>
10#include <string>
11#include <sstream>
12#include <unordered_map>
13#include <random>
14#include <algorithm>
15
16#include "crow/settings.h"
17
18#if defined(CROW_CAN_USE_CPP17) && !defined(CROW_FILESYSTEM_IS_EXPERIMENTAL)
19#include <filesystem>
20#endif
21
22// TODO(EDev): Adding C++20's [[likely]] and [[unlikely]] attributes might be useful
23#if defined(__GNUG__) || defined(__clang__)
24#define CROW_LIKELY(X) __builtin_expect(!!(X), 1)
25#define CROW_UNLIKELY(X) __builtin_expect(!!(X), 0)
26#else
27#define CROW_LIKELY(X) (X)
28#define CROW_UNLIKELY(X) (X)
29#endif
30
31namespace crow
32{
33 /// @cond SKIP
34 namespace black_magic
35 {
36#ifndef CROW_MSVC_WORKAROUND
37 /// Out of Range Exception for const_str
38 struct OutOfRange
39 {
40 OutOfRange(unsigned /*pos*/, unsigned /*length*/) {}
41 };
42 /// Helper function to throw an exception if i is larger than len
43 constexpr unsigned requires_in_range(unsigned i, unsigned len)
44 {
45 return i >= len ? throw OutOfRange(i, len) : i;
46 }
47
48 /// A constant string implementation.
49 class const_str
50 {
51 const char* const begin_;
52 unsigned size_;
53
54 public:
55 template<unsigned N>
56 constexpr const_str(const char (&arr)[N]):
57 begin_(arr), size_(N - 1)
58 {
59 static_assert(N >= 1, "not a string literal");
60 }
61 constexpr char operator[](unsigned i) const
62 {
63 return requires_in_range(i, size_), begin_[i];
64 }
65
66 constexpr operator const char*() const
67 {
68 return begin_;
69 }
70
71 constexpr const char* begin() const { return begin_; }
72 constexpr const char* end() const { return begin_ + size_; }
73
74 constexpr unsigned size() const
75 {
76 return size_;
77 }
78 };
79
80 constexpr unsigned find_closing_tag(const_str s, unsigned p)
81 {
82 return s[p] == '>' ? p : find_closing_tag(s, p + 1);
83 }
84
85 /// Check that the CROW_ROUTE string is valid
86 constexpr bool is_valid(const_str s, unsigned i = 0, int f = 0)
87 {
88 return i == s.size() ? f == 0 :
89 f < 0 || f >= 2 ? false :
90 s[i] == '<' ? is_valid(s, i + 1, f + 1) :
91 s[i] == '>' ? is_valid(s, i + 1, f - 1) :
92 is_valid(s, i + 1, f);
93 }
94
95 constexpr bool is_equ_p(const char* a, const char* b, unsigned n)
96 {
97 return *a == 0 && *b == 0 && n == 0 ? true :
98 (*a == 0 || *b == 0) ? false :
99 n == 0 ? true :
100 *a != *b ? false :
101 is_equ_p(a + 1, b + 1, n - 1);
102 }
103
104 constexpr bool is_equ_n(const_str a, unsigned ai, const_str b, unsigned bi, unsigned n)
105 {
106 return ai + n > a.size() || bi + n > b.size() ? false :
107 n == 0 ? true :
108 a[ai] != b[bi] ? false :
109 is_equ_n(a, ai + 1, b, bi + 1, n - 1);
110 }
111
112 constexpr bool is_int(const_str s, unsigned i)
113 {
114 return is_equ_n(s, i, "<int>", 0, 5);
115 }
116
117 constexpr bool is_uint(const_str s, unsigned i)
118 {
119 return is_equ_n(s, i, "<uint>", 0, 6);
120 }
121
122 constexpr bool is_float(const_str s, unsigned i)
123 {
124 return is_equ_n(s, i, "<float>", 0, 7) ||
125 is_equ_n(s, i, "<double>", 0, 8);
126 }
127
128 constexpr bool is_str(const_str s, unsigned i)
129 {
130 return is_equ_n(s, i, "<str>", 0, 5) ||
131 is_equ_n(s, i, "<string>", 0, 8);
132 }
133
134 constexpr bool is_path(const_str s, unsigned i)
135 {
136 return is_equ_n(s, i, "<path>", 0, 6);
137 }
138#endif
139 template<typename T>
140 struct parameter_tag
141 {
142 static const int value = 0;
143 };
144#define CROW_INTERNAL_PARAMETER_TAG(t, i) \
145 template<> \
146 struct parameter_tag<t> \
147 { \
148 static const int value = i; \
149 }
150 CROW_INTERNAL_PARAMETER_TAG(int, 1);
151 CROW_INTERNAL_PARAMETER_TAG(char, 1);
152 CROW_INTERNAL_PARAMETER_TAG(short, 1);
153 CROW_INTERNAL_PARAMETER_TAG(long, 1);
154 CROW_INTERNAL_PARAMETER_TAG(long long, 1);
155 CROW_INTERNAL_PARAMETER_TAG(unsigned int, 2);
156 CROW_INTERNAL_PARAMETER_TAG(unsigned char, 2);
157 CROW_INTERNAL_PARAMETER_TAG(unsigned short, 2);
158 CROW_INTERNAL_PARAMETER_TAG(unsigned long, 2);
159 CROW_INTERNAL_PARAMETER_TAG(unsigned long long, 2);
160 CROW_INTERNAL_PARAMETER_TAG(double, 3);
161 CROW_INTERNAL_PARAMETER_TAG(std::string, 4);
162#undef CROW_INTERNAL_PARAMETER_TAG
163 template<typename... Args>
164 struct compute_parameter_tag_from_args_list;
165
166 template<>
167 struct compute_parameter_tag_from_args_list<>
168 {
169 static const int value = 0;
170 };
171
172 template<typename Arg, typename... Args>
173 struct compute_parameter_tag_from_args_list<Arg, Args...>
174 {
175 static const int sub_value =
176 compute_parameter_tag_from_args_list<Args...>::value;
177 static const int value =
178 parameter_tag<typename std::decay<Arg>::type>::value ? sub_value * 6 + parameter_tag<typename std::decay<Arg>::type>::value : sub_value;
179 };
180
181 static inline bool is_parameter_tag_compatible(uint64_t a, uint64_t b)
182 {
183 if (a == 0)
184 return b == 0;
185 if (b == 0)
186 return a == 0;
187 int sa = a % 6;
188 int sb = a % 6;
189 if (sa == 5) sa = 4;
190 if (sb == 5) sb = 4;
191 if (sa != sb)
192 return false;
193 return is_parameter_tag_compatible(a / 6, b / 6);
194 }
195
196 static inline unsigned find_closing_tag_runtime(const char* s, unsigned p)
197 {
198 return s[p] == 0 ? throw std::runtime_error("unmatched tag <") :
199 s[p] == '>' ? p :
200 find_closing_tag_runtime(s, p + 1);
201 }
202
203 static inline uint64_t get_parameter_tag_runtime(const char* s, unsigned p = 0)
204 {
205 return s[p] == 0 ? 0 :
206 s[p] == '<' ? (
207 std::strncmp(s + p, "<int>", 5) == 0 ? get_parameter_tag_runtime(s, find_closing_tag_runtime(s, p)) * 6 + 1 :
208 std::strncmp(s + p, "<uint>", 6) == 0 ? get_parameter_tag_runtime(s, find_closing_tag_runtime(s, p)) * 6 + 2 :
209 (std::strncmp(s + p, "<float>", 7) == 0 ||
210 std::strncmp(s + p, "<double>", 8) == 0) ?
211 get_parameter_tag_runtime(s, find_closing_tag_runtime(s, p)) * 6 + 3 :
212 (std::strncmp(s + p, "<str>", 5) == 0 ||
213 std::strncmp(s + p, "<string>", 8) == 0) ?
214 get_parameter_tag_runtime(s, find_closing_tag_runtime(s, p)) * 6 + 4 :
215 std::strncmp(s + p, "<path>", 6) == 0 ? get_parameter_tag_runtime(s, find_closing_tag_runtime(s, p)) * 6 + 5 :
216 throw std::runtime_error("invalid parameter type")) :
217 get_parameter_tag_runtime(s, p + 1);
218 }
219#ifndef CROW_MSVC_WORKAROUND
220 constexpr uint64_t get_parameter_tag(const_str s, unsigned p = 0)
221 {
222 return p == s.size() ? 0 :
223 s[p] == '<' ? (
224 is_int(s, p) ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 1 :
225 is_uint(s, p) ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 2 :
226 is_float(s, p) ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 3 :
227 is_str(s, p) ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 4 :
228 is_path(s, p) ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 5 :
229 throw std::runtime_error("invalid parameter type")) :
230 get_parameter_tag(s, p + 1);
231 }
232#endif
233
234 template<typename... T>
235 struct S
236 {
237 template<typename U>
238 using push = S<U, T...>;
239 template<typename U>
240 using push_back = S<T..., U>;
241 template<template<typename... Args> class U>
242 using rebind = U<T...>;
243 };
244
245 // Check whether the template function can be called with specific arguments
246 template<typename F, typename Set>
247 struct CallHelper;
248 template<typename F, typename... Args>
249 struct CallHelper<F, S<Args...>>
250 {
251 template<typename F1, typename... Args1, typename = decltype(std::declval<F1>()(std::declval<Args1>()...))>
252 static char __test(int);
253
254 template<typename...>
255 static int __test(...);
256
257 static constexpr bool value = sizeof(__test<F, Args...>(0)) == sizeof(char);
258 };
259
260 // Check Tuple contains type T
261 template<typename T, typename Tuple>
262 struct has_type;
263
264 template<typename T>
265 struct has_type<T, std::tuple<>> : std::false_type
266 {};
267
268 template<typename T, typename U, typename... Ts>
269 struct has_type<T, std::tuple<U, Ts...>> : has_type<T, std::tuple<Ts...>>
270 {};
271
272 template<typename T, typename... Ts>
273 struct has_type<T, std::tuple<T, Ts...>> : std::true_type
274 {};
275
276 // Find index of type in tuple
277 template<class T, class Tuple>
278 struct tuple_index;
279
280 template<class T, class... Types>
281 struct tuple_index<T, std::tuple<T, Types...>>
282 {
283 static const int value = 0;
284 };
285
286 template<class T, class U, class... Types>
287 struct tuple_index<T, std::tuple<U, Types...>>
288 {
289 static const int value = 1 + tuple_index<T, std::tuple<Types...>>::value;
290 };
291
292 // Extract element from forward tuple or get default
293#ifdef CROW_CAN_USE_CPP14
294 template<typename T, typename Tup>
295 typename std::enable_if<has_type<T&, Tup>::value, typename std::decay<T>::type&&>::type
296 tuple_extract(Tup& tup)
297 {
298 return std::move(std::get<T&>(tup));
299 }
300#else
301 template<typename T, typename Tup>
302 typename std::enable_if<has_type<T&, Tup>::value, T&&>::type
303 tuple_extract(Tup& tup)
304 {
305 return std::move(std::get<tuple_index<T&, Tup>::value>(tup));
306 }
307#endif
308
309 template<typename T, typename Tup>
310 typename std::enable_if<!has_type<T&, Tup>::value, T>::type
311 tuple_extract(Tup&)
312 {
313 return T{};
314 }
315
316 // Kind of fold expressions in C++11
317 template<bool...>
318 struct bool_pack;
319 template<bool... bs>
320 using all_true = std::is_same<bool_pack<bs..., true>, bool_pack<true, bs...>>;
321
322 template<int N>
323 struct single_tag_to_type
324 {};
325
326 template<>
327 struct single_tag_to_type<1>
328 {
329 using type = int64_t;
330 };
331
332 template<>
333 struct single_tag_to_type<2>
334 {
335 using type = uint64_t;
336 };
337
338 template<>
339 struct single_tag_to_type<3>
340 {
341 using type = double;
342 };
343
344 template<>
345 struct single_tag_to_type<4>
346 {
347 using type = std::string;
348 };
349
350 template<>
351 struct single_tag_to_type<5>
352 {
353 using type = std::string;
354 };
355
356
357 template<uint64_t Tag>
358 struct arguments
359 {
360 using subarguments = typename arguments<Tag / 6>::type;
361 using type =
362 typename subarguments::template push<typename single_tag_to_type<Tag % 6>::type>;
363 };
364
365 template<>
366 struct arguments<0>
367 {
368 using type = S<>;
369 };
370
371 template<typename... T>
372 struct last_element_type
373 {
374 using type = typename std::tuple_element<sizeof...(T) - 1, std::tuple<T...>>::type;
375 };
376
377
378 template<>
379 struct last_element_type<>
380 {};
381
382
383 // from http://stackoverflow.com/questions/13072359/c11-compile-time-array-with-logarithmic-evaluation-depth
384 template<class T>
385 using Invoke = typename T::type;
386
387 template<unsigned...>
388 struct seq
389 {
390 using type = seq;
391 };
392
393 template<class S1, class S2>
394 struct concat;
395
396 template<unsigned... I1, unsigned... I2>
397 struct concat<seq<I1...>, seq<I2...>> : seq<I1..., (sizeof...(I1) + I2)...>
398 {};
399
400 template<class S1, class S2>
401 using Concat = Invoke<concat<S1, S2>>;
402
403 template<unsigned N>
404 struct gen_seq;
405 template<unsigned N>
406 using GenSeq = Invoke<gen_seq<N>>;
407
408 template<unsigned N>
409 struct gen_seq : Concat<GenSeq<N / 2>, GenSeq<N - N / 2>>
410 {};
411
412 template<>
413 struct gen_seq<0> : seq<>
414 {};
415 template<>
416 struct gen_seq<1> : seq<0>
417 {};
418
419 template<typename Seq, typename Tuple>
420 struct pop_back_helper;
421
422 template<unsigned... N, typename Tuple>
423 struct pop_back_helper<seq<N...>, Tuple>
424 {
425 template<template<typename... Args> class U>
426 using rebind = U<typename std::tuple_element<N, Tuple>::type...>;
427 };
428
429 template<typename... T>
430 struct pop_back //: public pop_back_helper<typename gen_seq<sizeof...(T)-1>::type, std::tuple<T...>>
431 {
432 template<template<typename... Args> class U>
433 using rebind = typename pop_back_helper<typename gen_seq<sizeof...(T) - 1>::type, std::tuple<T...>>::template rebind<U>;
434 };
435
436 template<>
437 struct pop_back<>
438 {
439 template<template<typename... Args> class U>
440 using rebind = U<>;
441 };
442
443 // from http://stackoverflow.com/questions/2118541/check-if-c0x-parameter-pack-contains-a-type
444 template<typename Tp, typename... List>
445 struct contains : std::true_type
446 {};
447
448 template<typename Tp, typename Head, typename... Rest>
449 struct contains<Tp, Head, Rest...> : std::conditional<std::is_same<Tp, Head>::value, std::true_type, contains<Tp, Rest...>>::type
450 {};
451
452 template<typename Tp>
453 struct contains<Tp> : std::false_type
454 {};
455
456 template<typename T>
457 struct empty_context
458 {};
459
460 template<typename T>
461 struct promote
462 {
463 using type = T;
464 };
465
466#define CROW_INTERNAL_PROMOTE_TYPE(t1, t2) \
467 template<> \
468 struct promote<t1> \
469 { \
470 using type = t2; \
471 }
472
473 CROW_INTERNAL_PROMOTE_TYPE(char, int64_t);
474 CROW_INTERNAL_PROMOTE_TYPE(short, int64_t);
475 CROW_INTERNAL_PROMOTE_TYPE(int, int64_t);
476 CROW_INTERNAL_PROMOTE_TYPE(long, int64_t);
477 CROW_INTERNAL_PROMOTE_TYPE(long long, int64_t);
478 CROW_INTERNAL_PROMOTE_TYPE(unsigned char, uint64_t);
479 CROW_INTERNAL_PROMOTE_TYPE(unsigned short, uint64_t);
480 CROW_INTERNAL_PROMOTE_TYPE(unsigned int, uint64_t);
481 CROW_INTERNAL_PROMOTE_TYPE(unsigned long, uint64_t);
482 CROW_INTERNAL_PROMOTE_TYPE(unsigned long long, uint64_t);
483 CROW_INTERNAL_PROMOTE_TYPE(float, double);
484#undef CROW_INTERNAL_PROMOTE_TYPE
485
486 template<typename T>
487 using promote_t = typename promote<T>::type;
488
489 } // namespace black_magic
490
491 namespace detail
492 {
493
494 template<class T, std::size_t N, class... Args>
495 struct get_index_of_element_from_tuple_by_type_impl
496 {
497 static constexpr auto value = N;
498 };
499
500 template<class T, std::size_t N, class... Args>
501 struct get_index_of_element_from_tuple_by_type_impl<T, N, T, Args...>
502 {
503 static constexpr auto value = N;
504 };
505
506 template<class T, std::size_t N, class U, class... Args>
507 struct get_index_of_element_from_tuple_by_type_impl<T, N, U, Args...>
508 {
509 static constexpr auto value = get_index_of_element_from_tuple_by_type_impl<T, N + 1, Args...>::value;
510 };
511 } // namespace detail
512
513 namespace utility
514 {
515 template<class T, class... Args>
516 T& get_element_by_type(std::tuple<Args...>& t)
517 {
518 return std::get<detail::get_index_of_element_from_tuple_by_type_impl<T, 0, Args...>::value>(t);
519 }
520
521 template<typename T>
522 struct function_traits;
523
524#ifndef CROW_MSVC_WORKAROUND
525 template<typename T>
526 struct function_traits : public function_traits<decltype(&T::operator())>
527 {
528 using parent_t = function_traits<decltype(&T::operator())>;
529 static const size_t arity = parent_t::arity;
530 using result_type = typename parent_t::result_type;
531 template<size_t i>
532 using arg = typename parent_t::template arg<i>;
533 };
534#endif
535
536 template<typename ClassType, typename R, typename... Args>
537 struct function_traits<R (ClassType::*)(Args...) const>
538 {
539 static const size_t arity = sizeof...(Args);
540
541 typedef R result_type;
542
543 template<size_t i>
544 using arg = typename std::tuple_element<i, std::tuple<Args...>>::type;
545 };
546
547 template<typename ClassType, typename R, typename... Args>
548 struct function_traits<R (ClassType::*)(Args...)>
549 {
550 static const size_t arity = sizeof...(Args);
551
552 typedef R result_type;
553
554 template<size_t i>
555 using arg = typename std::tuple_element<i, std::tuple<Args...>>::type;
556 };
557
558 template<typename R, typename... Args>
559 struct function_traits<std::function<R(Args...)>>
560 {
561 static const size_t arity = sizeof...(Args);
562
563 typedef R result_type;
564
565 template<size_t i>
566 using arg = typename std::tuple_element<i, std::tuple<Args...>>::type;
567 };
568 /// @endcond
569
570 inline static std::string base64encode(const unsigned char* data, size_t size, const char* key = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
571 {
572 std::string ret;
573 ret.resize((size + 2) / 3 * 4);
574 auto it = ret.begin();
575 while (size >= 3)
576 {
577 *it++ = key[(static_cast<unsigned char>(*data) & 0xFC) >> 2];
578 unsigned char h = (static_cast<unsigned char>(*data++) & 0x03) << 4;
579 *it++ = key[h | ((static_cast<unsigned char>(*data) & 0xF0) >> 4)];
580 h = (static_cast<unsigned char>(*data++) & 0x0F) << 2;
581 *it++ = key[h | ((static_cast<unsigned char>(*data) & 0xC0) >> 6)];
582 *it++ = key[static_cast<unsigned char>(*data++) & 0x3F];
583
584 size -= 3;
585 }
586 if (size == 1)
587 {
588 *it++ = key[(static_cast<unsigned char>(*data) & 0xFC) >> 2];
589 unsigned char h = (static_cast<unsigned char>(*data++) & 0x03) << 4;
590 *it++ = key[h];
591 *it++ = '=';
592 *it++ = '=';
593 }
594 else if (size == 2)
595 {
596 *it++ = key[(static_cast<unsigned char>(*data) & 0xFC) >> 2];
597 unsigned char h = (static_cast<unsigned char>(*data++) & 0x03) << 4;
598 *it++ = key[h | ((static_cast<unsigned char>(*data) & 0xF0) >> 4)];
599 h = (static_cast<unsigned char>(*data++) & 0x0F) << 2;
600 *it++ = key[h];
601 *it++ = '=';
602 }
603 return ret;
604 }
605
606 inline static std::string base64encode(std::string data, size_t size, const char* key = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
607 {
608 return base64encode((const unsigned char*)data.c_str(), size, key);
609 }
610
611 inline static std::string base64encode_urlsafe(const unsigned char* data, size_t size)
612 {
613 return base64encode(data, size, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_");
614 }
615
616 inline static std::string base64encode_urlsafe(std::string data, size_t size)
617 {
618 return base64encode((const unsigned char*)data.c_str(), size, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_");
619 }
620
621 inline static std::string base64decode(const char* data, size_t size)
622 {
623 // We accept both regular and url encoding here, as there does not seem to be any downside to that.
624 // If we want to distinguish that we should use +/ for non-url and -_ for url.
625
626 // Mapping logic from characters to [0-63]
627 auto key = [](char c) -> unsigned char {
628 if ((c >= 'A') && (c <= 'Z')) return c - 'A';
629 if ((c >= 'a') && (c <= 'z')) return c - 'a' + 26;
630 if ((c >= '0') && (c <= '9')) return c - '0' + 52;
631 if ((c == '+') || (c == '-')) return 62;
632 if ((c == '/') || (c == '_')) return 63;
633 return 0;
634 };
635
636 // Not padded
637 if (size % 4 == 2) // missing last 2 characters
638 size = (size / 4 * 3) + 1; // Not subtracting extra characters because they're truncated in int division
639 else if (size % 4 == 3) // missing last character
640 size = (size / 4 * 3) + 2; // Not subtracting extra characters because they're truncated in int division
641
642 // Padded
643 else if (data[size - 2] == '=') // padded with '=='
644 size = (size / 4 * 3) - 2; // == padding means the last block only has 1 character instead of 3, hence the '-2'
645 else if (data[size - 1] == '=') // padded with '='
646 size = (size / 4 * 3) - 1; // = padding means the last block only has 2 character instead of 3, hence the '-1'
647
648 // Padding not needed
649 else
650 size = size / 4 * 3;
651
652 std::string ret;
653 ret.resize(size);
654 auto it = ret.begin();
655
656 // These will be used to decode 1 character at a time
657 unsigned char odd; // char1 and char3
658 unsigned char even; // char2 and char4
659
660 // Take 4 character blocks to turn into 3
661 while (size >= 3)
662 {
663 // dec_char1 = (char1 shifted 2 bits to the left) OR ((char2 AND 00110000) shifted 4 bits to the right))
664 odd = key(*data++);
665 even = key(*data++);
666 *it++ = (odd << 2) | ((even & 0x30) >> 4);
667 // dec_char2 = ((char2 AND 00001111) shifted 4 bits left) OR ((char3 AND 00111100) shifted 2 bits right))
668 odd = key(*data++);
669 *it++ = ((even & 0x0F) << 4) | ((odd & 0x3C) >> 2);
670 // dec_char3 = ((char3 AND 00000011) shifted 6 bits left) OR (char4)
671 even = key(*data++);
672 *it++ = ((odd & 0x03) << 6) | (even);
673
674 size -= 3;
675 }
676 if (size == 2)
677 {
678 // d_char1 = (char1 shifted 2 bits to the left) OR ((char2 AND 00110000) shifted 4 bits to the right))
679 odd = key(*data++);
680 even = key(*data++);
681 *it++ = (odd << 2) | ((even & 0x30) >> 4);
682 // d_char2 = ((char2 AND 00001111) shifted 4 bits left) OR ((char3 AND 00111100) shifted 2 bits right))
683 odd = key(*data++);
684 *it++ = ((even & 0x0F) << 4) | ((odd & 0x3C) >> 2);
685 }
686 else if (size == 1)
687 {
688 // d_char1 = (char1 shifted 2 bits to the left) OR ((char2 AND 00110000) shifted 4 bits to the right))
689 odd = key(*data++);
690 even = key(*data++);
691 *it++ = (odd << 2) | ((even & 0x30) >> 4);
692 }
693 return ret;
694 }
695
696 inline static std::string base64decode(const std::string& data, size_t size)
697 {
698 return base64decode(data.data(), size);
699 }
700
701 inline static std::string base64decode(const std::string& data)
702 {
703 return base64decode(data.data(), data.length());
704 }
705
706 inline static std::string normalize_path(const std::string& directoryPath)
707 {
708 std::string normalizedPath = directoryPath;
709 std::replace(normalizedPath.begin(), normalizedPath.end(), '\\', '/');
710 if (!normalizedPath.empty() && normalizedPath.back() != '/')
711 normalizedPath += '/';
712 return normalizedPath;
713 }
714
715 inline static void sanitize_filename(std::string& data, char replacement = '_')
716 {
717 if (data.length() > 255)
718 data.resize(255);
719
720 static const auto toUpper = [](char c) {
721 return ((c >= 'a') && (c <= 'z')) ? (c - ('a' - 'A')) : c;
722 };
723 // Check for special device names. The Windows behavior is really odd here, it will consider both AUX and AUX.txt
724 // a special device. Thus we search for the string (case-insensitive), and then check if the string ends or if
725 // is has a dangerous follow up character (.:\/)
726 auto sanitizeSpecialFile = [](std::string& source, unsigned ofs, const char* pattern, bool includeNumber, char replacement) {
727 unsigned i = ofs;
728 size_t len = source.length();
729 const char* p = pattern;
730 while (*p)
731 {
732 if (i >= len) return;
733 if (toUpper(source[i]) != *p) return;
734 ++i;
735 ++p;
736 }
737 if (includeNumber)
738 {
739 if ((i >= len) || (source[i] < '1') || (source[i] > '9')) return;
740 ++i;
741 }
742 if ((i >= len) || (source[i] == '.') || (source[i] == ':') || (source[i] == '/') || (source[i] == '\\'))
743 {
744 source.erase(ofs + 1, (i - ofs) - 1);
745 source[ofs] = replacement;
746 }
747 };
748 bool checkForSpecialEntries = true;
749 for (unsigned i = 0; i < data.length(); ++i)
750 {
751 // Recognize directory traversals and the special devices CON/PRN/AUX/NULL/COM[1-]/LPT[1-9]
752 if (checkForSpecialEntries)
753 {
754 checkForSpecialEntries = false;
755 switch (toUpper(data[i]))
756 {
757 case 'A':
758 sanitizeSpecialFile(data, i, "AUX", false, replacement);
759 break;
760 case 'C':
761 sanitizeSpecialFile(data, i, "CON", false, replacement);
762 sanitizeSpecialFile(data, i, "COM", true, replacement);
763 break;
764 case 'L':
765 sanitizeSpecialFile(data, i, "LPT", true, replacement);
766 break;
767 case 'N':
768 sanitizeSpecialFile(data, i, "NUL", false, replacement);
769 break;
770 case 'P':
771 sanitizeSpecialFile(data, i, "PRN", false, replacement);
772 break;
773 case '.':
774 sanitizeSpecialFile(data, i, "..", false, replacement);
775 break;
776 }
777 }
778
779 // Sanitize individual characters
780 unsigned char c = data[i];
781 if ((c < ' ') || ((c >= 0x80) && (c <= 0x9F)) || (c == '?') || (c == '<') || (c == '>') || (c == ':') || (c == '*') || (c == '|') || (c == '\"'))
782 {
783 data[i] = replacement;
784 }
785 else if ((c == '/') || (c == '\\'))
786 {
787 if (CROW_UNLIKELY(i == 0)) //Prevent Unix Absolute Paths (Windows Absolute Paths are prevented with `(c == ':')`)
788 {
789 data[i] = replacement;
790 }
791 else
792 {
793 checkForSpecialEntries = true;
794 }
795 }
796 }
797 }
798
799 inline static std::string random_alphanum(std::size_t size)
800 {
801 static const char alphabet[] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
802 std::random_device dev;
803 std::mt19937 rng(dev());
804 std::uniform_int_distribution<std::mt19937::result_type> dist(0, sizeof(alphabet) - 2);
805 std::string out;
806 out.reserve(size);
807 for (std::size_t i = 0; i < size; i++)
808 out.push_back(alphabet[dist(rng)]);
809 return out;
810 }
811
812 inline static std::string join_path(std::string path, const std::string& fname)
813 {
814#if defined(CROW_CAN_USE_CPP17) && !defined(CROW_FILESYSTEM_IS_EXPERIMENTAL)
815 return (std::filesystem::path(path) / fname).string();
816#else
817 if (!(path.back() == '/' || path.back() == '\\'))
818 path += '/';
819 path += fname;
820 return path;
821#endif
822 }
823
824 /**
825 * @brief Checks two string for equality.
826 * Always returns false if strings differ in size.
827 * Defaults to case-insensitive comparison.
828 */
829 inline static bool string_equals(const std::string& l, const std::string& r, bool case_sensitive = false)
830 {
831 if (l.length() != r.length())
832 return false;
833
834 for (size_t i = 0; i < l.length(); i++)
835 {
836 if (case_sensitive)
837 {
838 if (l[i] != r[i])
839 return false;
840 }
841 else
842 {
843 if (std::toupper(l[i]) != std::toupper(r[i]))
844 return false;
845 }
846 }
847
848 return true;
849 }
850
851 template<typename T, typename U>
852 inline static T lexical_cast(const U& v)
853 {
854 std::stringstream stream;
855 T res;
856
857 stream << v;
858 stream >> res;
859
860 return res;
861 }
862
863 template<typename T>
864 inline static T lexical_cast(const char* v, size_t count)
865 {
866 std::stringstream stream;
867 T res;
868
869 stream.write(v, count);
870 stream >> res;
871
872 return res;
873 }
874
875
876 /// Return a copy of the given string with its
877 /// leading and trailing whitespaces removed.
878 inline static std::string trim(const std::string& v)
879 {
880 if (v.empty())
881 return "";
882
883 size_t begin = 0, end = v.length();
884
885 size_t i;
886 for (i = 0; i < v.length(); i++)
887 {
888 if (!std::isspace(v[i]))
889 {
890 begin = i;
891 break;
892 }
893 }
894
895 if (i == v.length())
896 return "";
897
898 for (i = v.length(); i > 0; i--)
899 {
900 if (!std::isspace(v[i - 1]))
901 {
902 end = i;
903 break;
904 }
905 }
906
907 return v.substr(begin, end - begin);
908 }
909 } // namespace utility
910} // namespace crow
crow
The main namespace of the library. In this namespace is defined the most important classes and functi...