diff --git a/src/lib-sieve/plugins/imap4flags/cmd-flag.c b/src/lib-sieve/plugins/imap4flags/cmd-flag.c
index 52e76ba1b763485bfa797d23bbde166c5f9b4a6a..923ebcde70f15843bd6eedad7a03628d0a2d0b4a 100644
--- a/src/lib-sieve/plugins/imap4flags/cmd-flag.c
+++ b/src/lib-sieve/plugins/imap4flags/cmd-flag.c
@@ -33,7 +33,7 @@ const struct sieve_command cmd_setflag = {
 	-1, /* We check positional arguments ourselves */
 	0, FALSE, FALSE, 
 	NULL, NULL,
-	ext_imapflags_command_validate, 
+	ext_imap4flags_command_validate, 
 	cmd_flag_generate, 
 	NULL 
 };
@@ -50,7 +50,7 @@ const struct sieve_command cmd_addflag = {
 	-1, /* We check positional arguments ourselves */
 	0, FALSE, FALSE, 
 	NULL, NULL,
-	ext_imapflags_command_validate, 
+	ext_imap4flags_command_validate, 
 	cmd_flag_generate, 
 	NULL 
 };
@@ -68,7 +68,7 @@ const struct sieve_command cmd_removeflag = {
 	-1, /* We check positional arguments ourselves */
 	0, FALSE, FALSE, 
 	NULL, NULL,
-	ext_imapflags_command_validate, 
+	ext_imap4flags_command_validate, 
 	cmd_flag_generate, 
 	NULL 
 };
@@ -91,7 +91,7 @@ static int cmd_flag_operation_execute
 const struct sieve_operation setflag_operation = { 
 	"SETFLAG",
 	&imapflags_extension,
-	EXT_IMAPFLAGS_OPERATION_SETFLAG,
+	ext_imap4flags_OPERATION_SETFLAG,
 	cmd_flag_operation_dump,
 	cmd_flag_operation_execute
 };
