lib-sieve: editheader extension: Migrate settings to new config structure

src/lib-sieve/plugins/editheader/Makefile.am

@@ -12,8 +12,10 @@ commands = \
 libsieve_ext_editheader_la_SOURCES = \
 	$(commands) \
 	ext-editheader.c \
+	ext-editheader-settings.c \
 	ext-editheader-common.c
 
 noinst_HEADERS = \
 	ext-editheader-limits.h \
+	ext-editheader-settings.h \
 	ext-editheader-common.h

src/lib-sieve/plugins/editheader/ext-editheader-common.c

@@ -4,15 +4,16 @@
 #include "lib.h"
 #include "mempool.h"
 #include "array.h"
+#include "settings.h"
 
 #include "rfc2822.h"
 
 #include "sieve-common.h"
 #include "sieve-error.h"
-#include "sieve-settings.old.h"
 #include "sieve-extensions.h"
 
 #include "ext-editheader-limits.h"
+#include "ext-editheader-settings.h"
 #include "ext-editheader-common.h"
 
 /*
@@ -28,111 +29,97 @@ struct ext_editheader_header {
 
 struct ext_editheader_context {
 	pool_t pool;
+	const struct ext_editheader_settings *set;
 
 	ARRAY(struct ext_editheader_header) headers;
 
 	size_t max_header_size;
 };
 
-static struct ext_editheader_header *
-ext_editheader_config_header_find(struct ext_editheader_context *extctx,
-				  const char *hname)
+static const struct ext_editheader_header *
+ext_editheader_header_find(struct ext_editheader_context *extctx,
+			   const char *hname)
 {
-	struct ext_editheader_header *headers;
-	unsigned int count, i;
+	const struct ext_editheader_header *header;
+
+	if (extctx == NULL)
+		return NULL;
 
-	headers = array_get_modifiable(&extctx->headers, &count);
-	for (i = 0; i < count; i++) {
-		if (strcasecmp(hname, headers[i].name) == 0)
-			return &headers[i];
+	array_foreach(&extctx->headers, header) {
+		if (strcasecmp(hname, header->name) == 0)
+			return header;
 	}
 	return NULL;
 }
 
-static void
+static int
+ext_editheader_header_add(struct sieve_instance *svinst,
+			  struct ext_editheader_context *extctx,
+			  const char *hname)
+{
+	struct ext_editheader_header *header;
+	const struct ext_editheader_header_settings *set;
+	const char *error;
+
+	if (settings_get_filter(svinst->event, "sieve_editheader_header", hname,
+				&ext_editheader_header_setting_parser_info, 0,
+				&set, &error) < 0) {
+		e_error(svinst->event, "%s", error);
+		return -1;
+	}
+
+	i_assert(ext_editheader_header_find(extctx, set->name) == NULL);
+
+	header = array_append_space(&extctx->headers);
+	header->name = p_strdup(extctx->pool, set->name);
+	header->forbid_add = set->forbid_add;
+	header->forbid_delete = set->forbid_delete;
+
+	settings_free(set);
+	return 0;
+}
+
+static int
 ext_editheader_config_headers(struct sieve_instance *svinst,
-			      struct ext_editheader_context *extctx,
-			      const char *setting, bool forbid_add,
-			      bool forbid_delete)
+			      struct ext_editheader_context *extctx)
 {
-	const char *setval;
-
-	setval = sieve_setting_get(svinst, setting);
-	if (setval != NULL) {
-		const char **headers = t_strsplit_spaces(setval, " \t");
-
-		while (*headers != NULL) {
-			struct ext_editheader_header *header;
-
-			if (!rfc2822_header_field_name_verify(
-				*headers, strlen(*headers))) {
-				e_warning(svinst->event, "editheader: "
-					  "setting %s contains invalid header field name "
-					  "'%s' (ignored)",
-					  setting, *headers);
-				headers++;
-				continue;
-			}
-
-			header = ext_editheader_config_header_find(
-				extctx, *headers);
-			if (header == NULL) {
-				header = array_append_space(
-					&extctx->headers);
-				header->name = p_strdup(extctx->pool,
-							*headers);
-			}
-
-			if (forbid_add)
-				header->forbid_add = TRUE;
-			if (forbid_delete)
-				header->forbid_delete = TRUE;
-
-			headers++;
-		}
+	const char *hname;
+
+	if (!array_is_created(&extctx->set->headers))
+		return 0;
+
+	array_foreach_elem(&extctx->set->headers, hname) {
+		if (ext_editheader_header_add(svinst, extctx, hname) < 0)
+			return -1;
 	}
+	return 0;
 }
 
 int ext_editheader_load(const struct sieve_extension *ext, void **context_r)
 {
-	struct ext_editheader_context *extctx;
 	struct sieve_instance *svinst = ext->svinst;
-	size_t max_header_size;
+	const struct ext_editheader_settings *set;
+	struct ext_editheader_context *extctx;
+	const char *error;
 	pool_t pool;
 
-	T_BEGIN {
-		pool = pool_alloconly_create("editheader_config", 1024);
-		extctx = p_new(pool, struct ext_editheader_context, 1);
-		extctx->pool = pool;
-		extctx->max_header_size =
-			EXT_EDITHEADER_DEFAULT_MAX_HEADER_SIZE;
-
-		p_array_init(&extctx->headers, pool, 16);
-
-		ext_editheader_config_headers(
-			svinst, extctx,
-			"sieve_editheader_protected", TRUE, TRUE);
-		ext_editheader_config_headers(
-			svinst, extctx,
-			"sieve_editheader_forbid_add", TRUE, FALSE);
-		ext_editheader_config_headers(
-			svinst, extctx,
-			"sieve_editheader_forbid_delete", FALSE, TRUE);
-
-		if (sieve_setting_get_size_value(
-			svinst, "sieve_editheader_max_header_size",
-			&max_header_size)) {
-			if (max_header_size < EXT_EDITHEADER_MINIMUM_MAX_HEADER_SIZE) {
-				e_warning(svinst->event, "editheader: "
-					  "value of sieve_editheader_max_header_size setting "
-					  "(=%zu) is less than the minimum (=%zu) "
-					  "(ignored)", max_header_size,
-					  (size_t)EXT_EDITHEADER_MINIMUM_MAX_HEADER_SIZE);
-			} else {
-				extctx->max_header_size = max_header_size;
-			}
-		}
-	} T_END;
+	if (settings_get(svinst->event, &ext_editheader_setting_parser_info, 0,
+			 &set, &error) < 0) {
+		e_error(svinst->event, "%s", error);
+		return -1;
+	}
+
+	pool = pool_alloconly_create("editheader_config", 1024);
+	extctx = p_new(pool, struct ext_editheader_context, 1);
+	extctx->pool = pool;
+	extctx->set = set;
+	p_array_init(&extctx->headers, pool, 16);
+
+	if (ext_editheader_config_headers(svinst, extctx) < 0) {
+		settings_free(set);
+		pool_unref(&pool);
+		return -1;
+	}
 
 	*context_r = extctx;
 	return 0;
@@ -142,8 +129,10 @@ void ext_editheader_unload(const struct sieve_extension *ext)
 {
 	struct ext_editheader_context *extctx = ext->context;
 
-	if (extctx != NULL)
-		pool_unref(&extctx->pool);
+	if (extctx == NULL)
+		return;
+	settings_free(extctx->set);
+	pool_unref(&extctx->pool);
 }
 
 /*
@@ -161,7 +150,7 @@ bool ext_editheader_header_allow_add(const struct sieve_extension *ext,
 	if (strcasecmp(hname, "x-sieve-redirected-from") == 0)
 		return FALSE;
 
-	header = ext_editheader_config_header_find(extctx, hname);
+	header = ext_editheader_header_find(extctx, hname);
 	if (header == NULL)
 		return TRUE;
 
@@ -182,7 +171,7 @@ bool ext_editheader_header_allow_delete(const struct sieve_extension *ext,
 	if (strcasecmp(hname, "subject") == 0)
 		return TRUE;
 
-	header = ext_editheader_config_header_find(extctx, hname);
+	header = ext_editheader_header_find(extctx, hname);
 	if (header == NULL)
 		return TRUE;
 
@@ -198,5 +187,8 @@ bool ext_editheader_header_too_large(const struct sieve_extension *ext,
 {
 	struct ext_editheader_context *extctx = ext->context;
 
-	return size > extctx->max_header_size;
+	if (extctx == NULL)
+		return size > EXT_EDITHEADER_DEFAULT_MAX_HEADER_SIZE;
+
+	return (size > extctx->set->max_header_size);
 }

src/lib-sieve/plugins/editheader/ext-editheader-settings.c

+/* Copyright (c) 2024 Pigeonhole authors, see the included COPYING file
+ */
+
+#include "lib.h"
+#include "array.h"
+#include "settings.h"
+#include "settings-parser.h"
+
+#include "rfc2822.h"
+#include "ext-editheader-limits.h"
+#include "ext-editheader-settings.h"
+
+static bool
+ext_editheader_header_settings_check(void *_set, pool_t pool,
+				     const char **error_r);
+static bool
+ext_editheader_settings_check(void *_set, pool_t pool, const char **error_r);
+
+#undef DEF
+#define DEF(type, name) \
+	SETTING_DEFINE_STRUCT_##type("sieve_editheader_header_"#name, name, \
+				     struct ext_editheader_header_settings)
+
+static const struct setting_define ext_editheader_header_setting_defines[] = {
+	DEF(STR, name),
+	DEF(BOOL, forbid_add),
+	DEF(BOOL, forbid_delete),
+
+	SETTING_DEFINE_LIST_END,
+};
+
+static const struct ext_editheader_header_settings
+ext_editheader_header_default_settings = {
+	.name = "",
+	.forbid_add = FALSE,
+	.forbid_delete = FALSE,
+};
+
+const struct setting_parser_info ext_editheader_header_setting_parser_info = {
+	.name = "sieve_editheader_header",
+
+	.defines = ext_editheader_header_setting_defines,
+	.defaults = &ext_editheader_header_default_settings,
+
+	.struct_size = sizeof(struct ext_editheader_header_settings),
+
+	.check_func = ext_editheader_header_settings_check,
+
+	.pool_offset1 = 1 + offsetof(struct ext_editheader_header_settings, pool),
+};
+
+#undef DEF
+#define DEF(type, name) \
+	SETTING_DEFINE_STRUCT_##type("sieve_editheader_"#name, name, \
+				     struct ext_editheader_settings)
+
+static const struct setting_define ext_editheader_setting_defines[] = {
+	DEF(SIZE, max_header_size),
+
+	{ .type = SET_FILTER_ARRAY,
+	  .key = "sieve_editheader_header",
+	  .filter_array_field_name = "sieve_editheader_header_name",
+	  .offset = offsetof(struct ext_editheader_settings, headers), },
+
+	SETTING_DEFINE_LIST_END,
+};
+
+static const struct ext_editheader_settings ext_editheader_default_settings = {
+	.max_header_size = EXT_EDITHEADER_DEFAULT_MAX_HEADER_SIZE,
+	.headers = ARRAY_INIT,
+};
+
+const struct setting_parser_info ext_editheader_setting_parser_info = {
+	.name = "sieve_editheader",
+
+	.defines = ext_editheader_setting_defines,
+	.defaults = &ext_editheader_default_settings,
+
+	.struct_size = sizeof(struct ext_editheader_settings),
+
+	.check_func = ext_editheader_settings_check,
+
+	.pool_offset1 = 1 + offsetof(struct ext_editheader_settings, pool),
+};
+
+/* <settings checks> */
+static bool
+ext_editheader_header_settings_check(void *_set, pool_t pool ATTR_UNUSED,
+				     const char **error_r)
+{
+	struct ext_editheader_header_settings *set = _set;
+
+	if (!rfc2822_header_field_name_verify(set->name, strlen(set->name))) {
+		*error_r = t_strdup_printf(
+			"sieve_editheader_header_name: "
+			"Invalid header field name '%s'", set->name);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static bool
+ext_editheader_settings_check(void *_set, pool_t pool ATTR_UNUSED,
+			     const char **error_r)
+{
+	struct ext_editheader_settings *set = _set;
+
+	if (set->max_header_size < EXT_EDITHEADER_MINIMUM_MAX_HEADER_SIZE) {
+		*error_r = t_strdup_printf(
+			"sieve_editheader_max_header_size: "
+			"Value (=%"PRIuUOFF_T") is less than the minimum "
+			"(=%"PRIuUOFF_T") ",
+			set->max_header_size,
+			(size_t)EXT_EDITHEADER_MINIMUM_MAX_HEADER_SIZE);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+/* </settings checks> */
+

src/lib-sieve/plugins/editheader/ext-editheader-settings.h

+#ifndef EXT_EDITHEADER_SETTINGS_H
+#define EXT_EDITHEADER_SETTINGS_H
+
+struct ext_editheader_header_settings {
+	pool_t pool;
+	const char *name;
+
+	bool forbid_add;
+	bool forbid_delete;
+};
+
+struct ext_editheader_settings {
+	pool_t pool;
+
+	uoff_t max_header_size;
+	ARRAY_TYPE(const_string) headers;
+};
+
+extern const struct setting_parser_info ext_editheader_header_setting_parser_info;
+extern const struct setting_parser_info ext_editheader_setting_parser_info;
+
+#endif

src/plugins/settings/Makefile.am

@@ -4,6 +4,7 @@ AM_CPPFLAGS = \
 	$(LIBDOVECOT_INCLUDE) \
 	-I$(top_srcdir) \
 	-I$(top_srcdir)/src/lib-sieve \
+	-I$(top_srcdir)/src/lib-sieve/util \
 	-I$(top_srcdir)/src/lib-sieve/storage/ldap \
 	-I$(top_srcdir)/src/lib-managesieve \
 	-DSETTINGS_PLUGIN

src/plugins/settings/settings-get.pl

@@ -24,6 +24,7 @@ print '#include "unichar.h"'."\n";
 print '#include "hash-method.h"'."\n";
 print '#include "settings.h"'."\n";
 print '#include "message-header-parser.h"'."\n";
+print '#include "rfc2822.h"'."\n";
 print '#include "sieve-common.h"'."\n";
 print '#include "sieve-limits.h"'."\n";
 print '#include "sieve-address-source.h"'."\n";

tests/extensions/editheader/errors.svtest

@@ -99,7 +99,7 @@ test "Size limit" {
  * TEST - Size limit at runtime
  */
 
-test_config_set "sieve_editheader_max_header_size" "";
+test_config_unset "sieve_editheader_max_header_size";
 test_config_reload :extension "editheader";
 
 test "Size limit at runtime" {

tests/extensions/editheader/protected.svtest

@@ -45,7 +45,16 @@ test "Default protected" {
 	}
 }
 
-test_config_set "sieve_editheader_protected" "subject delivery-date x-frop";
+test_config_set "sieve_editheader_header" "subject delivery-date x-frop";
+test_config_set "sieve_editheader_header/subject/name" "subject";
+test_config_set "sieve_editheader_header/subject/forbid_add" "yes";
+test_config_set "sieve_editheader_header/subject/forbid_delete" "yes";
+test_config_set "sieve_editheader_header/delivery-date/name" "delivery-date";
+test_config_set "sieve_editheader_header/delivery-date/forbid_add" "yes";
+test_config_set "sieve_editheader_header/delivery-date/forbid_delete" "yes";
+test_config_set "sieve_editheader_header/x-frop/name" "x-frop";
+test_config_set "sieve_editheader_header/x-frop/forbid_add" "yes";
+test_config_set "sieve_editheader_header/x-frop/forbid_delete" "yes";
 test_config_reload :extension "editheader";
 
 test_set "message" "${message}";
@@ -79,9 +88,13 @@ test "Configured protected" {
 	}
 }
 
-test_config_set "sieve_editheader_protected" "";
-test_config_set "sieve_editheader_forbid_add" "subject x-frop";
-test_config_set "sieve_editheader_forbid_delete" "subject x-friep";
+test_config_set "sieve_editheader_header" "subject X-Friep x-frop";
+test_config_set "sieve_editheader_header/subject/name" "subject";
+test_config_set "sieve_editheader_header/subject/forbid_add" "yes";
+test_config_set "sieve_editheader_header/subject/forbid_delete" "yes";
+test_config_set "sieve_editheader_header/X-Friep/name" "X-Friep";
+test_config_set "sieve_editheader_header/X-Friep/forbid_add" "yes";
+test_config_set "sieve_editheader_header/X-Friep/forbid_delete" "yes";
 test_config_reload :extension "editheader";
 
 test_set "message" "${message}";
@@ -148,26 +161,3 @@ id 3jhl22khhf23f; Mon, 24 Aug 2015 04:11:54 -0600;
 		test_fail "autosubmitted header was not added";
 	}
 }
-
-/*
- * TEST - Bad header configuration
- */
-
-test_config_set "sieve_editheader_protected" "${unicode:1F4A9} delivery-date";
-test_config_reload :extension "editheader";
-
-test_set "message" "${message}";
-test "Bad header configuration" {
-	if not exists "delivery-date" {
-		test_fail "delivery-date header did not exist in the first place";
-	}
-
-	deleteheader "delivery-date";
-
-	if not exists "delivery-date" {
-		test_fail "protected delivery-date header was deleted";
-	}
-}
-
-test_config_set "sieve_editheader_protected" "";
-test_config_reload :extension "editheader";