From 47a758f959846f948466e3cacc3b653c7fff98d2 Mon Sep 17 00:00:00 2001
From: Glenn Strauss <gstrauss@gluelogic.com>
Date: Sun, 13 Oct 2019 03:40:03 -0400
Subject: [PATCH] [core] inline buffer key for *_patch_connection()

handle buffer key as part of DATA_UNSET in *_patch_connection()
(instead of key being (buffer *))
---
 src/configfile.c         | 66 ++++++++++++++++++++--------------------
 src/mod_access.c         |  4 +--
 src/mod_accesslog.c      |  8 ++---
 src/mod_alias.c          |  2 +-
 src/mod_auth.c           |  6 ++--
 src/mod_authn_file.c     |  8 ++---
 src/mod_authn_gssapi.c   |  6 ++--
 src/mod_authn_ldap.c     | 18 +++++------
 src/mod_authn_mysql.c    | 20 ++++++------
 src/mod_authn_pam.c      |  2 +-
 src/mod_authn_sasl.c     |  2 +-
 src/mod_cgi.c            | 12 ++++----
 src/mod_cml.c            |  8 ++---
 src/mod_compress.c       | 10 +++---
 src/mod_deflate.c        | 16 +++++-----
 src/mod_dirlisting.c     | 30 +++++++++---------
 src/mod_evasive.c        |  6 ++--
 src/mod_evhost.c         |  2 +-
 src/mod_expire.c         |  4 +--
 src/mod_extforward.c     | 10 +++---
 src/mod_fastcgi.c        |  8 ++---
 src/mod_flv_streaming.c  |  2 +-
 src/mod_geoip.c          |  4 +--
 src/mod_indexfile.c      |  4 +--
 src/mod_magnet.c         |  4 +--
 src/mod_maxminddb.c      |  6 ++--
 src/mod_mysql_vhost.c    |  2 +-
 src/mod_openssl.c        | 44 +++++++++++++--------------
 src/mod_proxy.c          | 14 ++++-----
 src/mod_redirect.c       |  4 +--
 src/mod_rewrite.c        | 12 ++++----
 src/mod_rrdtool.c        |  2 +-
 src/mod_scgi.c           | 10 +++---
 src/mod_secdownload.c    | 14 ++++-----
 src/mod_setenv.c         | 12 ++++----
 src/mod_simple_vhost.c   |  8 ++---
 src/mod_skeleton.c       |  2 +-
 src/mod_sockproxy.c      |  6 ++--
 src/mod_ssi.c            | 10 +++---
 src/mod_staticfile.c     |  6 ++--
 src/mod_status.c         |  8 ++---
 src/mod_trigger_b4_dl.c  | 16 +++++-----
 src/mod_uploadprogress.c |  2 +-
 src/mod_userdir.c        | 12 ++++----
 src/mod_usertrack.c      |  8 ++---
 src/mod_vhostdb.c        |  2 +-
 src/mod_vhostdb_dbi.c    |  2 +-
 src/mod_vhostdb_ldap.c   |  2 +-
 src/mod_vhostdb_mysql.c  |  2 +-
 src/mod_vhostdb_pgsql.c  |  2 +-
 src/mod_webdav.c         | 10 +++---
 src/mod_wstunnel.c       | 14 ++++-----
 52 files changed, 247 insertions(+), 247 deletions(-)

diff --git a/src/configfile.c b/src/configfile.c
index 3eb98e13..728dade7 100644
--- a/src/configfile.c
+++ b/src/configfile.c
@@ -694,76 +694,76 @@ void config_patch_connection(server *srv, connection *con) {
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.document-root"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.document-root"))) {
 				PATCH(document_root);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.range-requests"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.range-requests"))) {
 				PATCH(range_requests);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.error-handler"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.error-handler"))) {
 				PATCH(error_handler);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.error-handler-404"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.error-handler-404"))) {
 				PATCH(error_handler_404);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.error-intercept"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.error-intercept"))) {
 				PATCH(error_intercept);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.errorfile-prefix"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.errorfile-prefix"))) {
 				PATCH(errorfile_prefix);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("mimetype.assign"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("mimetype.assign"))) {
 				PATCH(mimetypes);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.max-keep-alive-requests"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.max-keep-alive-requests"))) {
 				PATCH(max_keep_alive_requests);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.max-keep-alive-idle"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.max-keep-alive-idle"))) {
 				PATCH(max_keep_alive_idle);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.max-write-idle"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.max-write-idle"))) {
 				PATCH(max_write_idle);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.max-read-idle"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.max-read-idle"))) {
 				PATCH(max_read_idle);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.max-request-size"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.max-request-size"))) {
 				PATCH(max_request_size);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("mimetype.use-xattr"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("mimetype.use-xattr"))) {
 				PATCH(use_xattr);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("etag.use-inode"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("etag.use-inode"))) {
 				PATCH(etag_use_inode);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("etag.use-mtime"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("etag.use-mtime"))) {
 				PATCH(etag_use_mtime);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("etag.use-size"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("etag.use-size"))) {
 				PATCH(etag_use_size);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.follow-symlink"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.follow-symlink"))) {
 				PATCH(follow_symlink);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.name"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.name"))) {
 				PATCH(server_name);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.tag"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.tag"))) {
 				PATCH(server_tag);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.stream-request-body"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.stream-request-body"))) {
 				PATCH(stream_request_body);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.stream-response-body"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.stream-response-body"))) {
 				PATCH(stream_response_body);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("connection.kbytes-per-second"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("connection.kbytes-per-second"))) {
 				PATCH(kbytes_per_second);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("debug.log-request-handling"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("debug.log-request-handling"))) {
 				PATCH(log_request_handling);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("debug.log-request-header"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("debug.log-request-header"))) {
 				PATCH(log_request_header);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("debug.log-response-header"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("debug.log-response-header"))) {
 				PATCH(log_response_header);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("debug.log-condition-handling"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("debug.log-condition-handling"))) {
 				PATCH(log_condition_handling);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("debug.log-file-not-found"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("debug.log-file-not-found"))) {
 				PATCH(log_file_not_found);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("debug.log-timeouts"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("debug.log-timeouts"))) {
 				PATCH(log_timeouts);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.protocol-http11"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.protocol-http11"))) {
 				PATCH(allow_http11);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.force-lowercase-filenames"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.force-lowercase-filenames"))) {
 				PATCH(force_lowercase_filenames);
 		      #if 0 /*(not necessary; used only at startup)*/
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.listen-backlog"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.listen-backlog"))) {
 				PATCH(listen_backlog);
 		      #endif
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.kbytes-per-second"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.kbytes-per-second"))) {
 				PATCH(global_kbytes_per_second);
 				PATCH(global_bytes_per_second_cnt);
 				con->conf.global_bytes_per_second_cnt_ptr = &s->global_bytes_per_second_cnt;
 		      #if 0 /*(not necessary; used only at startup)*/
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.socket-perms"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.socket-perms"))) {
 				PATCH(socket_perms);
 		      #endif
 			}
