[Minor] Lowercase CSS

src/libserver/css/css_parser.cxx

 #include "css_tokeniser.hxx"
 #include "css_selector.hxx"
 #include "css_rule.hxx"
+#include "css_util.hxx"
 #include "css.hxx"
 #include "fmt/core.h"
 
 		return tl::make_unexpected(error);
 	}
 
+	/* Helper parser methods */
+	bool need_unescape(const std::string_view &sv);
+
 private:
 	std::unique_ptr<css_style_sheet> style_object;
 	std::unique_ptr<css_tokeniser> tokeniser;
 	const int max_rec = 20;
 	bool eof = false;
 
-	/* Helper parser methods */
-	bool need_unescape(const std::string_view &sv);
-
 	/* Consumers */
 	auto component_value_consumer(std::unique_ptr<css_consumed_block> &top) -> bool;
 	auto function_consumer(std::unique_ptr<css_consumed_block> &top) -> bool;
 		tl::expected<std::unique_ptr<css_style_sheet>, css_parse_error>
 {
 	css_parser parser(pool);
+	std::string_view processed_input;
+
+	if (parser.need_unescape(st)) {
+		processed_input = rspamd::css::unescape_css(pool, st);
+	}
+	else {
+		/* Lowercase inplace */
+		auto *nspace = reinterpret_cast<char *>(rspamd_mempool_alloc(pool, st.length()));
+		auto *p = nspace;
+
+		for (const auto c : st) {
+			*p++ = g_ascii_tolower(c);
+		}
+
+		processed_input = std::string_view{nspace, (std::size_t)(p - nspace)};
+	}
 
-	if (parser.consume_input(st)) {
+	if (parser.consume_input(processed_input)) {
 		return parser.get_object_maybe();
 	}
 

src/libserver/css/css_util.cxx

 std::string_view unescape_css(rspamd_mempool_t *pool,
 							  const std::string_view &sv)
 {
-	auto *nspace = reinterpret_cast<char *>(rspamd_mempool_alloc(pool, sv.length ()));
+	auto *nspace = reinterpret_cast<char *>(rspamd_mempool_alloc(pool, sv.length()));
 	auto *d = nspace;
 	auto nleft = sv.length ();
 
 	auto escape_offset = 0, i = 0;
 
 #define MAYBE_CONSUME_CHAR(c) do { \
-    if (c == '"' || c == '\'') { \
+    if ((c) == '"' || (c) == '\'') { \
         state = quoted; \
-        quote_char = c; \
+        quote_char = (c); \
         nleft--; \
-        *d++ = c; \
+        *d++ = (c); \
     } \
-    else if (c == '\\') { \
+    else if ((c) == '\\') { \
         escape_offset = i; \
         state = escape; \
     } \
     else { \
         state = normal; \
         nleft--; \
-        *d++ = c; \
+        *d++ = g_ascii_tolower(c); \
     } \
 } while (0)
 
 					else {
 						if (val < 0x80) {
 							/* Trivial case: ascii character */
-							*d++ = (unsigned char)val;
+							*d++ = (unsigned char)g_ascii_tolower(val);
 							nleft --;
 						}
 						else {
 							UChar32 uc = val;
 							auto off = 0;
 							UTF8_APPEND_CHAR_SAFE((uint8_t *) d, off,
-									sv.length (), uc);
+									sv.length (), u_tolower(uc));
 							d += off;
 							nleft -= off;
 						}

src/libutil/mem_pool.h

  * @return pointer to allocated object
  */
 void *rspamd_mempool_alloc_ (rspamd_mempool_t *pool, gsize size, const gchar *loc)
-RSPAMD_ATTR_ALLOC_SIZE(2) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT) RSPAMD_ATTR_RETURNS_NONNUL;
+	RSPAMD_ATTR_ALLOC_SIZE(2) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT) RSPAMD_ATTR_RETURNS_NONNUL;
 #define rspamd_mempool_alloc(pool, size) \
-	rspamd_mempool_alloc_((pool), (size), G_STRLOC)
+	rspamd_mempool_alloc_((pool), (size), (G_STRLOC))
 
 /**
  * Notify external memory usage for memory pool
  */
 void rspamd_mempool_notify_alloc_ (rspamd_mempool_t *pool, gsize size, const gchar *loc);
 #define rspamd_mempool_notify_alloc(pool, size) \
-	rspamd_mempool_notify_alloc_((pool), (size), G_STRLOC)
+	rspamd_mempool_notify_alloc_((pool), (size), (G_STRLOC))
 
 /**
  * Get memory and set it to zero
  * @return pointer to allocated object
  */
 void *rspamd_mempool_alloc0_ (rspamd_mempool_t *pool, gsize size, const gchar *loc)
-RSPAMD_ATTR_ALLOC_SIZE(2) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT) RSPAMD_ATTR_RETURNS_NONNUL;
+	RSPAMD_ATTR_ALLOC_SIZE(2) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT) RSPAMD_ATTR_RETURNS_NONNUL;
 #define rspamd_mempool_alloc0(pool, size) \