@@ -101,7 +101,7 @@ const struct sieve_operation setflag_operation = {
 const struct sieve_operation addflag_operation = { 
 	"ADDFLAG",
 	&imapflags_extension,
-	EXT_IMAPFLAGS_OPERATION_ADDFLAG,
+	ext_imap4flags_OPERATION_ADDFLAG,
 	cmd_flag_operation_dump,	
 	cmd_flag_operation_execute
 };
@@ -111,7 +111,7 @@ const struct sieve_operation addflag_operation = {
 const struct sieve_operation removeflag_operation = { 
 	"REMOVEFLAG",
 	&imapflags_extension,
-	EXT_IMAPFLAGS_OPERATION_REMOVEFLAG,
+	ext_imap4flags_OPERATION_REMOVEFLAG,
 	cmd_flag_operation_dump, 
 	cmd_flag_operation_execute 
 };
@@ -238,11 +238,11 @@ static int cmd_flag_operation_execute
 	/* Determine what to do */
 
 	if ( op == &setflag_operation )
-		flag_op = ext_imapflags_set_flags;
+		flag_op = ext_imap4flags_set_flags;
 	else if ( op == &addflag_operation )
-		flag_op = ext_imapflags_add_flags;
+		flag_op = ext_imap4flags_add_flags;
 	else if ( op == &removeflag_operation )
-		flag_op = ext_imapflags_remove_flags;
+		flag_op = ext_imap4flags_remove_flags;
 	else
 		i_unreached();
 
diff --git a/src/lib-sieve/plugins/imap4flags/ext-imap4flags-common.c b/src/lib-sieve/plugins/imap4flags/ext-imap4flags-common.c
index afe0d843c3542d8cb10bc09035b7a65086442a10..f8f0448e4e7d89aa5d13c601c0e9d8e5d161e168 100644
--- a/src/lib-sieve/plugins/imap4flags/ext-imap4flags-common.c
+++ b/src/lib-sieve/plugins/imap4flags/ext-imap4flags-common.c
@@ -36,7 +36,7 @@ extern const struct sieve_argument tag_flags_implicit;
  * Common command functions 
  */
 
-bool ext_imapflags_command_validate
+bool ext_imap4flags_command_validate
 (struct sieve_validator *validator, struct sieve_command_context *cmd)
 {
 	struct sieve_ast_argument *arg = cmd->first_positional;
@@ -118,13 +118,13 @@ bool ext_imapflags_command_validate
 		return FALSE;
 
 	if ( cmd->command != &tst_hasflag && sieve_argument_is_string_literal(arg2) ) {
-		struct ext_imapflags_iter fiter;
+		struct ext_imap4flags_iter fiter;
 		const char *flag;
 		
 		/* Warn the user about validity of verifiable flags */
-		ext_imapflags_iter_init(&fiter, sieve_ast_argument_str(arg));
+		ext_imap4flags_iter_init(&fiter, sieve_ast_argument_str(arg));
 
-		while ( (flag=ext_imapflags_iter_get_flag(&fiter)) != NULL ) {
+		while ( (flag=ext_imap4flags_iter_get_flag(&fiter)) != NULL ) {
 			if ( !flag_is_valid(flag) ) {
 				sieve_argument_validate_warning(validator, arg,
                 	"IMAP flag '%s' specified for the %s command is invalid "
@@ -142,7 +142,7 @@ bool ext_imapflags_command_validate
  * Flags tag registration 
  */
 
-void ext_imapflags_attach_flags_tag
+void ext_imap4flags_attach_flags_tag
 (struct sieve_validator *valdtr, const char *command)
 {
 	/* Register :flags tag with the command and we don't care whether it is 
@@ -163,21 +163,21 @@ void ext_imapflags_attach_flags_tag
  * Result context 
  */
 
-struct ext_imapflags_result_context {
+struct ext_imap4flags_result_context {
     string_t *internal_flags;
 };
 
-static inline struct ext_imapflags_result_context *_get_result_context
+static inline struct ext_imap4flags_result_context *_get_result_context
 (struct sieve_result *result)
 {
-	struct ext_imapflags_result_context *rctx =
-		(struct ext_imapflags_result_context *) 
+	struct ext_imap4flags_result_context *rctx =
+		(struct ext_imap4flags_result_context *) 
 		sieve_result_extension_get_context(result, &imapflags_extension);
 
 	if ( rctx == NULL ) {
 		pool_t pool = sieve_result_pool(result);
 
-		rctx =p_new(pool, struct ext_imapflags_result_context, 1);
+		rctx =p_new(pool, struct ext_imap4flags_result_context, 1);
 		rctx->internal_flags = str_new(pool, 32);
 
 		sieve_result_extension_set_context
@@ -190,7 +190,7 @@ static inline struct ext_imapflags_result_context *_get_result_context
 static string_t *_get_flags_string
 (struct sieve_result *result)
 {
-	struct ext_imapflags_result_context *ctx = 
+	struct ext_imap4flags_result_context *ctx = 
 		_get_result_context(result);
 		
 	return ctx->internal_flags;
@@ -200,7 +200,7 @@ static string_t *_get_flags_string
  * Runtime initialization 
  */
 
-static void ext_imapflags_runtime_init
+static void ext_imap4flags_runtime_init
 (const struct sieve_runtime_env *renv, void *context ATTR_UNUSED)
 {	
 	sieve_result_add_implicit_side_effect
@@ -209,7 +209,7 @@ static void ext_imapflags_runtime_init
 
 const struct sieve_interpreter_extension imapflags_interpreter_extension = {
 	&imapflags_extension,
-	ext_imapflags_runtime_init,
+	ext_imap4flags_runtime_init,
 	NULL,
 };
 
@@ -251,16 +251,16 @@ static bool flag_is_valid(const char *flag)
 	return TRUE;  
 }
 
-void ext_imapflags_iter_init
-(struct ext_imapflags_iter *iter, string_t *flags_list) 
+void ext_imap4flags_iter_init
+(struct ext_imap4flags_iter *iter, string_t *flags_list) 
 {
 	iter->flags_list = flags_list;
 	iter->offset = 0;
 	iter->last = 0;
 }
 
-const char *ext_imapflags_iter_get_flag
-(struct ext_imapflags_iter *iter) 
+const char *ext_imap4flags_iter_get_flag
+(struct ext_imap4flags_iter *iter) 
 {
 	unsigned int len = str_len(iter->flags_list);
 	const unsigned char *fp;
@@ -297,8 +297,8 @@ const char *ext_imapflags_iter_get_flag
 	return NULL;
 }
 
-static void ext_imapflags_iter_delete_last
-(struct ext_imapflags_iter *iter) 
+static void ext_imap4flags_iter_delete_last
+(struct ext_imap4flags_iter *iter) 
 {
 	iter->offset++;
 	if ( iter->offset > str_len(iter->flags_list) )
@@ -315,11 +315,11 @@ static bool flags_list_flag_exists
 (string_t *flags_list, const char *flag)
 {
 	const char *flg;
-	struct ext_imapflags_iter flit;
+	struct ext_imap4flags_iter flit;
 		
-	ext_imapflags_iter_init(&flit, flags_list);
+	ext_imap4flags_iter_init(&flit, flags_list);
 	
-	while ( (flg=ext_imapflags_iter_get_flag(&flit)) != NULL ) {
+	while ( (flg=ext_imap4flags_iter_get_flag(&flit)) != NULL ) {
 		if ( strcasecmp(flg, flag) == 0 ) 
 			return TRUE; 	
 	}
@@ -331,13 +331,13 @@ static void flags_list_flag_delete
 (string_t *flags_list, const char *flag)
 {
 	const char *flg;
-	struct ext_imapflags_iter flit;
+	struct ext_imap4flags_iter flit;
 		
-	ext_imapflags_iter_init(&flit, flags_list);
+	ext_imap4flags_iter_init(&flit, flags_list);
 	
-	while ( (flg=ext_imapflags_iter_get_flag(&flit)) != NULL ) {
+	while ( (flg=ext_imap4flags_iter_get_flag(&flit)) != NULL ) {
 		if ( strcasecmp(flg, flag) == 0 ) {
-			ext_imapflags_iter_delete_last(&flit);
+			ext_imap4flags_iter_delete_last(&flit);
 		} 	
 	}
 }
@@ -346,11 +346,11 @@ static void flags_list_add_flags
 (string_t *flags_list, string_t *flags)
 {	
 	const char *flg;
-	struct ext_imapflags_iter flit;
+	struct ext_imap4flags_iter flit;
 		
-	ext_imapflags_iter_init(&flit, flags);
+	ext_imap4flags_iter_init(&flit, flags);
 	
-	while ( (flg=ext_imapflags_iter_get_flag(&flit)) != NULL ) {
+	while ( (flg=ext_imap4flags_iter_get_flag(&flit)) != NULL ) {
 		if ( flag_is_valid(flg) && !flags_list_flag_exists(flags_list, flg) ) {
 			if ( str_len(flags_list) != 0 ) 
 				str_append_c(flags_list, ' '); 
@@ -363,11 +363,11 @@ static void flags_list_remove_flags
 (string_t *flags_list, string_t *flags)
 {	
 	const char *flg;
-	struct ext_imapflags_iter flit;
+	struct ext_imap4flags_iter flit;
 		
-	ext_imapflags_iter_init(&flit, flags);
+	ext_imap4flags_iter_init(&flit, flags);
 	
-	while ( (flg=ext_imapflags_iter_get_flag(&flit)) != NULL ) {
+	while ( (flg=ext_imap4flags_iter_get_flag(&flit)) != NULL ) {
 		flags_list_flag_delete(flags_list, flg); 	
 	}
 }
@@ -383,7 +383,7 @@ static void flags_list_set_flags
  * Flag registration 
  */
 
-int ext_imapflags_set_flags
+int ext_imap4flags_set_flags
 (const struct sieve_runtime_env *renv, struct sieve_variable_storage *storage,
 	unsigned int var_index, string_t *flags)
 {
@@ -401,7 +401,7 @@ int ext_imapflags_set_flags
 	return SIEVE_EXEC_OK;
 }
 
-int ext_imapflags_add_flags
+int ext_imap4flags_add_flags
 (const struct sieve_runtime_env *renv, struct sieve_variable_storage *storage,
 	unsigned int var_index, string_t *flags)
 {
@@ -419,7 +419,7 @@ int ext_imapflags_add_flags
 	return SIEVE_EXEC_OK;	
 }
 
-int ext_imapflags_remove_flags
+int ext_imap4flags_remove_flags
 (const struct sieve_runtime_env *renv, struct sieve_variable_storage *storage,
 	unsigned int var_index, string_t *flags)
 {
@@ -437,7 +437,7 @@ int ext_imapflags_remove_flags
 	return SIEVE_EXEC_OK;
 }
 
-int ext_imapflags_get_flags_string
+int ext_imap4flags_get_flags_string
 (const struct sieve_runtime_env *renv, struct sieve_variable_storage *storage, 
 	unsigned int var_index, const char **flags)
 {
@@ -457,8 +457,8 @@ int ext_imapflags_get_flags_string
 	return SIEVE_EXEC_OK;
 }
 
-void ext_imapflags_get_flags_init
-(struct ext_imapflags_iter *iter, const struct sieve_runtime_env *renv,
+void ext_imap4flags_get_flags_init
+(struct ext_imap4flags_iter *iter, const struct sieve_runtime_env *renv,
 	string_t *flags_list)
 {
 	string_t *cur_flags;
@@ -471,15 +471,15 @@ void ext_imapflags_get_flags_init
 	else
 		cur_flags = _get_flags_string(renv->result);
 	
-	ext_imapflags_iter_init(iter, cur_flags);		
+	ext_imap4flags_iter_init(iter, cur_flags);		
 }
 
-void ext_imapflags_get_implicit_flags_init
-(struct ext_imapflags_iter *iter, struct sieve_result *result)
+void ext_imap4flags_get_implicit_flags_init
+(struct ext_imap4flags_iter *iter, struct sieve_result *result)
 {
 	string_t *cur_flags = _get_flags_string(result);
 	
-	ext_imapflags_iter_init(iter, cur_flags);		
+	ext_imap4flags_iter_init(iter, cur_flags);		
 }
 
 
diff --git a/src/lib-sieve/plugins/imap4flags/ext-imap4flags-common.h b/src/lib-sieve/plugins/imap4flags/ext-imap4flags-common.h
index abbe35c049228da9cd224828c376a2e29ece9163..5e3a304753deb93242224e00517e4b763330de85 100644
--- a/src/lib-sieve/plugins/imap4flags/ext-imap4flags-common.h
+++ b/src/lib-sieve/plugins/imap4flags/ext-imap4flags-common.h
@@ -33,11 +33,11 @@ extern const struct sieve_operand flags_side_effect_operand;
  * Operations
  */
  
-enum ext_imapflags_opcode {
-	EXT_IMAPFLAGS_OPERATION_SETFLAG,
-	EXT_IMAPFLAGS_OPERATION_ADDFLAG,
-	EXT_IMAPFLAGS_OPERATION_REMOVEFLAG,
-	EXT_IMAPFLAGS_OPERATION_HASFLAG
+enum ext_imap4flags_opcode {
+	ext_imap4flags_OPERATION_SETFLAG,
+	ext_imap4flags_OPERATION_ADDFLAG,
+	ext_imap4flags_OPERATION_REMOVEFLAG,
+	ext_imap4flags_OPERATION_HASFLAG
 };
 
 extern const struct sieve_operation setflag_operation;
@@ -59,43 +59,43 @@ extern const struct sieve_command tst_hasflag;
  * Common command functions
  */
 
-bool ext_imapflags_command_validate
+bool ext_imap4flags_command_validate
 	(struct sieve_validator *validator, struct sieve_command_context *cmd);
 
 /*
  * Flags tagged argument
  */	
 	
-void ext_imapflags_attach_flags_tag
+void ext_imap4flags_attach_flags_tag
 	(struct sieve_validator *valdtr, const char *command);
 
 /* 
  * Flag management 
  */
 
-struct ext_imapflags_iter {
+struct ext_imap4flags_iter {
 	string_t *flags_list;
 	unsigned int offset;
 	unsigned int last;
 };
 
-void ext_imapflags_iter_init
-	(struct ext_imapflags_iter *iter, string_t *flags_list);
+void ext_imap4flags_iter_init
+	(struct ext_imap4flags_iter *iter, string_t *flags_list);
 	
-const char *ext_imapflags_iter_get_flag
-	(struct ext_imapflags_iter *iter);
+const char *ext_imap4flags_iter_get_flag
+	(struct ext_imap4flags_iter *iter);
 
 typedef int (*ext_imapflag_flag_operation_t)
 	(const struct sieve_runtime_env *renv, struct sieve_variable_storage *storage,
 		unsigned int var_index, string_t *flags);
 
-int ext_imapflags_set_flags
+int ext_imap4flags_set_flags
 	(const struct sieve_runtime_env *renv, struct sieve_variable_storage *storage,
 		unsigned int var_index, string_t *flags);
-int ext_imapflags_add_flags
+int ext_imap4flags_add_flags
 	(const struct sieve_runtime_env *renv, struct sieve_variable_storage *storage,
 		unsigned int var_index, string_t *flags);
-int ext_imapflags_remove_flags
+int ext_imap4flags_remove_flags
 	(const struct sieve_runtime_env *renv, struct sieve_variable_storage *storage,
 		unsigned int var_index, string_t *flags);
 
@@ -103,16 +103,16 @@ int ext_imapflags_remove_flags
  * Flags access
  */
 
-int ext_imapflags_get_flags_string
+int ext_imap4flags_get_flags_string
 (const struct sieve_runtime_env *renv, struct sieve_variable_storage *storage, 
 	unsigned int var_index, const char **flags);
 
-void ext_imapflags_get_flags_init
-	(struct ext_imapflags_iter *iter, const struct sieve_runtime_env *renv,
+void ext_imap4flags_get_flags_init
+	(struct ext_imap4flags_iter *iter, const struct sieve_runtime_env *renv,
 		string_t *flags_list);
-void ext_imapflags_get_implicit_flags_init
-	(struct ext_imapflags_iter *iter, struct sieve_result *result);
+void ext_imap4flags_get_implicit_flags_init
+	(struct ext_imap4flags_iter *iter, struct sieve_result *result);
 
 
-#endif /* __EXT_IMAPFLAGS_COMMON_H */
+#endif /* __EXT_IMAP4FLAGS_COMMON_H */
 
diff --git a/src/lib-sieve/plugins/imap4flags/ext-imap4flags.c b/src/lib-sieve/plugins/imap4flags/ext-imap4flags.c
index 23dc756771dc1161828678de0ef92b4d33dd0f73..9e90ea1ad33daf767d553d90a995682d8fd6172a 100644
--- a/src/lib-sieve/plugins/imap4flags/ext-imap4flags.c
+++ b/src/lib-sieve/plugins/imap4flags/ext-imap4flags.c
@@ -42,25 +42,25 @@ const struct sieve_operation *imapflags_operations[] = {
  * Extension
  */
 
-static bool ext_imapflags_validator_load(struct sieve_validator *valdtr);
-static bool ext_imapflags_interpreter_load
+static bool ext_imap4flags_validator_load(struct sieve_validator *valdtr);
+static bool ext_imap4flags_interpreter_load
 	(const struct sieve_runtime_env *renv, sieve_size_t *address);
 
-int ext_imapflags_my_id = -1;
+int ext_imap4flags_my_id = -1;
 
 const struct sieve_extension imapflags_extension = { 
 	"imap4flags", 
-	&ext_imapflags_my_id,
+	&ext_imap4flags_my_id,
 	NULL, NULL,
-	ext_imapflags_validator_load, 
+	ext_imap4flags_validator_load, 
 	NULL, 
-	ext_imapflags_interpreter_load, 
+	ext_imap4flags_interpreter_load, 
 	NULL, NULL, NULL,
 	SIEVE_EXT_DEFINE_OPERATIONS(imapflags_operations), 
 	SIEVE_EXT_DEFINE_OPERAND(flags_side_effect_operand)
 };
 
-static bool ext_imapflags_validator_load
+static bool ext_imap4flags_validator_load
 (struct sieve_validator *valdtr)
 {
 	/* Register commands */
@@ -69,13 +69,13 @@ static bool ext_imapflags_validator_load
 	sieve_validator_register_command(valdtr, &cmd_removeflag);
 	sieve_validator_register_command(valdtr, &tst_hasflag);
 	
-	ext_imapflags_attach_flags_tag(valdtr, "keep");
-	ext_imapflags_attach_flags_tag(valdtr, "fileinto");
+	ext_imap4flags_attach_flags_tag(valdtr, "keep");
+	ext_imap4flags_attach_flags_tag(valdtr, "fileinto");
 
 	return TRUE;
 }
 
-static bool ext_imapflags_interpreter_load
+static bool ext_imap4flags_interpreter_load
 (const struct sieve_runtime_env *renv, sieve_size_t *address ATTR_UNUSED)
 {
 	sieve_interpreter_extension_register
diff --git a/src/lib-sieve/plugins/imap4flags/tag-flags.c b/src/lib-sieve/plugins/imap4flags/tag-flags.c
index b08708d64f26fa613a632cc505160fa698c65330..14fc9eadc4b8895b6141ab07748d109162343916 100644
--- a/src/lib-sieve/plugins/imap4flags/tag-flags.c
+++ b/src/lib-sieve/plugins/imap4flags/tag-flags.c
@@ -212,7 +212,7 @@ static struct seff_flags_context *seff_flags_get_implicit_context
 	pool_t pool = sieve_result_pool(result);
 	struct seff_flags_context *ctx;
 	const char *flag;
-	struct ext_imapflags_iter flit;
+	struct ext_imap4flags_iter flit;
 	
 	ctx = p_new(pool, struct seff_flags_context, 1);
 	p_array_init(&ctx->keywords, pool, 2);
@@ -220,8 +220,8 @@ static struct seff_flags_context *seff_flags_get_implicit_context
 	T_BEGIN {
 		
 		/* Unpack */
-		ext_imapflags_get_implicit_flags_init(&flit, result);
-		while ( (flag=ext_imapflags_iter_get_flag(&flit)) != NULL ) {		
+		ext_imap4flags_get_implicit_flags_init(&flit, result);
+		while ( (flag=ext_imap4flags_iter_get_flag(&flit)) != NULL ) {		
 			if (flag != NULL && *flag != '\\') {
 				/* keyword */
 				const char *keyword = p_strdup(pool, flag);
@@ -294,11 +294,11 @@ static bool seff_flags_read_context
 	while ( (result=sieve_coded_stringlist_next_item(flag_list, &flags_item)) && 
 		flags_item != NULL ) {
 		const char *flag;
-		struct ext_imapflags_iter flit;
+		struct ext_imap4flags_iter flit;
 
-		ext_imapflags_iter_init(&flit, flags_item);
+		ext_imap4flags_iter_init(&flit, flags_item);
 	
-		while ( (flag=ext_imapflags_iter_get_flag(&flit)) != NULL ) {		
+		while ( (flag=ext_imap4flags_iter_get_flag(&flit)) != NULL ) {		
 			if (flag != NULL && *flag != '\\') {
 				/* keyword */
 				const char *keyword = p_strdup(pool, flag);
diff --git a/src/lib-sieve/plugins/imap4flags/tst-hasflag.c b/src/lib-sieve/plugins/imap4flags/tst-hasflag.c
index 62a562b26b7638601f4a55fc33fed76ae41b5d1c..8326ba0c33e9ac707ab1e1e887e0b209ee9e04d1 100644
--- a/src/lib-sieve/plugins/imap4flags/tst-hasflag.c
+++ b/src/lib-sieve/plugins/imap4flags/tst-hasflag.c
@@ -57,7 +57,7 @@ static int tst_hasflag_operation_execute
 const struct sieve_operation hasflag_operation = { 
 	"HASFLAG",
 	&imapflags_extension,
-	EXT_IMAPFLAGS_OPERATION_HASFLAG,
+	ext_imap4flags_OPERATION_HASFLAG,
 	tst_hasflag_operation_dump,
 	tst_hasflag_operation_execute
 };
@@ -95,7 +95,7 @@ static bool tst_hasflag_validate
 	struct sieve_ast_argument *vars = tst->first_positional;
 	struct sieve_ast_argument *keys = sieve_ast_argument_next(vars);
 		
-	if ( !ext_imapflags_command_validate(validator, tst) )
+	if ( !ext_imap4flags_command_validate(validator, tst) )
 		return FALSE;
 	
 	if ( keys == NULL ) {
@@ -166,9 +166,9 @@ static bool tst_hasflag_operation_dump
 static int _flag_key_extract_init
 (void **context, string_t *raw_key)
 {
-	struct ext_imapflags_iter *iter = t_new(struct ext_imapflags_iter, 1);
+	struct ext_imap4flags_iter *iter = t_new(struct ext_imap4flags_iter, 1);
 	
-	ext_imapflags_iter_init(iter, raw_key);
+	ext_imap4flags_iter_init(iter, raw_key);
 	
 	*context = iter; 
 	
@@ -178,9 +178,9 @@ static int _flag_key_extract_init
 static int _flag_key_extract
 (void *context, const char **key, size_t *size)
 {
-	struct ext_imapflags_iter *iter = (struct ext_imapflags_iter *) context;
+	struct ext_imap4flags_iter *iter = (struct ext_imap4flags_iter *) context;
 	
-	if ( (*key = ext_imapflags_iter_get_flag(iter)) != NULL ) {
+	if ( (*key = ext_imap4flags_iter_get_flag(iter)) != NULL ) {
 		*size = strlen(*key); 
 		return TRUE;
 	}
@@ -204,7 +204,7 @@ static int tst_hasflag_operation_execute
 	const struct sieve_match_type *mtch = &is_match_type;
 	struct sieve_match_context *mctx;
 	struct sieve_coded_stringlist *flag_list, *variables_list = NULL;
-	struct ext_imapflags_iter iter;
+	struct ext_imap4flags_iter iter;
 	const char *flag;
 	bool matched;
 	
@@ -260,8 +260,8 @@ static int tst_hasflag_operation_execute
 			(result=sieve_coded_stringlist_next_item(variables_list, &var_item)) 
 			&& var_item != NULL ) {
 		
-			ext_imapflags_get_flags_init(&iter, renv, var_item);	
-			while ( !matched && (flag=ext_imapflags_iter_get_flag(&iter)) != NULL ) {
+			ext_imap4flags_get_flags_init(&iter, renv, var_item);	
+			while ( !matched && (flag=ext_imap4flags_iter_get_flag(&iter)) != NULL ) {
 				if ( (mret=sieve_match_value(mctx, flag, strlen(flag))) < 0 ) {
 					result = FALSE;
 					break;
@@ -271,8 +271,8 @@ static int tst_hasflag_operation_execute
 			}
 		}
 	} else {
-		ext_imapflags_get_flags_init(&iter, renv, NULL);	
-		while ( !matched && (flag=ext_imapflags_iter_get_flag(&iter)) != NULL ) {
+		ext_imap4flags_get_flags_init(&iter, renv, NULL);	
+		while ( !matched && (flag=ext_imap4flags_iter_get_flag(&iter)) != NULL ) {
 			if ( (mret=sieve_match_value(mctx, flag, strlen(flag))) < 0 ) {
 				result = FALSE;
 				break;