diff --git a/src/mod_access.c b/src/mod_access.c
index 1e7e9b2d..9dcaf1bb 100644
--- a/src/mod_access.c
+++ b/src/mod_access.c
@@ -123,9 +123,9 @@ static int mod_access_patch_connection(server *srv, connection *con, plugin_data
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.access-deny"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("url.access-deny"))) {
 				PATCH(access_deny);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.access-allow"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("url.access-allow"))) {
 				PATCH(access_allow);
 			}
 		}
diff --git a/src/mod_accesslog.c b/src/mod_accesslog.c
index 83a12423..f1bc1276 100644
--- a/src/mod_accesslog.c
+++ b/src/mod_accesslog.c
@@ -729,17 +729,17 @@ static int mod_accesslog_patch_connection(server *srv, connection *con, plugin_d
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("accesslog.filename"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("accesslog.filename"))) {
 				PATCH(access_logfile);
 				PATCH(log_access_fd);
 				PATCH(access_logbuffer);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("accesslog.format"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("accesslog.format"))) {
 				PATCH(parsed_format);
 				PATCH(last_generated_accesslog_ts_ptr);
 				PATCH(ts_accesslog_str);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("accesslog.use-syslog"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("accesslog.use-syslog"))) {
 				PATCH(use_syslog);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("accesslog.syslog-level"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("accesslog.syslog-level"))) {
 				PATCH(syslog_level);
 			}
 		}
diff --git a/src/mod_alias.c b/src/mod_alias.c
index a6212539..48f89367 100644
--- a/src/mod_alias.c
+++ b/src/mod_alias.c
@@ -143,7 +143,7 @@ static int mod_alias_patch_connection(server *srv, connection *con, plugin_data
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("alias.url"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("alias.url"))) {
 				PATCH(alias);
 			}
 		}
diff --git a/src/mod_auth.c b/src/mod_auth.c
index 4e506d3c..0c55323f 100644
--- a/src/mod_auth.c
+++ b/src/mod_auth.c
@@ -447,11 +447,11 @@ static int mod_auth_patch_connection(server *srv, connection *con, plugin_data *
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend"))) {
 				PATCH(auth_backend);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.require"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.require"))) {
 				PATCH(auth_require);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.extern-authn"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.extern-authn"))) {
 				PATCH(auth_extern_authn);
 			}
 		}
diff --git a/src/mod_authn_file.c b/src/mod_authn_file.c
index fa21892b..01142230 100644
--- a/src/mod_authn_file.c
+++ b/src/mod_authn_file.c
@@ -180,13 +180,13 @@ static int mod_authn_file_patch_connection(server *srv, connection *con, plugin_
         for (j = 0; j < dc->value->used; j++) {
             data_unset *du = dc->value->data[j];
 
-            if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.plain.groupfile"))) {
+            if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.plain.groupfile"))) {
                 PATCH(auth_plain_groupfile);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.plain.userfile"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.plain.userfile"))) {
                 PATCH(auth_plain_userfile);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.htdigest.userfile"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.htdigest.userfile"))) {
                 PATCH(auth_htdigest_userfile);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.htpasswd.userfile"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.htpasswd.userfile"))) {
                 PATCH(auth_htpasswd_userfile);
             }
         }
diff --git a/src/mod_authn_gssapi.c b/src/mod_authn_gssapi.c
index b19c6287..3e581c40 100644
--- a/src/mod_authn_gssapi.c
+++ b/src/mod_authn_gssapi.c
@@ -156,11 +156,11 @@ static int mod_authn_gssapi_patch_connection(server *srv, connection *con, plugi
         for (j = 0; j < dc->value->used; j++) {
             data_unset *du = dc->value->data[j];
 
-            if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.gssapi.keytab"))) {
+            if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.gssapi.keytab"))) {
                 PATCH(auth_gssapi_keytab);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.gssapi.principal"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.gssapi.principal"))) {
                 PATCH(auth_gssapi_principal);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.gssapi.store-creds"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.gssapi.store-creds"))) {
                 PATCH(auth_gssapi_store_creds);
             }
         }
diff --git a/src/mod_authn_ldap.c b/src/mod_authn_ldap.c
index b2d10e03..fd4d5eb1 100644
--- a/src/mod_authn_ldap.c
+++ b/src/mod_authn_ldap.c
@@ -214,24 +214,24 @@ static int mod_authn_ldap_patch_connection(server *srv, connection *con, plugin_
         for (j = 0; j < dc->value->used; j++) {
             data_unset *du = dc->value->data[j];
 
-            if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.ldap.hostname"))) {
+            if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.ldap.hostname"))) {
                 PATCH(auth_ldap_hostname);
                 p->anon_conf = s;
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.ldap.base-dn"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.ldap.base-dn"))) {
                 PATCH(auth_ldap_basedn);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.ldap.filter"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.ldap.filter"))) {
                 PATCH(auth_ldap_filter);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.ldap.ca-file"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.ldap.ca-file"))) {
                 PATCH(auth_ldap_cafile);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.ldap.starttls"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.ldap.starttls"))) {
                 PATCH(auth_ldap_starttls);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.ldap.bind-dn"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.ldap.bind-dn"))) {
                 PATCH(auth_ldap_binddn);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.ldap.bind-pw"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.ldap.bind-pw"))) {
                 PATCH(auth_ldap_bindpw);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.ldap.allow-empty-pw"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.ldap.allow-empty-pw"))) {
                 PATCH(auth_ldap_allow_empty_pw);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.ldap.groupmember"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.ldap.groupmember"))) {
                 PATCH(auth_ldap_groupmember);
             }
         }