-	rspamd_mempool_alloc0_((pool), (size), G_STRLOC)
+	rspamd_mempool_alloc0_((pool), (size), (G_STRLOC))
 
 /**
  * Make a copy of string in pool
  * @return pointer to newly created string that is copy of src
  */
 gchar *rspamd_mempool_strdup_ (rspamd_mempool_t *pool, const gchar *src, const gchar *loc)
-RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT);
+	RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT);
 #define rspamd_mempool_strdup(pool, src) \
-	rspamd_mempool_strdup_ ((pool), (src), G_STRLOC)
+	rspamd_mempool_strdup_ ((pool), (src), (G_STRLOC))
 
 /**
  * Make a copy of fixed string in pool as null terminated string
 								const gchar *loc)
 RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT);
 #define rspamd_mempool_ftokdup(pool, src) \
-	rspamd_mempool_ftokdup_ ((pool), (src), G_STRLOC)
+	rspamd_mempool_ftokdup_ ((pool), (src), (G_STRLOC))
 
 /**
  * Allocate piece of shared memory
  * @param size bytes to allocate
  */
 void *rspamd_mempool_alloc_shared_ (rspamd_mempool_t *pool, gsize size, const gchar *loc)
-RSPAMD_ATTR_ALLOC_SIZE(2) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT) RSPAMD_ATTR_RETURNS_NONNUL;
+	RSPAMD_ATTR_ALLOC_SIZE(2) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT) RSPAMD_ATTR_RETURNS_NONNUL;
 #define rspamd_mempool_alloc_shared(pool, size) \
-	rspamd_mempool_alloc_shared_((pool), (size), G_STRLOC)
+	rspamd_mempool_alloc_shared_((pool), (size), (G_STRLOC))
 
 void *rspamd_mempool_alloc0_shared_ (rspamd_mempool_t *pool, gsize size, const gchar *loc)
-RSPAMD_ATTR_ALLOC_SIZE(2) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT) RSPAMD_ATTR_RETURNS_NONNUL;
+	RSPAMD_ATTR_ALLOC_SIZE(2) RSPAMD_ATTR_ALLOC_ALIGN(MIN_MEM_ALIGNMENT) RSPAMD_ATTR_RETURNS_NONNUL;
 #define rspamd_mempool_alloc0_shared(pool, size) \
-	rspamd_mempool_alloc0_shared_((pool), (size), G_STRLOC)
+	rspamd_mempool_alloc0_shared_((pool), (size), (G_STRLOC))
 
 /**
  * Add destructor callback to pool
 
 /* Macros for common usage */
 #define rspamd_mempool_add_destructor(pool, func, data) \
-    rspamd_mempool_add_destructor_full (pool, func, data, G_STRFUNC, G_STRLOC)
+    rspamd_mempool_add_destructor_full (pool, func, data, (G_STRFUNC), (G_STRLOC))
 
 /**
  * Replace destructor callback to pool for specified pointer
  * @param new_data pointer to data that would be passed to destructor
  */
 void rspamd_mempool_replace_destructor (rspamd_mempool_t *pool,
-										rspamd_mempool_destruct_t func, void *old_data, void *new_data);
+										rspamd_mempool_destruct_t func,
+										void *old_data, void *new_data);
 
 /**
  * Calls all destructors associated with the specific memory pool without removing