diff --git a/src/mod_authn_mysql.c b/src/mod_authn_mysql.c
index d8842bfa..11339160 100644
--- a/src/mod_authn_mysql.c
+++ b/src/mod_authn_mysql.c
@@ -304,25 +304,25 @@ static int mod_authn_mysql_patch_connection(server *srv, connection *con, plugin
         for (j = 0; j < dc->value->used; j++) {
             data_unset *du = dc->value->data[j];
 
-            if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.mysql.host"))) {
+            if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.mysql.host"))) {
                 PATCH(auth_mysql_host);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.mysql.user"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.mysql.user"))) {
                 PATCH(auth_mysql_user);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.mysql.pass"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.mysql.pass"))) {
                 PATCH(auth_mysql_pass);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.mysql.db"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.mysql.db"))) {
                 PATCH(auth_mysql_db);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.mysql.port"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.mysql.port"))) {
                 PATCH(auth_mysql_port);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.mysql.socket"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.mysql.socket"))) {
                 PATCH(auth_mysql_socket);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.mysql.users_table"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.mysql.users_table"))) {
                 PATCH(auth_mysql_users_table);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.mysql.col_user"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.mysql.col_user"))) {
                 PATCH(auth_mysql_col_user);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.mysql.col_pass"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.mysql.col_pass"))) {
                 PATCH(auth_mysql_col_pass);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.mysql.col_realm"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.mysql.col_realm"))) {
                 PATCH(auth_mysql_col_realm);
             }
         }
diff --git a/src/mod_authn_pam.c b/src/mod_authn_pam.c
index 621712ed..47bd1067 100644
--- a/src/mod_authn_pam.c
+++ b/src/mod_authn_pam.c
@@ -117,7 +117,7 @@ static int mod_authn_pam_patch_connection(server *srv, connection *con, plugin_d
         s = p->config_storage[i];
         for (size_t j = 0; j < dc->value->used; ++j) {
             data_unset *du = dc->value->data[j];
-            if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.pam.opts"))) {
+            if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.pam.opts"))) {
                 PATCH(service);
             }
         }
diff --git a/src/mod_authn_sasl.c b/src/mod_authn_sasl.c
index 344cf561..d19e1716 100644
--- a/src/mod_authn_sasl.c
+++ b/src/mod_authn_sasl.c
@@ -167,7 +167,7 @@ static int mod_authn_sasl_patch_connection(server *srv, connection *con, plugin_
         s = p->config_storage[i];
         for (size_t j = 0; j < dc->value->used; ++j) {
             data_unset *du = dc->value->data[j];
-            if (buffer_is_equal_string(du->key, CONST_STR_LEN("auth.backend.sasl.opts"))) {
+            if (buffer_is_equal_string(&du->key, CONST_STR_LEN("auth.backend.sasl.opts"))) {
                 PATCH(service);
                 PATCH(fqdn);
                 PATCH(pwcheck_method);
diff --git a/src/mod_cgi.c b/src/mod_cgi.c
index c49f522e..a0f028e9 100644
--- a/src/mod_cgi.c
+++ b/src/mod_cgi.c
@@ -884,17 +884,17 @@ static int mod_cgi_patch_connection(server *srv, connection *con, plugin_data *p
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("cgi.assign"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("cgi.assign"))) {
 				PATCH(cgi);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("cgi.execute-x-only"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("cgi.execute-x-only"))) {
 				PATCH(execute_x_only);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("cgi.local-redir"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("cgi.local-redir"))) {
 				PATCH(local_redir);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("cgi.upgrade"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("cgi.upgrade"))) {
 				PATCH(upgrade);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("cgi.x-sendfile"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("cgi.x-sendfile"))) {
 				PATCH(xsendfile_allow);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("cgi.x-sendfile-docroot"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("cgi.x-sendfile-docroot"))) {
 				PATCH(xsendfile_docroot);
 			}
 		}
diff --git a/src/mod_cml.c b/src/mod_cml.c
index 16ecdfd5..367da6f5 100644
--- a/src/mod_cml.c
+++ b/src/mod_cml.c
@@ -179,15 +179,15 @@ static int mod_cml_patch_connection(server *srv, connection *con, plugin_data *p
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("cml.extension"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("cml.extension"))) {
 				PATCH(ext);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("cml.memcache-hosts"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("cml.memcache-hosts"))) {
 #if defined(USE_MEMCACHED)
 				PATCH(memc);
 #endif
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("cml.memcache-namespace"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("cml.memcache-namespace"))) {
 				PATCH(mc_namespace);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("cml.power-magnet"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("cml.power-magnet"))) {
 				PATCH(power_magnet);
 			}
 		}
diff --git a/src/mod_compress.c b/src/mod_compress.c
index 656796f2..ee5664eb 100644
--- a/src/mod_compress.c
+++ b/src/mod_compress.c
@@ -765,15 +765,15 @@ static int mod_compress_patch_connection(server *srv, connection *con, plugin_da
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("compress.cache-dir"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("compress.cache-dir"))) {
 				PATCH(compress_cache_dir);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("compress.filetype"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("compress.filetype"))) {
 				PATCH(compress);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("compress.max-filesize"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("compress.max-filesize"))) {
 				PATCH(compress_max_filesize);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("compress.allowed-encodings"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("compress.allowed-encodings"))) {
 				PATCH(allowed_encodings);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("compress.max-loadavg"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("compress.max-loadavg"))) {
 				PATCH(max_loadavg);
 			}
 		}
diff --git a/src/mod_deflate.c b/src/mod_deflate.c
index 5eb93ec9..559b6c49 100644
--- a/src/mod_deflate.c
+++ b/src/mod_deflate.c
@@ -965,21 +965,21 @@ static int mod_deflate_patch_connection(server *srv, connection *con, plugin_dat
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.mimetypes"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("deflate.mimetypes"))) {
 				PATCH(mimetypes);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.allowed-encodings"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("deflate.allowed-encodings"))) {
 				PATCH(allowed_encodings);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.max-compress-size"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("deflate.max-compress-size"))) {
 				PATCH(max_compress_size);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.min-compress-size"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("deflate.min-compress-size"))) {
 				PATCH(min_compress_size);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.compression-level"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("deflate.compression-level"))) {
 				PATCH(compression_level);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.output-buffer-size"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("deflate.output-buffer-size"))) {
 				PATCH(output_buffer_size);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.work-block-size"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("deflate.work-block-size"))) {
 				PATCH(work_block_size);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("deflate.max-loadavg"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("deflate.max-loadavg"))) {
 				PATCH(max_loadavg);
 			}
 		}
diff --git a/src/mod_dirlisting.c b/src/mod_dirlisting.c
index 60d413aa..32796644 100644
--- a/src/mod_dirlisting.c
+++ b/src/mod_dirlisting.c
@@ -368,34 +368,34 @@ static int mod_dirlisting_patch_connection(server *srv, connection *con, plugin_
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_ACTIVATE)) ||
-			    buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_DIR_LISTING))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN(CONFIG_ACTIVATE)) ||
+			    buffer_is_equal_string(&du->key, CONST_STR_LEN(CONFIG_DIR_LISTING))) {
 				PATCH(dir_listing);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_HIDE_DOTFILES))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN(CONFIG_HIDE_DOTFILES))) {
 				PATCH(hide_dot_files);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_EXTERNAL_CSS))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN(CONFIG_EXTERNAL_CSS))) {
 				PATCH(external_css);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_EXTERNAL_JS))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN(CONFIG_EXTERNAL_JS))) {
 				PATCH(external_js);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_ENCODING))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN(CONFIG_ENCODING))) {
 				PATCH(encoding);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_SHOW_README))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN(CONFIG_SHOW_README))) {
 				PATCH(show_readme);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_HIDE_README_FILE))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN(CONFIG_HIDE_README_FILE))) {
 				PATCH(hide_readme_file);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_SHOW_HEADER))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN(CONFIG_SHOW_HEADER))) {
 				PATCH(show_header);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_HIDE_HEADER_FILE))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN(CONFIG_HIDE_HEADER_FILE))) {
 				PATCH(hide_header_file);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_SET_FOOTER))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN(CONFIG_SET_FOOTER))) {
 				PATCH(set_footer);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_EXCLUDE))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN(CONFIG_EXCLUDE))) {
 				PATCH(excludes);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_ENCODE_README))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN(CONFIG_ENCODE_README))) {
 				PATCH(encode_readme);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_ENCODE_HEADER))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN(CONFIG_ENCODE_HEADER))) {
 				PATCH(encode_header);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN(CONFIG_AUTO_LAYOUT))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN(CONFIG_AUTO_LAYOUT))) {
 				PATCH(auto_layout);
 			}
 		}
diff --git a/src/mod_evasive.c b/src/mod_evasive.c
index 3857973d..93e86c2c 100644
--- a/src/mod_evasive.c
+++ b/src/mod_evasive.c
@@ -132,11 +132,11 @@ static int mod_evasive_patch_connection(server *srv, connection *con, plugin_dat
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("evasive.max-conns-per-ip"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("evasive.max-conns-per-ip"))) {
 				PATCH(max_conns);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("evasive.silent"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("evasive.silent"))) {
 				PATCH(silent);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("evasive.location"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("evasive.location"))) {
 				PATCH(location);
 			}
 		}
diff --git a/src/mod_evhost.c b/src/mod_evhost.c
index 1f5c1f4d..eb2f8788 100644
--- a/src/mod_evhost.c
+++ b/src/mod_evhost.c
@@ -273,7 +273,7 @@ static int mod_evhost_patch_connection(server *srv, connection *con, plugin_data
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("evhost.path-pattern"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("evhost.path-pattern"))) {
 				PATCH(path_pieces);
 				PATCH(len);
 			}
diff --git a/src/mod_expire.c b/src/mod_expire.c
index 109112d2..7e762956 100644
--- a/src/mod_expire.c
+++ b/src/mod_expire.c
@@ -312,9 +312,9 @@ static int mod_expire_patch_connection(server *srv, connection *con, plugin_data
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("expire.url"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("expire.url"))) {
 				PATCH(expire_url);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("expire.mimetypes"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("expire.mimetypes"))) {
 				PATCH(expire_mimetypes);
 			}
 		}
diff --git a/src/mod_extforward.c b/src/mod_extforward.c
index 1f023a6e..5c43bddd 100644
--- a/src/mod_extforward.c
+++ b/src/mod_extforward.c
@@ -397,17 +397,17 @@ static int mod_extforward_patch_connection(server *srv, connection *con, plugin_
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("extforward.forwarder"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("extforward.forwarder"))) {
 				PATCH(forwarder);
 				PATCH(forward_masks);
 				PATCH(forward_all);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("extforward.headers"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("extforward.headers"))) {
 				PATCH(headers);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("extforward.params"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("extforward.params"))) {
 				PATCH(opts);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("extforward.hap-PROXY"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("extforward.hap-PROXY"))) {
 				PATCH(hap_PROXY);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("extforward.hap-PROXY-ssl-client-verify"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("extforward.hap-PROXY-ssl-client-verify"))) {
 				PATCH(hap_PROXY_ssl_client_verify);
 			}
 		}
diff --git a/src/mod_fastcgi.c b/src/mod_fastcgi.c
index 50a8e3cc..c6fa1b6c 100644
--- a/src/mod_fastcgi.c
+++ b/src/mod_fastcgi.c
@@ -462,15 +462,15 @@ static int fcgi_patch_connection(server *srv, connection *con, plugin_data *p) {
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("fastcgi.server"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("fastcgi.server"))) {
 				PATCH(exts);
 				PATCH(exts_auth);
 				PATCH(exts_resp);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("fastcgi.debug"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("fastcgi.debug"))) {
 				PATCH(debug);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("fastcgi.balance"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("fastcgi.balance"))) {
 				PATCH(balance);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("fastcgi.map-extensions"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("fastcgi.map-extensions"))) {
 				PATCH(ext_mapping);
 			}
 		}
diff --git a/src/mod_flv_streaming.c b/src/mod_flv_streaming.c
index 1076aadc..950a485f 100644
--- a/src/mod_flv_streaming.c
+++ b/src/mod_flv_streaming.c
@@ -107,7 +107,7 @@ static int mod_flv_streaming_patch_connection(server *srv, connection *con, plug
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("flv-streaming.extensions"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("flv-streaming.extensions"))) {
 				PATCH(extensions);
 			}
 		}
diff --git a/src/mod_geoip.c b/src/mod_geoip.c
index a40ac8c7..69ffb8f1 100644
--- a/src/mod_geoip.c
+++ b/src/mod_geoip.c
@@ -198,11 +198,11 @@ static int mod_geoip_patch_connection(server *srv, connection *con, plugin_data
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("geoip.db-filename"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("geoip.db-filename"))) {
 				PATCH(db_name);
 			}
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("geoip.memory-cache"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("geoip.memory-cache"))) {
 				PATCH(mem_cache);
 			}
 		}
diff --git a/src/mod_indexfile.c b/src/mod_indexfile.c
index a06a4bfd..34fb8a07 100644
--- a/src/mod_indexfile.c
+++ b/src/mod_indexfile.c
@@ -131,9 +131,9 @@ static int mod_indexfile_patch_connection(server *srv, connection *con, plugin_d
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("server.indexfiles"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("server.indexfiles"))) {
 				PATCH(indexfiles);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("index-file.names"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("index-file.names"))) {
 				PATCH(indexfiles);
 			}
 		}
diff --git a/src/mod_magnet.c b/src/mod_magnet.c
index 8ad218ff..5aae757a 100644
--- a/src/mod_magnet.c
+++ b/src/mod_magnet.c
@@ -159,9 +159,9 @@ static int mod_magnet_patch_connection(server *srv, connection *con, plugin_data
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN(MAGNET_CONFIG_RAW_URL))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN(MAGNET_CONFIG_RAW_URL))) {
 				PATCH(url_raw);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN(MAGNET_CONFIG_PHYSICAL_PATH))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN(MAGNET_CONFIG_PHYSICAL_PATH))) {
 				PATCH(physical_path);
 			}
 		}
diff --git a/src/mod_maxminddb.c b/src/mod_maxminddb.c
index e3d4bac9..dbb92e7a 100644
--- a/src/mod_maxminddb.c
+++ b/src/mod_maxminddb.c
@@ -344,14 +344,14 @@ mod_maxmind_patch_connection (server * const srv,
         for (size_t j = 0; j < dc->value->used; ++j) {
             data_unset *du = dc->value->data[j];
 
-            if (buffer_is_equal_string(du->key, CONST_STR_LEN("maxminddb.activate"))) {
+            if (buffer_is_equal_string(&du->key, CONST_STR_LEN("maxminddb.activate"))) {
                 PATCH(activate);
             }
-            else if (buffer_is_equal_string(du->key, CONST_STR_LEN("maxminddb.db"))) {
+            else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("maxminddb.db"))) {
                 /*PATCH(db_name);*//*(not used)*/
                 PATCH(mmdb);
             }
-            else if (buffer_is_equal_string(du->key, CONST_STR_LEN("maxminddb.env"))) {
+            else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("maxminddb.env"))) {
                 PATCH(env);
                 PATCH(cenv);
             }
diff --git a/src/mod_mysql_vhost.c b/src/mod_mysql_vhost.c
index a61bc14f..4bf122f3 100644
--- a/src/mod_mysql_vhost.c
+++ b/src/mod_mysql_vhost.c
@@ -250,7 +250,7 @@ static int mod_mysql_vhost_patch_connection(server *srv, connection *con, plugin
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("mysql-vhost.sql"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("mysql-vhost.sql"))) {
 				PATCH(mysql_query);
 			}
 		}
diff --git a/src/mod_openssl.c b/src/mod_openssl.c
index f8c7de60..7e122a3d 100644
--- a/src/mod_openssl.c
+++ b/src/mod_openssl.c
@@ -1398,55 +1398,55 @@ mod_openssl_patch_connection (server *srv, connection *con, handler_ctx *hctx)
         for (size_t j = 0; j < dc->value->used; ++j) {
             data_unset *du = dc->value->data[j];
 
-            if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.pemfile"))) {
+            if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.pemfile"))) {
                 /*PATCH(ssl_pemfile);*//*(not patched)*/
                 /*PATCH(ssl_privkey);*//*(not patched)*/
                 PATCH(ssl_pemfile_x509);
                 PATCH(ssl_pemfile_pkey);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.ca-file"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.ca-file"))) {
                 PATCH(ssl_ca_file);
                 PATCH(ssl_ca_file_cert_names);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.ca-dn-file"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.ca-dn-file"))) {
                 PATCH(ssl_ca_dn_file);
                 PATCH(ssl_ca_file_cert_names);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.verifyclient.activate"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.verifyclient.activate"))) {
                 PATCH(ssl_verifyclient);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.verifyclient.enforce"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.verifyclient.enforce"))) {
                 PATCH(ssl_verifyclient_enforce);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.verifyclient.depth"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.verifyclient.depth"))) {
                 PATCH(ssl_verifyclient_depth);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.verifyclient.username"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.verifyclient.username"))) {
                 PATCH(ssl_verifyclient_username);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.verifyclient.exportcert"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.verifyclient.exportcert"))) {
                 PATCH(ssl_verifyclient_export_cert);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.disable-client-renegotiation"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.disable-client-renegotiation"))) {
                 PATCH(ssl_disable_client_renegotiation);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.read-ahead"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.read-ahead"))) {
                 PATCH(ssl_read_ahead);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.acme-tls-1"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.acme-tls-1"))) {
                 PATCH(ssl_acme_tls_1);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("debug.log-ssl-noise"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("debug.log-ssl-noise"))) {
                 PATCH(ssl_log_noise);
           #if 0 /*(not patched)*/
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.ca-crl-file"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.ca-crl-file"))) {
                 PATCH(ssl_ca_crl_file);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.honor-cipher-order"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.honor-cipher-order"))) {
                 PATCH(ssl_honor_cipher_order);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.empty-fragments"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.empty-fragments"))) {
                 PATCH(ssl_empty_fragments);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.use-sslv2"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.use-sslv2"))) {
                 PATCH(ssl_use_sslv2);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.use-sslv3"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.use-sslv3"))) {
                 PATCH(ssl_use_sslv3);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.cipher-list"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.cipher-list"))) {
                 PATCH(ssl_cipher_list);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.dh-file"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.dh-file"))) {
                 PATCH(ssl_dh_file);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.ec-curve"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.ec-curve"))) {
                 PATCH(ssl_ec_curve);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.engine"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.engine"))) {
                 PATCH(ssl_enabled);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssl.openssl.ssl-conf-cmd"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssl.openssl.ssl-conf-cmd"))) {
                 PATCH(ssl_conf_cmd);
           #endif
             }
diff --git a/src/mod_proxy.c b/src/mod_proxy.c
index d9c08e64..682fd743 100644
--- a/src/mod_proxy.c
+++ b/src/mod_proxy.c
@@ -900,21 +900,21 @@ static int mod_proxy_patch_connection(server *srv, connection *con, plugin_data
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("proxy.server"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("proxy.server"))) {
 				PATCH_GW(exts);
 				PATCH_GW(exts_auth);
 				PATCH_GW(exts_resp);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("proxy.debug"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("proxy.debug"))) {
 				PATCH_GW(debug);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("proxy.balance"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("proxy.balance"))) {
 				PATCH_GW(balance);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("proxy.map-extensions"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("proxy.map-extensions"))) {
 				PATCH_GW(ext_mapping);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("proxy.replace-http-host"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("proxy.replace-http-host"))) {
 				PATCH(replace_http_host);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("proxy.forwarded"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("proxy.forwarded"))) {
 				PATCH(forwarded);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("proxy.header"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("proxy.header"))) {
 				PATCH(header); /*(copies struct)*/
 			}
 		}
diff --git a/src/mod_redirect.c b/src/mod_redirect.c
index 2b9216d9..0e37aab2 100644
--- a/src/mod_redirect.c
+++ b/src/mod_redirect.c
@@ -134,10 +134,10 @@ static int mod_redirect_patch_connection(server *srv, connection *con, plugin_da
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (0 == strcmp(du->key->ptr, "url.redirect")) {
+			if (0 == strcmp(du->key.ptr, "url.redirect")) {
 				p->conf.redirect = s->redirect;
 				p->conf.context = dc;
-			} else if (0 == strcmp(du->key->ptr, "url.redirect-code")) {
+			} else if (0 == strcmp(du->key.ptr, "url.redirect-code")) {
 				p->conf.redirect_code = s->redirect_code;
 			}
 		}
diff --git a/src/mod_rewrite.c b/src/mod_rewrite.c
index 2f0577ab..a4f8e473 100644
--- a/src/mod_rewrite.c
+++ b/src/mod_rewrite.c
@@ -183,27 +183,27 @@ static int mod_rewrite_patch_connection(server *srv, connection *con, plugin_dat
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.rewrite"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("url.rewrite"))) {
 				PATCH(rewrite);
 				p->conf.context = dc;
 				PATCH(rewrite_repeat_idx);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.rewrite-once"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("url.rewrite-once"))) {
 				PATCH(rewrite);
 				p->conf.context = dc;
 				PATCH(rewrite_repeat_idx);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.rewrite-repeat"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("url.rewrite-repeat"))) {
 				PATCH(rewrite);
 				p->conf.context = dc;
 				PATCH(rewrite_repeat_idx);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.rewrite-if-not-file"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("url.rewrite-if-not-file"))) {
 				PATCH(rewrite_NF);
 				p->conf.context_NF = dc;
 				PATCH(rewrite_NF_repeat_idx);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.rewrite-repeat-if-not-file"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("url.rewrite-repeat-if-not-file"))) {
 				PATCH(rewrite_NF);
 				p->conf.context_NF = dc;
 				PATCH(rewrite_NF_repeat_idx);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.rewrite-final"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("url.rewrite-final"))) {
 				PATCH(rewrite);
 				p->conf.context = dc;
 				PATCH(rewrite_repeat_idx);
diff --git a/src/mod_rrdtool.c b/src/mod_rrdtool.c
index 9fca757d..876dafa5 100644
--- a/src/mod_rrdtool.c
+++ b/src/mod_rrdtool.c
@@ -265,7 +265,7 @@ static int mod_rrd_patch_connection(server *srv, connection *con, plugin_data *p
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("rrdtool.db-name"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("rrdtool.db-name"))) {
 				PATCH(path_rrd);
 				/* get pointers to double values */
 
diff --git a/src/mod_scgi.c b/src/mod_scgi.c
index ad002546..eeca1f55 100644
--- a/src/mod_scgi.c
+++ b/src/mod_scgi.c
@@ -251,17 +251,17 @@ static int scgi_patch_connection(server *srv, connection *con, plugin_data *p) {
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("scgi.server"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("scgi.server"))) {
 				PATCH(exts);
 				PATCH(exts_auth);
 				PATCH(exts_resp);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("scgi.protocol"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("scgi.protocol"))) {
 				PATCH(proto);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("scgi.balance"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("scgi.balance"))) {
 				PATCH(balance);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("scgi.debug"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("scgi.debug"))) {
 				PATCH(debug);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("scgi.map-extensions"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("scgi.map-extensions"))) {
 				PATCH(ext_mapping);
 			}
 		}
diff --git a/src/mod_secdownload.c b/src/mod_secdownload.c
index 28299c65..fba53c47 100644
--- a/src/mod_secdownload.c
+++ b/src/mod_secdownload.c
@@ -417,19 +417,19 @@ static int mod_secdownload_patch_connection(server *srv, connection *con, plugin
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("secdownload.secret"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("secdownload.secret"))) {
 				PATCH(secret);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("secdownload.document-root"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("secdownload.document-root"))) {
 				PATCH(doc_root);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("secdownload.uri-prefix"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("secdownload.uri-prefix"))) {
 				PATCH(uri_prefix);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("secdownload.timeout"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("secdownload.timeout"))) {
 				PATCH(timeout);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("secdownload.algorithm"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("secdownload.algorithm"))) {
 				PATCH(algorithm);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("secdownload.path-segments"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("secdownload.path-segments"))) {
 				PATCH(path_segments);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("secdownload.hash-querystr"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("secdownload.hash-querystr"))) {
 				PATCH(hash_querystr);
 			}
 		}
diff --git a/src/mod_setenv.c b/src/mod_setenv.c
index deb0849a..b4bbdb84 100644
--- a/src/mod_setenv.c
+++ b/src/mod_setenv.c
@@ -176,17 +176,17 @@ static int mod_setenv_patch_connection(server *srv, connection *con, plugin_data
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("setenv.add-request-header"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("setenv.add-request-header"))) {
 				PATCH(request_header);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("setenv.set-request-header"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("setenv.set-request-header"))) {
 				PATCH(set_request_header);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("setenv.add-response-header"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("setenv.add-response-header"))) {
 				PATCH(response_header);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("setenv.set-response-header"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("setenv.set-response-header"))) {
 				PATCH(set_response_header);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("setenv.add-environment"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("setenv.add-environment"))) {
 				PATCH(environment);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("setenv.set-environment"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("setenv.set-environment"))) {
 				PATCH(set_environment);
 			}
 		}
diff --git a/src/mod_simple_vhost.c b/src/mod_simple_vhost.c
index 711ac5c9..ef456c4f 100644
--- a/src/mod_simple_vhost.c
+++ b/src/mod_simple_vhost.c
@@ -200,16 +200,16 @@ static int mod_simple_vhost_patch_connection(server *srv, connection *con, plugi
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("simple-vhost.server-root"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("simple-vhost.server-root"))) {
 				PATCH(server_root);
 				PATCH(docroot_cache_key);
 				PATCH(docroot_cache_value);
 				PATCH(docroot_cache_servername);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("simple-vhost.default-host"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("simple-vhost.default-host"))) {
 				PATCH(default_host);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("simple-vhost.document-root"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("simple-vhost.document-root"))) {
 				PATCH(document_root);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("simple-vhost.debug"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("simple-vhost.debug"))) {
 				PATCH(debug);
 			}
 		}
diff --git a/src/mod_skeleton.c b/src/mod_skeleton.c
index 48efe648..c10954f1 100644
--- a/src/mod_skeleton.c
+++ b/src/mod_skeleton.c
@@ -135,7 +135,7 @@ static int mod_skeleton_patch_connection(server *srv, connection *con, plugin_da
 		for (size_t j = 0; j < dc->value->used; ++j) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("skeleton.array"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("skeleton.array"))) {
 				PATCH(match);
 			}
 		}
diff --git a/src/mod_sockproxy.c b/src/mod_sockproxy.c
index 4381491a..4e5b62b3 100644
--- a/src/mod_sockproxy.c
+++ b/src/mod_sockproxy.c
@@ -117,13 +117,13 @@ static int mod_sockproxy_patch_connection(server *srv, connection *con, plugin_d
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("sockproxy.server"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("sockproxy.server"))) {
 				PATCH(exts);
 				PATCH(exts_auth);
 				PATCH(exts_resp);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("sockproxy.debug"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("sockproxy.debug"))) {
 				PATCH(debug);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("sockproxy.balance"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("sockproxy.balance"))) {
 				PATCH(balance);
 			}
 		}
diff --git a/src/mod_ssi.c b/src/mod_ssi.c
index ed0b9c0d..f568ff9a 100644
--- a/src/mod_ssi.c
+++ b/src/mod_ssi.c
@@ -1282,15 +1282,15 @@ static int mod_ssi_patch_connection(server *srv, connection *con, plugin_data *p
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssi.extension"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssi.extension"))) {
 				PATCH(ssi_extension);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssi.content-type"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssi.content-type"))) {
 				PATCH(content_type);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssi.conditional-requests"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssi.conditional-requests"))) {
 				PATCH(conditional_requests);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssi.exec"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssi.exec"))) {
 				PATCH(ssi_exec);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("ssi.recursion-max"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("ssi.recursion-max"))) {
 				PATCH(ssi_recursion_max);
 			}
 		}
diff --git a/src/mod_staticfile.c b/src/mod_staticfile.c
index e858375f..68da1857 100644
--- a/src/mod_staticfile.c
+++ b/src/mod_staticfile.c
@@ -140,11 +140,11 @@ static int mod_staticfile_patch_connection(server *srv, connection *con, plugin_
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("static-file.exclude-extensions"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("static-file.exclude-extensions"))) {
 				PATCH(exclude_ext);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("static-file.etags"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("static-file.etags"))) {
 				PATCH(etags_used);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("static-file.disable-pathinfo"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("static-file.disable-pathinfo"))) {
 				PATCH(disable_pathinfo);
 			}
 		}
diff --git a/src/mod_status.c b/src/mod_status.c
index 7171521a..240b81b7 100644
--- a/src/mod_status.c
+++ b/src/mod_status.c
@@ -874,13 +874,13 @@ static int mod_status_patch_connection(server *srv, connection *con, plugin_data
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("status.status-url"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("status.status-url"))) {
 				PATCH(status_url);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("status.config-url"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("status.config-url"))) {
 				PATCH(config_url);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("status.enable-sort"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("status.enable-sort"))) {
 				PATCH(sort);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("status.statistics-url"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("status.statistics-url"))) {
 				PATCH(statistics_url);
 			}
 		}
diff --git a/src/mod_trigger_b4_dl.c b/src/mod_trigger_b4_dl.c
index c78d5c86..deebae46 100644
--- a/src/mod_trigger_b4_dl.c
+++ b/src/mod_trigger_b4_dl.c
@@ -292,27 +292,27 @@ static int mod_trigger_b4_dl_patch_connection(server *srv, connection *con, plug
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("trigger-before-download.download-url"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("trigger-before-download.download-url"))) {
 #if defined(HAVE_PCRE_H)
 				PATCH(download_regex);
 #endif
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("trigger-before-download.trigger-url"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("trigger-before-download.trigger-url"))) {
 # if defined(HAVE_PCRE_H)
 				PATCH(trigger_regex);
 # endif
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("trigger-before-download.gdbm-filename"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("trigger-before-download.gdbm-filename"))) {
 #if defined(HAVE_GDBM_H)
 				PATCH(db);
 #endif
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("trigger-before-download.trigger-timeout"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("trigger-before-download.trigger-timeout"))) {
 				PATCH(trigger_timeout);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("trigger-before-download.debug"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("trigger-before-download.debug"))) {
 				PATCH(debug);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("trigger-before-download.deny-url"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("trigger-before-download.deny-url"))) {
 				PATCH(deny_url);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("trigger-before-download.memcache-namespace"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("trigger-before-download.memcache-namespace"))) {
 				PATCH(mc_namespace);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("trigger-before-download.memcache-hosts"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("trigger-before-download.memcache-hosts"))) {
 #if defined(USE_MEMCACHED)
 				PATCH(memc);
 #endif
diff --git a/src/mod_uploadprogress.c b/src/mod_uploadprogress.c
index 80f5c257..f8503b65 100644
--- a/src/mod_uploadprogress.c
+++ b/src/mod_uploadprogress.c
@@ -237,7 +237,7 @@ static int mod_uploadprogress_patch_connection(server *srv, connection *con, plu
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("upload-progress.progress-url"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("upload-progress.progress-url"))) {
 				PATCH(progress_url);
 			}
 		}
diff --git a/src/mod_userdir.c b/src/mod_userdir.c
index 7b4aad70..72131e74 100644
--- a/src/mod_userdir.c
+++ b/src/mod_userdir.c
@@ -171,17 +171,17 @@ static int mod_userdir_patch_connection(server *srv, connection *con, plugin_dat
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("userdir.path"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("userdir.path"))) {
 				PATCH(path);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("userdir.exclude-user"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("userdir.exclude-user"))) {
 				PATCH(exclude_user);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("userdir.include-user"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("userdir.include-user"))) {
 				PATCH(include_user);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("userdir.basepath"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("userdir.basepath"))) {
 				PATCH(basepath);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("userdir.letterhomes"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("userdir.letterhomes"))) {
 				PATCH(letterhomes);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("userdir.active"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("userdir.active"))) {
 				PATCH(active);
 			}
 		}
diff --git a/src/mod_usertrack.c b/src/mod_usertrack.c
index 932c75e7..c0bb7975 100644
--- a/src/mod_usertrack.c
+++ b/src/mod_usertrack.c
@@ -165,13 +165,13 @@ static int mod_usertrack_patch_connection(server *srv, connection *con, plugin_d
 		for (j = 0; j < dc->value->used; j++) {
 			data_unset *du = dc->value->data[j];
 
-			if (buffer_is_equal_string(du->key, CONST_STR_LEN("usertrack.cookie-name"))) {
+			if (buffer_is_equal_string(&du->key, CONST_STR_LEN("usertrack.cookie-name"))) {
 				PATCH(cookie_name);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("usertrack.cookie-attrs"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("usertrack.cookie-attrs"))) {
 				PATCH(cookie_attrs);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("usertrack.cookie-max-age"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("usertrack.cookie-max-age"))) {
 				PATCH(cookie_max_age);
-			} else if (buffer_is_equal_string(du->key, CONST_STR_LEN("usertrack.cookie-domain"))) {
+			} else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("usertrack.cookie-domain"))) {
 				PATCH(cookie_domain);
 			}
 		}
diff --git a/src/mod_vhostdb.c b/src/mod_vhostdb.c
index 0ec50886..5d101d37 100644
--- a/src/mod_vhostdb.c
+++ b/src/mod_vhostdb.c
@@ -113,7 +113,7 @@ static int mod_vhostdb_patch_connection(server *srv, connection *con, plugin_dat
         for (size_t j = 0; j < dc->value->used; ++j) {
             data_unset *du = dc->value->data[j];
 
-            if (buffer_is_equal_string(du->key, CONST_STR_LEN("vhostdb.backend"))) {
+            if (buffer_is_equal_string(&du->key, CONST_STR_LEN("vhostdb.backend"))) {
                 PATCH(vhostdb_backend);
             }
         }
diff --git a/src/mod_vhostdb_dbi.c b/src/mod_vhostdb_dbi.c
index 594adcb8..aae4f2b0 100644
--- a/src/mod_vhostdb_dbi.c
+++ b/src/mod_vhostdb_dbi.c
@@ -308,7 +308,7 @@ static void mod_vhostdb_patch_connection (server *srv, connection *con, plugin_d
         for (size_t j = 0; j < dc->value->used; ++j) {
             data_unset *du = dc->value->data[j];
 
-            if (buffer_is_equal_string(du->key, CONST_STR_LEN("vhostdb.dbi"))) {
+            if (buffer_is_equal_string(&du->key, CONST_STR_LEN("vhostdb.dbi"))) {
                 PATCH(vdata);
             }
         }
diff --git a/src/mod_vhostdb_ldap.c b/src/mod_vhostdb_ldap.c
index c5a13cdd..db8b828a 100644
--- a/src/mod_vhostdb_ldap.c
+++ b/src/mod_vhostdb_ldap.c
@@ -536,7 +536,7 @@ static void mod_vhostdb_patch_connection (server *srv, connection *con, plugin_d
         for (size_t j = 0; j < dc->value->used; ++j) {
             data_unset *du = dc->value->data[j];
 
-            if (buffer_is_equal_string(du->key,CONST_STR_LEN("vhostdb.ldap"))) {
+            if (buffer_is_equal_string(&du->key,CONST_STR_LEN("vhostdb.ldap"))) {
                 PATCH(vdata);
             }
         }
diff --git a/src/mod_vhostdb_mysql.c b/src/mod_vhostdb_mysql.c
index 236fb9af..cc97ed52 100644
--- a/src/mod_vhostdb_mysql.c
+++ b/src/mod_vhostdb_mysql.c
@@ -272,7 +272,7 @@ static void mod_vhostdb_patch_connection (server *srv, connection *con, plugin_d
         for (size_t j = 0; j < dc->value->used; ++j) {
             data_unset *du = dc->value->data[j];
 
-            if (buffer_is_equal_string(du->key,CONST_STR_LEN("vhostdb.mysql"))){
+            if (buffer_is_equal_string(&du->key,CONST_STR_LEN("vhostdb.mysql"))){
                 PATCH(vdata);
             }
         }
diff --git a/src/mod_vhostdb_pgsql.c b/src/mod_vhostdb_pgsql.c
index b22d4c2a..a595a363 100644
--- a/src/mod_vhostdb_pgsql.c
+++ b/src/mod_vhostdb_pgsql.c
@@ -249,7 +249,7 @@ static void mod_vhostdb_patch_connection (server *srv, connection *con, plugin_d
         for (size_t j = 0; j < dc->value->used; ++j) {
             data_unset *du = dc->value->data[j];
 
-            if (buffer_is_equal_string(du->key,CONST_STR_LEN("vhostdb.pgsql"))){
+            if (buffer_is_equal_string(&du->key,CONST_STR_LEN("vhostdb.pgsql"))){
                 PATCH(vdata);
             }
         }
diff --git a/src/mod_webdav.c b/src/mod_webdav.c
index 38d8cd75..aa7c7ecb 100644
--- a/src/mod_webdav.c
+++ b/src/mod_webdav.c
@@ -490,17 +490,17 @@ mod_webdav_patch_connection (server * const restrict srv,
         /* merge config */
         for (size_t j = 0; j < dc->value->used; ++j) {
             data_unset *du = dc->value->data[j];
-            if (buffer_is_equal_string(du->key, CONST_STR_LEN("webdav.activate"))) {
+            if (buffer_is_equal_string(&du->key, CONST_STR_LEN("webdav.activate"))) {
                 PATCH_OPTION(enabled);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("webdav.is-readonly"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("webdav.is-readonly"))) {
                 PATCH_OPTION(is_readonly);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("webdav.log-xml"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("webdav.log-xml"))) {
                 PATCH_OPTION(log_xml);
           #ifdef USE_PROPPATCH
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("webdav.sqlite-db-name"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("webdav.sqlite-db-name"))) {
                 PATCH_OPTION(sql);
           #endif
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("webdav.opts"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("webdav.opts"))) {
                 PATCH_OPTION(deprecated_unsafe_partial_put_compat);
             }
         }
diff --git a/src/mod_wstunnel.c b/src/mod_wstunnel.c
index 3cb4537b..217779ab 100644
--- a/src/mod_wstunnel.c
+++ b/src/mod_wstunnel.c
@@ -382,23 +382,23 @@ static void mod_wstunnel_patch_connection(server *srv, connection *con, plugin_d
         for (j = 0; j < dc->value->used; j++) {
             data_unset *du = dc->value->data[j];
 
-            if (buffer_is_equal_string(du->key, CONST_STR_LEN("wstunnel.server"))) {
+            if (buffer_is_equal_string(&du->key, CONST_STR_LEN("wstunnel.server"))) {
                 PATCH_GW(exts);
                 /*(wstunnel can not act as authorizer,
                  * but p->conf.exts_auth must not be NULL)*/
                 PATCH_GW(exts_auth);
                 PATCH_GW(exts_resp);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("wstunnel.debug"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("wstunnel.debug"))) {
                 PATCH_GW(debug);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("wstunnel.balance"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("wstunnel.balance"))) {
                 PATCH_GW(balance);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("wstunnel.map-extensions"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("wstunnel.map-extensions"))) {
                 PATCH_GW(ext_mapping);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("wstunnel.frame-type"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("wstunnel.frame-type"))) {
                 PATCH(frame_type);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("wstunnel.origins"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("wstunnel.origins"))) {
                 PATCH(origins);
-            } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("wstunnel.ping-interval"))) {
+            } else if (buffer_is_equal_string(&du->key, CONST_STR_LEN("wstunnel.ping-interval"))) {
                 PATCH(ping_interval);
             }
         }