diff --git a/examples/active.c b/examples/active.c
index 110f42c..ced9789 100644
--- a/examples/active.c
+++ b/examples/active.c
@@ -19,9 +19,7 @@
 
 #include <strophe.h>
 
-int handle_reply(xmpp_conn_t *const conn,
-                 xmpp_stanza_t *const stanza,
-                 void *const userdata)
+int handle_reply(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
 {
     xmpp_stanza_t *query, *item;
     const char *type;
@@ -46,11 +44,11 @@ int handle_reply(xmpp_conn_t *const conn,
     return 0;
 }
 
-void conn_handler(xmpp_conn_t *const conn,
-                  const xmpp_conn_event_t status,
-                  const int error,
-                  xmpp_stream_error_t *const stream_error,
-                  void *const userdata)
+void conn_handler(xmpp_conn_t *conn,
+                  xmpp_conn_event_t status,
+                  int error,
+                  xmpp_stream_error_t *stream_error,
+                  void *userdata)
 {
     xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
     xmpp_stanza_t *iq, *query;
diff --git a/examples/basic.c b/examples/basic.c
index fb9299d..c3942d5 100644
--- a/examples/basic.c
+++ b/examples/basic.c
@@ -19,11 +19,11 @@
 #define KA_INTERVAL 1
 
 /* define a handler for connection events */
-void conn_handler(xmpp_conn_t *const conn,
-                  const xmpp_conn_event_t status,
-                  const int error,
-                  xmpp_stream_error_t *const stream_error,
-                  void *const userdata)
+void conn_handler(xmpp_conn_t *conn,
+                  xmpp_conn_event_t status,
+                  int error,
+                  xmpp_stream_error_t *stream_error,
+                  void *userdata)
 {
     xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
     int secured;
diff --git a/examples/bot.c b/examples/bot.c
index cc5c28d..944593f 100644
--- a/examples/bot.c
+++ b/examples/bot.c
@@ -22,9 +22,7 @@
 
 #include <strophe.h>
 
-int version_handler(xmpp_conn_t *const conn,
-                    xmpp_stanza_t *const stanza,
-                    void *const userdata)
+int version_handler(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
 {
     xmpp_stanza_t *reply, *query, *name, *version, *text;
     const char *ns;
@@ -70,9 +68,7 @@ int version_handler(xmpp_conn_t *const conn,
     return 1;
 }
 
-int message_handler(xmpp_conn_t *const conn,
-                    xmpp_stanza_t *const stanza,
-                    void *const userdata)
+int message_handler(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
 {
     xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
     xmpp_stanza_t *body, *reply;
@@ -118,11 +114,11 @@ int message_handler(xmpp_conn_t *const conn,
 }
 
 /* define a handler for connection events */
-void conn_handler(xmpp_conn_t *const conn,
-                  const xmpp_conn_event_t status,
-                  const int error,
-                  xmpp_stream_error_t *const stream_error,
-                  void *const userdata)
+void conn_handler(xmpp_conn_t *conn,
+                  xmpp_conn_event_t status,
+                  int error,
+                  xmpp_stream_error_t *stream_error,
+                  void *userdata)
 {
     xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
 
diff --git a/examples/component.c b/examples/component.c
index 219f0d2..1bf8b89 100644
--- a/examples/component.c
+++ b/examples/component.c
@@ -20,11 +20,11 @@
 #include <strophe.h>
 
 /* define a handler for connection events */
-void conn_handler(xmpp_conn_t *const conn,
-                  const xmpp_conn_event_t status,
-                  const int error,
-                  xmpp_stream_error_t *const stream_error,
-                  void *const userdata)
+void conn_handler(xmpp_conn_t *conn,
+                  xmpp_conn_event_t status,
+                  int error,
+                  xmpp_stream_error_t *stream_error,
+                  void *userdata)
 {
     xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
 
diff --git a/examples/register.c b/examples/register.c
index 39ee6e9..0e3e289 100644
--- a/examples/register.c
+++ b/examples/register.c
@@ -102,9 +102,7 @@ iq_reg_send_form(xmpp_reg_t *reg, xmpp_conn_t *conn, xmpp_stanza_t *stanza)
     }
 }
 
-static int iq_reg2_cb(xmpp_conn_t *const conn,
-                      xmpp_stanza_t *const stanza,
-                      void *const userdata)
+static int iq_reg2_cb(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
 {
     const char *type;
 
@@ -129,9 +127,7 @@ quit:
     return 0;
 }
 
-static int iq_reg_cb(xmpp_conn_t *const conn,
-                     xmpp_stanza_t *const stanza,
-                     void *const userdata)
+static int iq_reg_cb(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
 {
     xmpp_reg_t *reg = (xmpp_reg_t *)userdata;
     xmpp_stanza_t *registered = NULL;
@@ -166,9 +162,8 @@ quit:
     return 0;
 }
 
-static int _handle_error(xmpp_conn_t *const conn,
-                         xmpp_stanza_t *const stanza,
-                         void *const userdata)
+static int
+_handle_error(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
 {
     (void)stanza;
     (void)userdata;
@@ -179,9 +174,9 @@ static int _handle_error(xmpp_conn_t *const conn,
     return 0;
 }
 
-static int _handle_proceedtls_default(xmpp_conn_t *const conn,
-                                      xmpp_stanza_t *const stanza,
-                                      void *const userdata)
+static int _handle_proceedtls_default(xmpp_conn_t *conn,
+                                      xmpp_stanza_t *stanza,
+                                      void *userdata)
 {
     const char *name = xmpp_stanza_get_name(stanza);
 
@@ -201,8 +196,7 @@ static int _handle_proceedtls_default(xmpp_conn_t *const conn,
     return 0;
 }
 
-static int _handle_missing_features(xmpp_conn_t *const conn,
-                                    void *const userdata)
+static int _handle_missing_features(xmpp_conn_t *conn, void *userdata)
 {
     (void)userdata;
 
@@ -212,9 +206,8 @@ static int _handle_missing_features(xmpp_conn_t *const conn,
     return 0;
 }
 
-static int _handle_features(xmpp_conn_t *const conn,
-                            xmpp_stanza_t *const stanza,
-                            void *const userdata)
+static int
+_handle_features(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
 {
     xmpp_reg_t *reg = (xmpp_reg_t *)userdata;
     xmpp_ctx_t *ctx = reg->ctx;
@@ -265,11 +258,11 @@ static int _handle_features(xmpp_conn_t *const conn,
     return 0;
 }
 
-static void conn_handler(xmpp_conn_t *const conn,
-                         const xmpp_conn_event_t status,
-                         const int error,
-                         xmpp_stream_error_t *const stream_error,
-                         void *const userdata)
+static void conn_handler(xmpp_conn_t *conn,
+                         xmpp_conn_event_t status,
+                         int error,
+                         xmpp_stream_error_t *stream_error,
+                         void *userdata)
 {
     xmpp_reg_t *reg = (xmpp_reg_t *)userdata;
     int secured;
diff --git a/examples/roster.c b/examples/roster.c
index dcd6f5c..bb89447 100644
--- a/examples/roster.c
+++ b/examples/roster.c
@@ -18,9 +18,7 @@
 
 #include <strophe.h>
 
-int handle_reply(xmpp_conn_t *const conn,
-                 xmpp_stanza_t *const stanza,
-                 void *const userdata)
+int handle_reply(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
 {
     xmpp_stanza_t *query, *item;
     const char *type, *name;
@@ -51,11 +49,11 @@ int handle_reply(xmpp_conn_t *const conn,
     return 0;
 }
 
-void conn_handler(xmpp_conn_t *const conn,
-                  const xmpp_conn_event_t status,
-                  const int error,
-                  xmpp_stream_error_t *const stream_error,
-                  void *const userdata)
+void conn_handler(xmpp_conn_t *conn,
+                  xmpp_conn_event_t status,
+                  int error,
+                  xmpp_stream_error_t *stream_error,
+                  void *userdata)
 {
     xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
     xmpp_stanza_t *iq, *query;
diff --git a/examples/vcard.c b/examples/vcard.c
index 57e115d..777ab9c 100644
--- a/examples/vcard.c
+++ b/examples/vcard.c
@@ -160,7 +160,7 @@ exit:
     return cb;
 }
 
-static int timedout(xmpp_conn_t *const conn, void *const userdata)
+static int timedout(xmpp_conn_t *conn, void *userdata)
 {
     (void)userdata;
 
@@ -170,9 +170,7 @@ static int timedout(xmpp_conn_t *const conn, void *const userdata)
     return 0;
 }
 
-static int recv_vcard(xmpp_conn_t *const conn,
-                      xmpp_stanza_t *const stanza,
-                      void *const userdata)
+static int recv_vcard(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
 {
     vcard_t *vc = userdata;
     vcard_cb_t cb;
@@ -217,11 +215,11 @@ static void send_vcard_req(xmpp_conn_t *conn, const char *to, const char *id)
                          xmpp_conn_get_bound_jid(conn), to, id);
 }
 
-static void conn_handler(xmpp_conn_t *const conn,
-                         const xmpp_conn_event_t status,
-                         const int error,
-                         xmpp_stream_error_t *const stream_error,
-                         void *const userdata)
+static void conn_handler(xmpp_conn_t *conn,
+                         xmpp_conn_event_t status,
+                         int error,
+                         xmpp_stream_error_t *stream_error,
+                         void *userdata)
 {
     vcard_t *vc = userdata;
 
diff --git a/src/auth.c b/src/auth.c
index c60512b..fcc10f6 100644
--- a/src/auth.c
+++ b/src/auth.c
@@ -60,51 +60,43 @@
 #define HANDSHAKE_TIMEOUT 15000 /* 15 seconds */
 #endif
 
-static void _auth(xmpp_conn_t *const conn);
+static void _auth(xmpp_conn_t *conn);
 static void _auth_legacy(xmpp_conn_t *conn);
-static void _handle_open_sasl(xmpp_conn_t *const conn);
-static void _handle_open_tls(xmpp_conn_t *const conn);
+static void _handle_open_sasl(xmpp_conn_t *conn);
+static void _handle_open_tls(xmpp_conn_t *conn);
 
-static int _handle_component_auth(xmpp_conn_t *const conn);
-static int _handle_component_hs_response(xmpp_conn_t *const conn,
-                                         xmpp_stanza_t *const stanza,
-                                         void *const userdata);
+static int _handle_component_auth(xmpp_conn_t *conn);
+static int _handle_component_hs_response(xmpp_conn_t *conn,
+                                         xmpp_stanza_t *stanza,
+                                         void *userdata);
 
-static int _handle_features_sasl(xmpp_conn_t *const conn,
-                                 xmpp_stanza_t *const stanza,
-                                 void *const userdata);
-static int _handle_sasl_result(xmpp_conn_t *const conn,
-                               xmpp_stanza_t *const stanza,
-                               void *const userdata);
-static int _handle_digestmd5_challenge(xmpp_conn_t *const conn,
-                                       xmpp_stanza_t *const stanza,
-                                       void *const userdata);
-static int _handle_digestmd5_rspauth(xmpp_conn_t *const conn,
-                                     xmpp_stanza_t *const stanza,
-                                     void *const userdata);
-static int _handle_scram_challenge(xmpp_conn_t *const conn,
-                                   xmpp_stanza_t *const stanza,
-                                   void *const userdata);
-static char *_make_scram_init_msg(xmpp_conn_t *const conn);
+static int
+_handle_features_sasl(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata);
+static int
+_handle_sasl_result(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata);
+static int _handle_digestmd5_challenge(xmpp_conn_t *conn,
+                                       xmpp_stanza_t *stanza,
+                                       void *userdata);
+static int _handle_digestmd5_rspauth(xmpp_conn_t *conn,
+                                     xmpp_stanza_t *stanza,
+                                     void *userdata);
+static int _handle_scram_challenge(xmpp_conn_t *conn,
+                                   xmpp_stanza_t *stanza,
+                                   void *userdata);
+static char *_make_scram_init_msg(xmpp_conn_t *conn);
 
-static int _handle_missing_features_sasl(xmpp_conn_t *const conn,
-                                         void *const userdata);
-static int _handle_missing_bind(xmpp_conn_t *const conn, void *const userdata);
-static int _handle_bind(xmpp_conn_t *const conn,
-                        xmpp_stanza_t *const stanza,
-                        void *const userdata);
-static int _handle_session(xmpp_conn_t *const conn,
-                           xmpp_stanza_t *const stanza,
-                           void *const userdata);
-static int _handle_missing_session(xmpp_conn_t *const conn,
-                                   void *const userdata);
-static int _handle_missing_handshake(xmpp_conn_t *const conn,
-                                     void *const userdata);
+static int _handle_missing_features_sasl(xmpp_conn_t *conn, void *userdata);
+static int _handle_missing_bind(xmpp_conn_t *conn, void *userdata);
+static int
+_handle_bind(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata);
+static int
+_handle_session(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata);
+static int _handle_missing_session(xmpp_conn_t *conn, void *userdata);
+static int _handle_missing_handshake(xmpp_conn_t *conn, void *userdata);
 
 /* stream:error handler */
-static int _handle_error(xmpp_conn_t *const conn,
-                         xmpp_stanza_t *const stanza,
-                         void *const userdata)
+static int
+_handle_error(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
 {
     xmpp_stanza_t *child;
     const char *name;
@@ -199,8 +191,7 @@ static int _handle_error(xmpp_conn_t *const conn,
 }
 
 /* stream:features handlers */
-static int _handle_missing_features(xmpp_conn_t *const conn,
-                                    void *const userdata)
+static int _handle_missing_features(xmpp_conn_t *conn, void *userdata)
 {
     UNUSED(userdata);
 
@@ -212,9 +203,8 @@ static int _handle_missing_features(xmpp_conn_t *const conn,
     return 0;
 }
 
-static int _handle_features(xmpp_conn_t *const conn,
-                            xmpp_stanza_t *const stanza,
-                            void *const userdata)
+static int
+_handle_features(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
 {
     xmpp_stanza_t *child, *mech;
     const char *ns;
@@ -279,7 +269,7 @@ static int _handle_features(xmpp_conn_t *const conn,
 
 /* returns the correct auth id for a component or a client.
  * returned string must be freed by caller */
-static char *_get_authid(xmpp_conn_t *const conn)
+static char *_get_authid(xmpp_conn_t *conn)
 {
     char *authid = NULL;
 
@@ -293,9 +283,9 @@ static char *_get_authid(xmpp_conn_t *const conn)
     return authid;
 }
 
-static int _handle_proceedtls_default(xmpp_conn_t *const conn,
-                                      xmpp_stanza_t *const stanza,
-                                      void *const userdata)
+static int _handle_proceedtls_default(xmpp_conn_t *conn,
+                                      xmpp_stanza_t *stanza,
+                                      void *userdata)
 {
     const char *name;
 
@@ -319,9 +309,8 @@ static int _handle_proceedtls_default(xmpp_conn_t *const conn,
     return 0;
 }
 
-static int _handle_sasl_result(xmpp_conn_t *const conn,
-                               xmpp_stanza_t *const stanza,
-                               void *const userdata)
+static int
+_handle_sasl_result(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
 {
     const char *name;
 
@@ -355,9 +344,9 @@ static int _handle_sasl_result(xmpp_conn_t *const conn,
 }
 
 /* handle the challenge phase of digest auth */
-static int _handle_digestmd5_challenge(xmpp_conn_t *const conn,
-                                       xmpp_stanza_t *const stanza,
-                                       void *const userdata)
+static int _handle_digestmd5_challenge(xmpp_conn_t *conn,
+                                       xmpp_stanza_t *stanza,
+                                       void *userdata)
 {
     char *text;
     char *response;
@@ -414,9 +403,9 @@ static int _handle_digestmd5_challenge(xmpp_conn_t *const conn,
 }
 
 /* handle the rspauth phase of digest auth */
-static int _handle_digestmd5_rspauth(xmpp_conn_t *const conn,
-                                     xmpp_stanza_t *const stanza,
-                                     void *const userdata)
+static int _handle_digestmd5_rspauth(xmpp_conn_t *conn,
+                                     xmpp_stanza_t *stanza,
+                                     void *userdata)
 {
     xmpp_stanza_t *auth;
     const char *name;
@@ -451,9 +440,9 @@ struct scram_user_data {
 };
 
 /* handle the challenge phase of SCRAM-SHA-1 auth */
-static int _handle_scram_challenge(xmpp_conn_t *const conn,
-                                   xmpp_stanza_t *const stanza,
-                                   void *const userdata)
+static int _handle_scram_challenge(xmpp_conn_t *conn,
+                                   xmpp_stanza_t *stanza,
+                                   void *userdata)
 {
     char *text;
     char *response;
@@ -532,7 +521,7 @@ err:
     return 0;
 }
 
-static char *_make_scram_init_msg(xmpp_conn_t *const conn)
+static char *_make_scram_init_msg(xmpp_conn_t *conn)
 {
     xmpp_ctx_t *ctx = conn->ctx;
     size_t message_len;
@@ -555,7 +544,7 @@ static char *_make_scram_init_msg(xmpp_conn_t *const conn)
     return message;
 }
 
-static xmpp_stanza_t *_make_starttls(xmpp_conn_t *const conn)
+static xmpp_stanza_t *_make_starttls(xmpp_conn_t *conn)
 {
     xmpp_stanza_t *starttls;
 
@@ -569,8 +558,7 @@ static xmpp_stanza_t *_make_starttls(xmpp_conn_t *const conn)
     return starttls;
 }
 
-static xmpp_stanza_t *_make_sasl_auth(xmpp_conn_t *const conn,
-                                      const char *const mechanism)
+static xmpp_stanza_t *_make_sasl_auth(xmpp_conn_t *conn, const char *mechanism)
 {
     xmpp_stanza_t *auth;
 
@@ -590,7 +578,7 @@ static xmpp_stanza_t *_make_sasl_auth(xmpp_conn_t *const conn,
  * this will get called again until one auth method succeeds or every
  * method fails
  */
-static void _auth(xmpp_conn_t *const conn)
+static void _auth(xmpp_conn_t *conn)
 {
     xmpp_stanza_t *auth;
     xmpp_stanza_t *authdata;
@@ -796,7 +784,7 @@ static void _auth(xmpp_conn_t *const conn)
  *
  *  @param conn a Strophe connection object
  */
-void auth_handle_open(xmpp_conn_t *const conn)
+void auth_handle_open(xmpp_conn_t *conn)
 {
     /* reset all timed handlers */
     handler_reset_timed(conn, 0);
@@ -812,7 +800,7 @@ void auth_handle_open(xmpp_conn_t *const conn)
 }
 
 /* called when stream:stream tag received after TLS establishment */
-static void _handle_open_tls(xmpp_conn_t *const conn)
+static void _handle_open_tls(xmpp_conn_t *conn)
 {
     /* setup handlers for incoming <stream:features> */
     handler_add(conn, _handle_features, XMPP_NS_STREAMS, "features", NULL,
@@ -821,7 +809,7 @@ static void _handle_open_tls(xmpp_conn_t *const conn)
 }
 
 /* called when stream:stream tag received after SASL auth */
-static void _handle_open_sasl(xmpp_conn_t *const conn)
+static void _handle_open_sasl(xmpp_conn_t *conn)
 {
     xmpp_debug(conn->ctx, "xmpp", "Reopened stream successfully.");
 
@@ -832,9 +820,8 @@ static void _handle_open_sasl(xmpp_conn_t *const conn)
                       NULL);
 }
 
-static int _handle_features_sasl(xmpp_conn_t *const conn,
-                                 xmpp_stanza_t *const stanza,
-                                 void *const userdata)
+static int
+_handle_features_sasl(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
 {
     xmpp_stanza_t *bind, *session, *iq, *res, *text, *opt;
     const char *ns;
@@ -939,8 +926,7 @@ static int _handle_features_sasl(xmpp_conn_t *const conn,
     return 0;
 }
 
-static int _handle_missing_features_sasl(xmpp_conn_t *const conn,
-                                         void *const userdata)
+static int _handle_missing_features_sasl(xmpp_conn_t *conn, void *userdata)
 {
     UNUSED(userdata);
 
@@ -951,9 +937,8 @@ static int _handle_missing_features_sasl(xmpp_conn_t *const conn,
     return 0;
 }
 
-static int _handle_bind(xmpp_conn_t *const conn,
-                        xmpp_stanza_t *const stanza,
-                        void *const userdata)
+static int
+_handle_bind(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
 {
     const char *type;
     xmpp_stanza_t *iq, *session;
@@ -1025,7 +1010,7 @@ static int _handle_bind(xmpp_conn_t *const conn,
     return 0;
 }
 
-static int _handle_missing_bind(xmpp_conn_t *const conn, void *const userdata)
+static int _handle_missing_bind(xmpp_conn_t *conn, void *userdata)
 {
     UNUSED(userdata);
 
@@ -1034,9 +1019,8 @@ static int _handle_missing_bind(xmpp_conn_t *const conn, void *const userdata)
     return 0;
 }
 
-static int _handle_session(xmpp_conn_t *const conn,
-                           xmpp_stanza_t *const stanza,
-                           void *const userdata)
+static int
+_handle_session(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
 {
     const char *type;
 
@@ -1065,8 +1049,7 @@ static int _handle_session(xmpp_conn_t *const conn,
     return 0;
 }
 
-static int _handle_missing_session(xmpp_conn_t *const conn,
-                                   void *const userdata)
+static int _handle_missing_session(xmpp_conn_t *conn, void *userdata)
 {
     UNUSED(userdata);
 
@@ -1075,7 +1058,7 @@ static int _handle_missing_session(xmpp_conn_t *const conn,
     return 0;
 }
 
-static int _handle_missing_legacy(xmpp_conn_t *const conn, void *const userdata)
+static int _handle_missing_legacy(xmpp_conn_t *conn, void *userdata)
 {
     UNUSED(userdata);
 
@@ -1086,9 +1069,8 @@ static int _handle_missing_legacy(xmpp_conn_t *const conn, void *const userdata)
     return 0;
 }
 
-static int _handle_legacy(xmpp_conn_t *const conn,
-                          xmpp_stanza_t *const stanza,
-                          void *const userdata)
+static int
+_handle_legacy(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
 {
     const char *type;
     const char *name;
@@ -1219,7 +1201,7 @@ err:
     disconnect_mem_error(conn);
 }
 
-void auth_handle_component_open(xmpp_conn_t *const conn)
+void auth_handle_component_open(xmpp_conn_t *conn)
 {
     int rc;
 
@@ -1239,7 +1221,7 @@ void auth_handle_component_open(xmpp_conn_t *const conn)
 }
 
 /* Will compute SHA1 and authenticate the component to the server */
-int _handle_component_auth(xmpp_conn_t *const conn)
+int _handle_component_auth(xmpp_conn_t *conn)
 {
     uint8_t md_value[SHA1_DIGEST_SIZE];
     SHA1_CTX mdctx;
@@ -1289,9 +1271,9 @@ int _handle_component_auth(xmpp_conn_t *const conn)
 /* Check if the received stanza is <handshake/> and set auth to true
  * and fire connection handler.
  */
-int _handle_component_hs_response(xmpp_conn_t *const conn,
-                                  xmpp_stanza_t *const stanza,
-                                  void *const userdata)
+int _handle_component_hs_response(xmpp_conn_t *conn,
+                                  xmpp_stanza_t *stanza,
+                                  void *userdata)
 {
     const char *name;
 
@@ -1321,7 +1303,7 @@ int _handle_component_hs_response(xmpp_conn_t *const conn,
     return 0;
 }
 
-int _handle_missing_handshake(xmpp_conn_t *const conn, void *const userdata)
+int _handle_missing_handshake(xmpp_conn_t *conn, void *userdata)
 {
     UNUSED(userdata);
 
@@ -1330,7 +1312,7 @@ int _handle_missing_handshake(xmpp_conn_t *const conn, void *const userdata)
     return 0;
 }
 
-void auth_handle_open_raw(xmpp_conn_t *const conn)
+void auth_handle_open_raw(xmpp_conn_t *conn)
 {
     handler_reset_timed(conn, 0);
     /* user handlers are not called before authentication is completed. */
@@ -1338,7 +1320,7 @@ void auth_handle_open_raw(xmpp_conn_t *const conn)
     conn->conn_handler(conn, XMPP_CONN_CONNECT, 0, NULL, conn->userdata);
 }
 
-void auth_handle_open_stub(xmpp_conn_t *const conn)
+void auth_handle_open_stub(xmpp_conn_t *conn)
 {
     xmpp_warn(conn->ctx, "auth", "Stub callback is called.");
 }
diff --git a/src/common.h b/src/common.h
index ddc30fd..de3a6e1 100644
--- a/src/common.h
+++ b/src/common.h
@@ -87,33 +87,21 @@ struct _xmpp_ctx_t {
 };
 
 /* convenience functions for accessing the context */
-void *xmpp_alloc(const xmpp_ctx_t *const ctx, const size_t size);
-void *xmpp_realloc(const xmpp_ctx_t *const ctx, void *p, const size_t size);
-char *xmpp_strdup(const xmpp_ctx_t *const ctx, const char *const s);
+void *xmpp_alloc(const xmpp_ctx_t *ctx, size_t size);
+void *xmpp_realloc(const xmpp_ctx_t *ctx, void *p, size_t size);
+char *xmpp_strdup(const xmpp_ctx_t *ctx, const char *s);
 
-void xmpp_log(const xmpp_ctx_t *const ctx,
+void xmpp_log(const xmpp_ctx_t *ctx,
               const xmpp_log_level_t level,
-              const char *const area,
-              const char *const fmt,
+              const char *area,
+              const char *fmt,
               va_list ap);
 
 /* wrappers for xmpp_log at specific levels */
-void xmpp_error(const xmpp_ctx_t *const ctx,
-                const char *const area,
-                const char *const fmt,
-                ...);
-void xmpp_warn(const xmpp_ctx_t *const ctx,
-               const char *const area,
-               const char *const fmt,
-               ...);
-void xmpp_info(const xmpp_ctx_t *const ctx,
-               const char *const area,
-               const char *const fmt,
-               ...);
-void xmpp_debug(const xmpp_ctx_t *const ctx,
-                const char *const area,
-                const char *const fmt,
-                ...);
+void xmpp_error(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...);
+void xmpp_warn(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...);
+void xmpp_info(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...);
+void xmpp_debug(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...);
 
 /** connection **/
 
@@ -153,7 +141,7 @@ enum {
     XMPP_PORT_COMPONENT = 5347,
 };
 
-typedef void (*xmpp_open_handler)(xmpp_conn_t *const conn);
+typedef void (*xmpp_open_handler)(xmpp_conn_t *conn);
 
 struct _xmpp_conn_t {
     unsigned int ref;
@@ -225,13 +213,13 @@ struct _xmpp_conn_t {
     xmpp_handlist_t *handlers;
 };
 
-void conn_disconnect(xmpp_conn_t *const conn);
-void conn_disconnect_clean(xmpp_conn_t *const conn);
-void conn_established(xmpp_conn_t *const conn);
-void conn_open_stream(xmpp_conn_t *const conn);
-int conn_tls_start(xmpp_conn_t *const conn);
-void conn_prepare_reset(xmpp_conn_t *const conn, xmpp_open_handler handler);
-void conn_parser_reset(xmpp_conn_t *const conn);
+void conn_disconnect(xmpp_conn_t *conn);
+void conn_disconnect_clean(xmpp_conn_t *conn);
+void conn_established(xmpp_conn_t *conn);
+void conn_open_stream(xmpp_conn_t *conn);
+int conn_tls_start(xmpp_conn_t *conn);
+void conn_prepare_reset(xmpp_conn_t *conn, xmpp_open_handler handler);
+void conn_parser_reset(xmpp_conn_t *conn);
 
 typedef enum {
     XMPP_STANZA_UNKNOWN,
@@ -256,32 +244,32 @@ struct _xmpp_stanza_t {
 };
 
 /* handler management */
-void handler_fire_stanza(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza);
-uint64_t handler_fire_timed(xmpp_ctx_t *const ctx);
+void handler_fire_stanza(xmpp_conn_t *conn, xmpp_stanza_t *stanza);
+uint64_t handler_fire_timed(xmpp_ctx_t *ctx);
 void handler_reset_timed(xmpp_conn_t *conn, int user_only);
-void handler_add_timed(xmpp_conn_t *const conn,
+void handler_add_timed(xmpp_conn_t *conn,
                        xmpp_timed_handler handler,
-                       const unsigned long period,
-                       void *const userdata);
-void handler_add_id(xmpp_conn_t *const conn,
+                       unsigned long period,
+                       void *userdata);
+void handler_add_id(xmpp_conn_t *conn,
                     xmpp_handler handler,
-                    const char *const id,
-                    void *const userdata);
-void handler_add(xmpp_conn_t *const conn,
+                    const char *id,
+                    void *userdata);
+void handler_add(xmpp_conn_t *conn,
                  xmpp_handler handler,
-                 const char *const ns,
-                 const char *const name,
-                 const char *const type,
-                 void *const userdata);
+                 const char *ns,
+                 const char *name,
+                 const char *type,
+                 void *userdata);
 void handler_system_delete_all(xmpp_conn_t *conn);
 
 /* utility functions */
-void disconnect_mem_error(xmpp_conn_t *const conn);
+void disconnect_mem_error(xmpp_conn_t *conn);
 
 /* auth functions */
-void auth_handle_open(xmpp_conn_t *const conn);
-void auth_handle_component_open(xmpp_conn_t *const conn);
-void auth_handle_open_raw(xmpp_conn_t *const conn);
-void auth_handle_open_stub(xmpp_conn_t *const conn);
+void auth_handle_open(xmpp_conn_t *conn);
+void auth_handle_component_open(xmpp_conn_t *conn);
+void auth_handle_open_raw(xmpp_conn_t *conn);
+void auth_handle_open_stub(xmpp_conn_t *conn);
 
 #endif /* __LIBSTROPHE_COMMON_H__ */
diff --git a/src/conn.c b/src/conn.c
index 46e11cc..1cdeb96 100644
--- a/src/conn.c
+++ b/src/conn.c
@@ -48,8 +48,8 @@
 #define CONNECT_TIMEOUT 5000 /* 5 seconds */
 #endif
 
-static int _disconnect_cleanup(xmpp_conn_t *const conn, void *const userdata);
-static char *_conn_build_stream_tag(xmpp_conn_t *const conn,
+static int _disconnect_cleanup(xmpp_conn_t *conn, void *userdata);
+static char *_conn_build_stream_tag(xmpp_conn_t *conn,
                                     char **attributes,
                                     size_t attributes_len);
 static void _conn_attributes_new(xmpp_conn_t *conn,
@@ -59,24 +59,21 @@ static void _conn_attributes_new(xmpp_conn_t *conn,
 static void _conn_attributes_destroy(xmpp_conn_t *conn,
                                      char **attributes,
                                      size_t attributes_len);
-static void
-_handle_stream_start(char *name, char **attrs, void *const userdata);
-static void _handle_stream_end(char *name, void *const userdata);
-static void _handle_stream_stanza(xmpp_stanza_t *stanza, void *const userdata);
-static unsigned short _conn_default_port(xmpp_conn_t *const conn,
+static void _handle_stream_start(char *name, char **attrs, void *userdata);
+static void _handle_stream_end(char *name, void *userdata);
+static void _handle_stream_stanza(xmpp_stanza_t *stanza, void *userdata);
+static unsigned short _conn_default_port(xmpp_conn_t *conn,
                                          xmpp_conn_type_t type);
-static void _conn_reset(xmpp_conn_t *const conn);
-static int _conn_connect(xmpp_conn_t *const conn,
-                         const char *const domain,
-                         const char *const host,
+static void _conn_reset(xmpp_conn_t *conn);
+static int _conn_connect(xmpp_conn_t *conn,
+                         const char *domain,
+                         const char *host,
                          unsigned short port,
                          xmpp_conn_type_t type,
                          xmpp_conn_handler callback,
-                         void *const userdata);
+                         void *userdata);
 
-void xmpp_send_error(xmpp_conn_t *const conn,
-                     xmpp_error_type_t const type,
-                     char *const text)
+void xmpp_send_error(xmpp_conn_t *conn, xmpp_error_type_t type, char *text)
 {
     xmpp_stanza_t *error = xmpp_error_new(conn->ctx, type, text);
 
@@ -93,7 +90,7 @@ void xmpp_send_error(xmpp_conn_t *const conn,
  *
  *  @ingroup Connections
  */
-xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t *const ctx)
+xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t *ctx)
 {
     xmpp_conn_t *conn = NULL;
     xmpp_connlist_t *tail, *item;
@@ -201,7 +198,7 @@ xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t *const ctx)
  *
  *  @ingroup Connections
  */
-xmpp_conn_t *xmpp_conn_clone(xmpp_conn_t *const conn)
+xmpp_conn_t *xmpp_conn_clone(xmpp_conn_t *conn)
 {
     conn->ref++;
     return conn;
@@ -219,7 +216,7 @@ xmpp_conn_t *xmpp_conn_clone(xmpp_conn_t *const conn)
  *
  *  @ingroup Connections
  */
-void xmpp_conn_set_keepalive(xmpp_conn_t *const conn, int timeout, int interval)
+void xmpp_conn_set_keepalive(xmpp_conn_t *conn, int timeout, int interval)
 {
     int ret = 0;
 
@@ -245,7 +242,7 @@ void xmpp_conn_set_keepalive(xmpp_conn_t *const conn, int timeout, int interval)
  *
  *  @ingroup Connections
  */
-int xmpp_conn_release(xmpp_conn_t *const conn)
+int xmpp_conn_release(xmpp_conn_t *conn)
 {
     xmpp_ctx_t *ctx;
     xmpp_connlist_t *item, *prev;
@@ -353,7 +350,7 @@ int xmpp_conn_release(xmpp_conn_t *const conn)
  *
  *  @ingroup Connections
  */
-const char *xmpp_conn_get_jid(const xmpp_conn_t *const conn)
+const char *xmpp_conn_get_jid(const xmpp_conn_t *conn)
 {
     return conn->jid;
 }
@@ -371,7 +368,7 @@ const char *xmpp_conn_get_jid(const xmpp_conn_t *const conn)
  *
  * @ingroup Connections
  */
-const char *xmpp_conn_get_bound_jid(const xmpp_conn_t *const conn)
+const char *xmpp_conn_get_bound_jid(const xmpp_conn_t *conn)
 {
     return conn->bound_jid;
 }
@@ -387,7 +384,7 @@ const char *xmpp_conn_get_bound_jid(const xmpp_conn_t *const conn)
  *
  *  @ingroup Connections
  */
-void xmpp_conn_set_jid(xmpp_conn_t *const conn, const char *const jid)
+void xmpp_conn_set_jid(xmpp_conn_t *conn, const char *jid)
 {
     if (conn->jid)
         xmpp_free(conn->ctx, conn->jid);
@@ -402,7 +399,7 @@ void xmpp_conn_set_jid(xmpp_conn_t *const conn, const char *const jid)
  *
  *  @ingroup Connections
  */
-const char *xmpp_conn_get_pass(const xmpp_conn_t *const conn)
+const char *xmpp_conn_get_pass(const xmpp_conn_t *conn)
 {
     return conn->pass;
 }
@@ -416,7 +413,7 @@ const char *xmpp_conn_get_pass(const xmpp_conn_t *const conn)
  *
  *  @ingroup Connections
  */
-void xmpp_conn_set_pass(xmpp_conn_t *const conn, const char *const pass)
+void xmpp_conn_set_pass(xmpp_conn_t *conn, const char *pass)
 {
     if (conn->pass)
         xmpp_free(conn->ctx, conn->pass);
@@ -430,7 +427,7 @@ void xmpp_conn_set_pass(xmpp_conn_t *const conn, const char *const pass)
  *
  *  @ingroup Connections
  */
-xmpp_ctx_t *xmpp_conn_get_context(xmpp_conn_t *const conn)
+xmpp_ctx_t *xmpp_conn_get_context(xmpp_conn_t *conn)
 {
     return conn->ctx;
 }
@@ -456,11 +453,11 @@ xmpp_ctx_t *xmpp_conn_get_context(xmpp_conn_t *const conn)
  *
  *  @ingroup Connections
  */
-int xmpp_connect_client(xmpp_conn_t *const conn,
-                        const char *const altdomain,
+int xmpp_connect_client(xmpp_conn_t *conn,
+                        const char *altdomain,
                         unsigned short altport,
                         xmpp_conn_handler callback,
-                        void *const userdata)
+                        void *userdata)
 {
     resolver_srv_rr_t *srv_rr_list = NULL;
     resolver_srv_rr_t *rr;
@@ -536,11 +533,11 @@ int xmpp_connect_client(xmpp_conn_t *const conn,
  *
  *  @ingroup Connections
  */
-int xmpp_connect_component(xmpp_conn_t *const conn,
-                           const char *const server,
+int xmpp_connect_component(xmpp_conn_t *conn,
+                           const char *server,
                            unsigned short port,
                            xmpp_conn_handler callback,
-                           void *const userdata)
+                           void *userdata)
 {
     /*  The server domain, jid and password MUST be specified. */
     if (!(server && conn->jid && conn->pass))
@@ -583,18 +580,18 @@ int xmpp_connect_component(xmpp_conn_t *const conn,
  *
  *  @ingroup Connections
  */
-int xmpp_connect_raw(xmpp_conn_t *const conn,
-                     const char *const altdomain,
+int xmpp_connect_raw(xmpp_conn_t *conn,
+                     const char *altdomain,
                      unsigned short altport,
                      xmpp_conn_handler callback,
-                     void *const userdata)
+                     void *userdata)
 {
     conn->is_raw = 1;
     return xmpp_connect_client(conn, altdomain, altport, callback, userdata);
 }
 
 /* Called when tcp connection is established. */
-void conn_established(xmpp_conn_t *const conn)
+void conn_established(xmpp_conn_t *conn)
 {
     if (conn->tls_legacy_ssl && !conn->is_raw) {
         xmpp_debug(conn->ctx, "xmpp", "using legacy SSL connection");
@@ -628,7 +625,7 @@ void conn_established(xmpp_conn_t *const conn)
  *
  *  @ingroup Connections
  */
-int xmpp_conn_open_stream_default(xmpp_conn_t *const conn)
+int xmpp_conn_open_stream_default(xmpp_conn_t *conn)
 {
     if (!conn->is_raw)
         return XMPP_EINVOP;
@@ -655,7 +652,7 @@ int xmpp_conn_open_stream_default(xmpp_conn_t *const conn)
  *
  *  @ingroup Connections
  */
-int xmpp_conn_open_stream(xmpp_conn_t *const conn,
+int xmpp_conn_open_stream(xmpp_conn_t *conn,
                           char **attributes,
                           size_t attributes_len)
 {
@@ -681,7 +678,7 @@ int xmpp_conn_open_stream(xmpp_conn_t *const conn,
  *
  *  @ingroup Connections
  */
-int xmpp_conn_tls_start(xmpp_conn_t *const conn)
+int xmpp_conn_tls_start(xmpp_conn_t *conn)
 {
     return conn_tls_start(conn);
 }
@@ -692,7 +689,7 @@ int xmpp_conn_tls_start(xmpp_conn_t *const conn)
  *
  *  @param conn a Strophe connection object
  */
-void conn_disconnect_clean(xmpp_conn_t *const conn)
+void conn_disconnect_clean(xmpp_conn_t *conn)
 {
     /* remove the timed handler */
     xmpp_timed_handler_delete(conn, _disconnect_cleanup);
@@ -706,7 +703,7 @@ void conn_disconnect_clean(xmpp_conn_t *const conn)
  *
  *  @param conn a Strophe connection object
  */
-void conn_disconnect(xmpp_conn_t *const conn)
+void conn_disconnect(xmpp_conn_t *conn)
 {
     xmpp_debug(conn->ctx, "xmpp", "Closing socket.");
     conn->state = XMPP_STATE_DISCONNECTED;
@@ -724,14 +721,14 @@ void conn_disconnect(xmpp_conn_t *const conn)
 
 /* prepares a parser reset.  this is called from handlers. we can't
  * reset the parser immediately as it is not re-entrant. */
-void conn_prepare_reset(xmpp_conn_t *const conn, xmpp_open_handler handler)
+void conn_prepare_reset(xmpp_conn_t *conn, xmpp_open_handler handler)
 {
     conn->reset_parser = 1;
     conn->open_handler = handler;
 }
 
 /* reset the parser */
-void conn_parser_reset(xmpp_conn_t *const conn)
+void conn_parser_reset(xmpp_conn_t *conn)
 {
     conn->reset_parser = 0;
     parser_reset(conn->parser);
@@ -746,7 +743,7 @@ void conn_parser_reset(xmpp_conn_t *const conn)
  *
  *  @ingroup Connections
  */
-void xmpp_disconnect(xmpp_conn_t *const conn)
+void xmpp_disconnect(xmpp_conn_t *conn)
 {
     if (conn->state != XMPP_STATE_CONNECTING &&
         conn->state != XMPP_STATE_CONNECTED)
@@ -772,7 +769,7 @@ void xmpp_disconnect(xmpp_conn_t *const conn)
  *
  *  @ingroup Connections
  */
-void xmpp_send_raw_string(xmpp_conn_t *const conn, const char *const fmt, ...)
+void xmpp_send_raw_string(xmpp_conn_t *conn, const char *fmt, ...)
 {
     va_list ap;
     size_t len;
@@ -821,9 +818,7 @@ void xmpp_send_raw_string(xmpp_conn_t *const conn, const char *const fmt, ...)
  *
  *  @ingroup Connections
  */
-void xmpp_send_raw(xmpp_conn_t *const conn,
-                   const char *const data,
-                   const size_t len)
+void xmpp_send_raw(xmpp_conn_t *conn, const char *data, size_t len)
 {
     xmpp_send_queue_t *item;
 
@@ -867,7 +862,7 @@ void xmpp_send_raw(xmpp_conn_t *const conn,
  *
  *  @ingroup Connections
  */
-void xmpp_send(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza)
+void xmpp_send(xmpp_conn_t *conn, xmpp_stanza_t *stanza)
 {
     char *buf;
     size_t len;
@@ -887,7 +882,7 @@ void xmpp_send(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza)
  *
  *  @param conn a Strophe connection object
  */
-void conn_open_stream(xmpp_conn_t *const conn)
+void conn_open_stream(xmpp_conn_t *conn)
 {
     xmpp_send_raw_string(conn,
                          "<?xml version=\"1.0\"?>"
@@ -902,7 +897,7 @@ void conn_open_stream(xmpp_conn_t *const conn)
                          XMPP_NS_STREAMS);
 }
 
-int conn_tls_start(xmpp_conn_t *const conn)
+int conn_tls_start(xmpp_conn_t *conn)
 {
     int rc;
 
@@ -942,7 +937,7 @@ int conn_tls_start(xmpp_conn_t *const conn)
  *
  *  @ingroup Connections
  */
-long xmpp_conn_get_flags(const xmpp_conn_t *const conn)
+long xmpp_conn_get_flags(const xmpp_conn_t *conn)
 {
     long flags;
 
@@ -977,7 +972,7 @@ long xmpp_conn_get_flags(const xmpp_conn_t *const conn)
  *
  *  @ingroup Connections
  */
-int xmpp_conn_set_flags(xmpp_conn_t *const conn, long flags)
+int xmpp_conn_set_flags(xmpp_conn_t *conn, long flags)
 {
     if (conn->state != XMPP_STATE_DISCONNECTED) {
         xmpp_error(conn->ctx, "conn",
@@ -1012,7 +1007,7 @@ int xmpp_conn_set_flags(xmpp_conn_t *const conn, long flags)
  *
  *  @ingroup Connections
  */
-void xmpp_conn_disable_tls(xmpp_conn_t *const conn)
+void xmpp_conn_disable_tls(xmpp_conn_t *conn)
 {
     long flags = xmpp_conn_get_flags(conn);
 
@@ -1026,7 +1021,7 @@ void xmpp_conn_disable_tls(xmpp_conn_t *const conn)
  *
  *  @ingroup Connections
  */
-int xmpp_conn_is_secured(xmpp_conn_t *const conn)
+int xmpp_conn_is_secured(xmpp_conn_t *conn)
 {
     return conn->secured && !conn->tls_failed && conn->tls != NULL;
 }
@@ -1036,7 +1031,7 @@ int xmpp_conn_is_secured(xmpp_conn_t *const conn)
  *
  *  @ingroup Connections
  */
-int xmpp_conn_is_connecting(xmpp_conn_t *const conn)
+int xmpp_conn_is_connecting(xmpp_conn_t *conn)
 {
     return conn->state == XMPP_STATE_CONNECTING;
 }
@@ -1046,7 +1041,7 @@ int xmpp_conn_is_connecting(xmpp_conn_t *const conn)
  *
  *  @ingroup Connections
  */
-int xmpp_conn_is_connected(xmpp_conn_t *const conn)
+int xmpp_conn_is_connected(xmpp_conn_t *conn)
 {
     return conn->state == XMPP_STATE_CONNECTED;
 }
@@ -1056,13 +1051,13 @@ int xmpp_conn_is_connected(xmpp_conn_t *const conn)
  *
  *  @ingroup Connections
  */
-int xmpp_conn_is_disconnected(xmpp_conn_t *const conn)
+int xmpp_conn_is_disconnected(xmpp_conn_t *conn)
 {
     return conn->state == XMPP_STATE_DISCONNECTED;
 }
 
 /* timed handler for cleanup if normal disconnect procedure takes too long */
-static int _disconnect_cleanup(xmpp_conn_t *const conn, void *const userdata)
+static int _disconnect_cleanup(xmpp_conn_t *conn, void *userdata)
 {
     UNUSED(userdata);
 
@@ -1073,7 +1068,7 @@ static int _disconnect_cleanup(xmpp_conn_t *const conn, void *const userdata)
     return 0;
 }
 
-static char *_conn_build_stream_tag(xmpp_conn_t *const conn,
+static char *_conn_build_stream_tag(xmpp_conn_t *conn,
                                     char **attributes,
                                     size_t attributes_len)
 {
@@ -1190,7 +1185,7 @@ static char *_get_stream_attribute(char **attrs, char *name)
     return NULL;
 }
 
-static void _handle_stream_start(char *name, char **attrs, void *const userdata)
+static void _handle_stream_start(char *name, char **attrs, void *userdata)
 {
     xmpp_conn_t *conn = (xmpp_conn_t *)userdata;
     char *id;
@@ -1226,7 +1221,7 @@ static void _handle_stream_start(char *name, char **attrs, void *const userdata)
     }
 }
 
-static void _handle_stream_end(char *name, void *const userdata)
+static void _handle_stream_end(char *name, void *userdata)
 {
     xmpp_conn_t *conn = (xmpp_conn_t *)userdata;
 
@@ -1237,7 +1232,7 @@ static void _handle_stream_end(char *name, void *const userdata)
     conn_disconnect_clean(conn);
 }
 
-static void _handle_stream_stanza(xmpp_stanza_t *stanza, void *const userdata)
+static void _handle_stream_stanza(xmpp_stanza_t *stanza, void *userdata)
 {
     xmpp_conn_t *conn = (xmpp_conn_t *)userdata;
     char *buf;
@@ -1251,7 +1246,7 @@ static void _handle_stream_stanza(xmpp_stanza_t *stanza, void *const userdata)
     handler_fire_stanza(conn, stanza);
 }
 
-static unsigned short _conn_default_port(xmpp_conn_t *const conn,
+static unsigned short _conn_default_port(xmpp_conn_t *conn,
                                          xmpp_conn_type_t type)
 {
     switch (type) {
@@ -1265,7 +1260,7 @@ static unsigned short _conn_default_port(xmpp_conn_t *const conn,
     };
 }
 
-static void _conn_reset(xmpp_conn_t *const conn)
+static void _conn_reset(xmpp_conn_t *conn)
 {
     xmpp_ctx_t *ctx = conn->ctx;
     xmpp_send_queue_t *sq, *tsq;
@@ -1316,13 +1311,13 @@ static void _conn_reset(xmpp_conn_t *const conn)
     handler_system_delete_all(conn);
 }
 
-static int _conn_connect(xmpp_conn_t *const conn,
-                         const char *const domain,
-                         const char *const host,
+static int _conn_connect(xmpp_conn_t *conn,
+                         const char *domain,
+                         const char *host,
                          unsigned short port,
                          xmpp_conn_type_t type,
                          xmpp_conn_handler callback,
-                         void *const userdata)
+                         void *userdata)
 {
     xmpp_open_handler open_handler;
 
@@ -1352,10 +1347,9 @@ static int _conn_connect(xmpp_conn_t *const conn,
     conn->conn_handler = callback;
     conn->userdata = userdata;
 
-    open_handler = conn->is_raw
-                       ? auth_handle_open_stub
-                       : type == XMPP_CLIENT ? auth_handle_open
-                                             : auth_handle_component_open;
+    open_handler = conn->is_raw          ? auth_handle_open_stub
+                   : type == XMPP_CLIENT ? auth_handle_open
+                                         : auth_handle_component_open;
     conn_prepare_reset(conn, open_handler);
 
     /* FIXME: it could happen that the connect returns immediately as
diff --git a/src/crypto.c b/src/crypto.c
index 3e396b2..dd456e5 100644
--- a/src/crypto.c
+++ b/src/crypto.c
@@ -244,15 +244,14 @@ static const char _base64_charmap[65] = {
     'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', '='};
 
-static size_t base64_encoded_len(const size_t len)
+static size_t base64_encoded_len(size_t len)
 {
     /* encoded steam is 4 bytes for every three, rounded up */
     return ((len + 2) / 3) << 2;
 }
 
-static char *base64_encode(xmpp_ctx_t *ctx,
-                           const unsigned char *const buffer,
-                           const size_t len)
+static char *
+base64_encode(xmpp_ctx_t *ctx, const unsigned char *buffer, size_t len)
 {
     size_t clen;
     char *cbuf, *c;
@@ -304,7 +303,7 @@ static char *base64_encode(xmpp_ctx_t *ctx,
     return cbuf;
 }
 
-static size_t base64_decoded_len(const char *const buffer, const size_t len)
+static size_t base64_decoded_len(const char *buffer, size_t len)
 {
     size_t nudge = 0;
     unsigned char c;
@@ -331,8 +330,8 @@ static size_t base64_decoded_len(const char *const buffer, const size_t len)
 }
 
 static void base64_decode(xmpp_ctx_t *ctx,
-                          const char *const buffer,
-                          const size_t len,
+                          const char *buffer,
+                          size_t len,
                           unsigned char **out,
                           size_t *outlen)
 {
diff --git a/src/ctx.c b/src/ctx.c
index da2d643..cc4134b 100644
--- a/src/ctx.c
+++ b/src/ctx.c
@@ -122,19 +122,19 @@ int xmpp_version_check(int major, int minor)
 /* Wrap stdlib routines malloc, free, and realloc for default memory
  * management.
  */
-static void *_malloc(const size_t size, void *const userdata)
+static void *_malloc(size_t size, void *userdata)
 {
     UNUSED(userdata);
     return malloc(size);
 }
 
-static void _free(void *p, void *const userdata)
+static void _free(void *p, void *userdata)
 {
     UNUSED(userdata);
     free(p);
 }
 
-static void *_realloc(void *p, const size_t size, void *const userdata)
+static void *_realloc(void *p, size_t size, void *userdata)
 {
     UNUSED(userdata);
     return realloc(p, size);
@@ -146,8 +146,7 @@ static xmpp_mem_t xmpp_default_mem = {
     _free, _realloc, NULL};
 
 /* log levels and names */
-static const char *const _xmpp_log_level_name[4] = {"DEBUG", "INFO", "WARN",
-                                                    "ERROR"};
+static const char *_xmpp_log_level_name[4] = {"DEBUG", "INFO", "WARN", "ERROR"};
 static const xmpp_log_level_t _xmpp_default_logger_levels[] = {
     XMPP_LEVEL_DEBUG, XMPP_LEVEL_INFO, XMPP_LEVEL_WARN, XMPP_LEVEL_ERROR};
 
@@ -160,10 +159,10 @@ static const xmpp_log_level_t _xmpp_default_logger_levels[] = {
  *  @param area the area the log message is for
  *  @param msg the log message
  */
-static void xmpp_default_logger(void *const userdata,
-                                const xmpp_log_level_t level,
-                                const char *const area,
-                                const char *const msg)
+static void xmpp_default_logger(void *userdata,
+                                xmpp_log_level_t level,
+                                const char *area,
+                                const char *msg)
 {
     xmpp_log_level_t filter_level = *(xmpp_log_level_t *)userdata;
     if (level >= filter_level)
@@ -212,7 +211,7 @@ static xmpp_log_t xmpp_default_log = {NULL, NULL};
  *
  *  @return a pointer to the allocated memory or NULL on an error
  */
-void *xmpp_alloc(const xmpp_ctx_t *const ctx, const size_t size)
+void *xmpp_alloc(const xmpp_ctx_t *ctx, size_t size)
 {
     return ctx->mem->alloc(size, ctx->mem->userdata);
 }
@@ -223,7 +222,7 @@ void *xmpp_alloc(const xmpp_ctx_t *const ctx, const size_t size)
  *  @param ctx a Strophe context object
  *  @param p a pointer referencing memory to be freed
  */
-void xmpp_free(const xmpp_ctx_t *const ctx, void *p)
+void xmpp_free(const xmpp_ctx_t *ctx, void *p)
 {
     ctx->mem->free(p, ctx->mem->userdata);
 }
@@ -237,7 +236,7 @@ void xmpp_free(const xmpp_ctx_t *const ctx, void *p)
  *
  *  @return a pointer to the reallocated memory or NULL on an error
  */
-void *xmpp_realloc(const xmpp_ctx_t *const ctx, void *p, const size_t size)
+void *xmpp_realloc(const xmpp_ctx_t *ctx, void *p, size_t size)
 {
     return ctx->mem->realloc(p, size, ctx->mem->userdata);
 }
@@ -255,10 +254,10 @@ void *xmpp_realloc(const xmpp_ctx_t *const ctx, void *p, const size_t size)
  *  @param fmt a printf-style format string for the message
  *  @param ap variable argument list supplied for the format string
  */
-void xmpp_log(const xmpp_ctx_t *const ctx,
-              const xmpp_log_level_t level,
-              const char *const area,
-              const char *const fmt,
+void xmpp_log(const xmpp_ctx_t *ctx,
+              xmpp_log_level_t level,
+              const char *area,
+              const char *fmt,
               va_list ap)
 {
     int oldret, ret;
@@ -306,10 +305,7 @@ void xmpp_log(const xmpp_ctx_t *const ctx,
  *  @param fmt a printf-style format string followed by a variable list of
  *      arguments to format
  */
-void xmpp_error(const xmpp_ctx_t *const ctx,
-                const char *const area,
-                const char *const fmt,
-                ...)
+void xmpp_error(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...)
 {
     va_list ap;
 
@@ -328,10 +324,7 @@ void xmpp_error(const xmpp_ctx_t *const ctx,
  *  @param fmt a printf-style format string followed by a variable list of
  *      arguments to format
  */
-void xmpp_warn(const xmpp_ctx_t *const ctx,
-               const char *const area,
-               const char *const fmt,
-               ...)
+void xmpp_warn(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...)
 {
     va_list ap;
 
@@ -350,10 +343,7 @@ void xmpp_warn(const xmpp_ctx_t *const ctx,
  *  @param fmt a printf-style format string followed by a variable list of
  *      arguments to format
  */
-void xmpp_info(const xmpp_ctx_t *const ctx,
-               const char *const area,
-               const char *const fmt,
-               ...)
+void xmpp_info(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...)
 {
     va_list ap;
 
@@ -372,10 +362,7 @@ void xmpp_info(const xmpp_ctx_t *const ctx,
  *  @param fmt a printf-style format string followed by a variable list of
  *      arguments to format
  */
-void xmpp_debug(const xmpp_ctx_t *const ctx,
-                const char *const area,
-                const char *const fmt,
-                ...)
+void xmpp_debug(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...)
 {
     va_list ap;
 
@@ -398,8 +385,7 @@ void xmpp_debug(const xmpp_ctx_t *const ctx,
  *
  *  @ingroup Context
  */
-xmpp_ctx_t *xmpp_ctx_new(const xmpp_mem_t *const mem,
-                         const xmpp_log_t *const log)
+xmpp_ctx_t *xmpp_ctx_new(const xmpp_mem_t *mem, const xmpp_log_t *log)
 {
     xmpp_ctx_t *ctx = NULL;
 
@@ -439,7 +425,7 @@ xmpp_ctx_t *xmpp_ctx_new(const xmpp_mem_t *const mem,
  *
  *  @ingroup Context
  */
-void xmpp_ctx_free(xmpp_ctx_t *const ctx)
+void xmpp_ctx_free(xmpp_ctx_t *ctx)
 {
     /* mem and log are owned by their suppliers */
     xmpp_rand_free(ctx, ctx->rand);
@@ -453,7 +439,7 @@ void xmpp_ctx_free(xmpp_ctx_t *const ctx)
  *
  *  @ingroup Context
  */
-void xmpp_ctx_set_timeout(xmpp_ctx_t *const ctx, const unsigned long timeout)
+void xmpp_ctx_set_timeout(xmpp_ctx_t *ctx, unsigned long timeout)
 {
     ctx->timeout = timeout;
 }
diff --git a/src/event.c b/src/event.c
index b13845b..a44ed68 100644
--- a/src/event.c
+++ b/src/event.c
@@ -73,7 +73,7 @@
  *
  *  @ingroup EventLoop
  */
-void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
+void xmpp_run_once(xmpp_ctx_t *ctx, unsigned long timeout)
 {
     xmpp_connlist_t *connitem;
     xmpp_conn_t *conn;
diff --git a/src/handler.c b/src/handler.c
index dfd25e0..16df683 100644
--- a/src/handler.c
+++ b/src/handler.c
@@ -53,7 +53,7 @@ static void _handler_item_remove(xmpp_handlist_t **head, xmpp_handlist_t *item)
  *  @param conn a Strophe connection object
  *  @param stanza a Strophe stanza object
  */
-void handler_fire_stanza(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza)
+void handler_fire_stanza(xmpp_conn_t *conn, xmpp_stanza_t *stanza)
 {
     xmpp_handlist_t *item, *next, *head, *head_old;
     const char *id, *ns, *name, *type;
@@ -144,7 +144,7 @@ void handler_fire_stanza(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza)
  *
  *  @return the time in milliseconds until the next handler will be ready
  */
-uint64_t handler_fire_timed(xmpp_ctx_t *const ctx)
+uint64_t handler_fire_timed(xmpp_ctx_t *ctx)
 {
     xmpp_connlist_t *connitem;
     xmpp_handlist_t *item, *next;
@@ -253,9 +253,9 @@ void handler_reset_timed(xmpp_conn_t *conn, int user_only)
 static void _timed_handler_add(xmpp_ctx_t *ctx,
                                xmpp_handlist_t **handlers_list,
                                xmpp_void_handler handler,
-                               const unsigned long period,
-                               void *const userdata,
-                               const int user_handler)
+                               unsigned long period,
+                               void *userdata,
+                               int user_handler)
 {
     xmpp_handlist_t *item;
 
@@ -311,16 +311,15 @@ static void _timed_handler_delete(xmpp_ctx_t *ctx,
  *
  *  @ingroup Handlers
  */
-void xmpp_timed_handler_delete(xmpp_conn_t *const conn,
-                               xmpp_timed_handler handler)
+void xmpp_timed_handler_delete(xmpp_conn_t *conn, xmpp_timed_handler handler)
 {
     _timed_handler_delete(conn->ctx, &conn->timed_handlers, handler);
 }
 
-static void _id_handler_add(xmpp_conn_t *const conn,
+static void _id_handler_add(xmpp_conn_t *conn,
                             xmpp_handler handler,
-                            const char *const id,
-                            void *const userdata,
+                            const char *id,
+                            void *userdata,
                             int user_handler)
 {
     xmpp_handlist_t *item, *tail;
@@ -373,9 +372,9 @@ static void _id_handler_add(xmpp_conn_t *const conn,
  *
  *  @ingroup Handlers
  */
-void xmpp_id_handler_delete(xmpp_conn_t *const conn,
+void xmpp_id_handler_delete(xmpp_conn_t *conn,
                             xmpp_handler handler,
-                            const char *const id)
+                            const char *id)
 {
     xmpp_handlist_t *item, *prev, *next;
 
@@ -406,12 +405,12 @@ void xmpp_id_handler_delete(xmpp_conn_t *const conn,
 }
 
 /* add a stanza handler */
-static void _handler_add(xmpp_conn_t *const conn,
+static void _handler_add(xmpp_conn_t *conn,
                          xmpp_handler handler,
-                         const char *const ns,
-                         const char *const name,
-                         const char *const type,
-                         void *const userdata,
+                         const char *ns,
+                         const char *name,
+                         const char *type,
+                         void *userdata,
                          int user_handler)
 {
     xmpp_handlist_t *item, *tail;
@@ -489,7 +488,7 @@ static void _handler_add(xmpp_conn_t *const conn,
  *
  *  @ingroup Handlers
  */
-void xmpp_handler_delete(xmpp_conn_t *const conn, xmpp_handler handler)
+void xmpp_handler_delete(xmpp_conn_t *conn, xmpp_handler handler)
 {
     xmpp_handlist_t *prev, *item;
 
@@ -536,10 +535,10 @@ void xmpp_handler_delete(xmpp_conn_t *const conn, xmpp_handler handler)
  *
  *  @ingroup Handlers
  */
-void xmpp_timed_handler_add(xmpp_conn_t *const conn,
+void xmpp_timed_handler_add(xmpp_conn_t *conn,
                             xmpp_timed_handler handler,
-                            const unsigned long period,
-                            void *const userdata)
+                            unsigned long period,
+                            void *userdata)
 {
     _timed_handler_add(conn->ctx, &conn->timed_handlers, handler, period,
                        userdata, 1);
@@ -554,10 +553,10 @@ void xmpp_timed_handler_add(xmpp_conn_t *const conn,
  *  @param period the time in milliseconds between firings
  *  @param userdata an opaque data pointer that will be passed to the handler
  */
-void handler_add_timed(xmpp_conn_t *const conn,
+void handler_add_timed(xmpp_conn_t *conn,
                        xmpp_timed_handler handler,
-                       const unsigned long period,
-                       void *const userdata)
+                       unsigned long period,
+                       void *userdata)
 {
     _timed_handler_add(conn->ctx, &conn->timed_handlers, handler, period,
                        userdata, 0);
@@ -579,10 +578,10 @@ void handler_add_timed(xmpp_conn_t *const conn,
  *
  *  @ingroup Handlers
  */
-void xmpp_id_handler_add(xmpp_conn_t *const conn,
+void xmpp_id_handler_add(xmpp_conn_t *conn,
                          xmpp_handler handler,
-                         const char *const id,
-                         void *const userdata)
+                         const char *id,
+                         void *userdata)
 {
     _id_handler_add(conn, handler, id, userdata, 1);
 }
@@ -596,10 +595,10 @@ void xmpp_id_handler_add(xmpp_conn_t *const conn,
  *  @param id a string with the id
  *  @param userdata an opaque data pointer that will be passed to the handler
  */
-void handler_add_id(xmpp_conn_t *const conn,
+void handler_add_id(xmpp_conn_t *conn,
                     xmpp_handler handler,
-                    const char *const id,
-                    void *const userdata)
+                    const char *id,
+                    void *userdata)
 {
     _id_handler_add(conn, handler, id, userdata, 0);
 }
@@ -626,12 +625,12 @@ void handler_add_id(xmpp_conn_t *const conn,
  *
  *  @ingroup Handlers
  */
-void xmpp_handler_add(xmpp_conn_t *const conn,
+void xmpp_handler_add(xmpp_conn_t *conn,
                       xmpp_handler handler,
-                      const char *const ns,
-                      const char *const name,
-                      const char *const type,
-                      void *const userdata)
+                      const char *ns,
+                      const char *name,
+                      const char *type,
+                      void *userdata)
 {
     _handler_add(conn, handler, ns, name, type, userdata, 1);
 }
@@ -647,12 +646,12 @@ void xmpp_handler_add(xmpp_conn_t *const conn,
  *  @param type a string with the 'type' attribute value to match
  *  @param userdata an opaque data pointer that will be passed to the handler
  */
-void handler_add(xmpp_conn_t *const conn,
+void handler_add(xmpp_conn_t *conn,
                  xmpp_handler handler,
-                 const char *const ns,
-                 const char *const name,
-                 const char *const type,
-                 void *const userdata)
+                 const char *ns,
+                 const char *name,
+                 const char *type,
+                 void *userdata)
 {
     _handler_add(conn, handler, ns, name, type, userdata, 0);
 }
@@ -762,10 +761,10 @@ void handler_system_delete_all(xmpp_conn_t *conn)
  *
  *  @ingroup Handlers
  */
-void xmpp_global_timed_handler_add(xmpp_ctx_t *const ctx,
+void xmpp_global_timed_handler_add(xmpp_ctx_t *ctx,
                                    xmpp_global_timed_handler handler,
-                                   const unsigned long period,
-                                   void *const userdata)
+                                   unsigned long period,
+                                   void *userdata)
 {
     _timed_handler_add(ctx, &ctx->timed_handlers, handler, period, userdata, 1);
 }
@@ -777,7 +776,7 @@ void xmpp_global_timed_handler_add(xmpp_ctx_t *const ctx,
  *
  *  @ingroup Handlers
  */
-void xmpp_global_timed_handler_delete(xmpp_ctx_t *const ctx,
+void xmpp_global_timed_handler_delete(xmpp_ctx_t *ctx,
                                       xmpp_global_timed_handler handler)
 {
     _timed_handler_delete(ctx, &ctx->timed_handlers, handler);
diff --git a/src/hash.c b/src/hash.c
index 85d8c15..d23810d 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -46,8 +46,7 @@ struct _hash_iterator_t {
 };
 
 /** allocate and initialize a new hash table */
-hash_t *
-hash_new(xmpp_ctx_t *const ctx, const int size, hash_free_func free_func)
+hash_t *hash_new(xmpp_ctx_t *ctx, int size, hash_free_func free_func)
 {
     hash_t *result = NULL;
 
@@ -72,14 +71,14 @@ hash_new(xmpp_ctx_t *const ctx, const int size, hash_free_func free_func)
 }
 
 /** obtain a new reference to an existing hash table */
-hash_t *hash_clone(hash_t *const table)
+hash_t *hash_clone(hash_t *table)
 {
     table->ref++;
     return table;
 }
 
 /** release a hash table that is no longer needed */
-void hash_release(hash_t *const table)
+void hash_release(hash_t *table)
 {
     xmpp_ctx_t *ctx = table->ctx;
     hashentry_t *entry, *next;
@@ -143,7 +142,7 @@ hashentry_t *_hash_entry_find(hash_t *table, const char *key)
  *  each key can appear only once; the value of any
  *  identical key will be replaced
  */
-int hash_add(hash_t *table, const char *const key, void *data)
+int hash_add(hash_t *table, const char *key, void *data)
 {
     xmpp_ctx_t *ctx = table->ctx;
     hashentry_t *entry = NULL;
diff --git a/src/hash.h b/src/hash.h
index eb80880..4e50fb3 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -18,23 +18,22 @@
 
 typedef struct _hash_t hash_t;
 
-typedef void (*hash_free_func)(const xmpp_ctx_t *const ctx, void *p);
+typedef void (*hash_free_func)(const xmpp_ctx_t *ctx, void *p);
 
 /** allocate and initialize a new hash table */
-hash_t *
-hash_new(xmpp_ctx_t *const ctx, const int size, hash_free_func free_func);
+hash_t *hash_new(xmpp_ctx_t *ctx, int size, hash_free_func free_func);
 
 /** allocate a new reference to an existing hash table */
-hash_t *hash_clone(hash_t *const table);
+hash_t *hash_clone(hash_t *table);
 
 /** release a hash table when no longer needed */
-void hash_release(hash_t *const table);
+void hash_release(hash_t *table);
 
 /** add a key, value pair to a hash table.
  *  each key can appear only once; the value of any
  *  identical key will be replaced
  */
-int hash_add(hash_t *table, const char *const key, void *data);
+int hash_add(hash_t *table, const char *key, void *data);
 
 /** look up a key in a hash table */
 void *hash_get(hash_t *table, const char *key);
diff --git a/src/parser.h b/src/parser.h
index 1a47ff5..dd735d9 100644
--- a/src/parser.h
+++ b/src/parser.h
@@ -20,12 +20,9 @@
 
 typedef struct _parser_t parser_t;
 
-typedef void (*parser_start_callback)(char *name,
-                                      char **attrs,
-                                      void *const userdata);
-typedef void (*parser_end_callback)(char *name, void *const userdata);
-typedef void (*parser_stanza_callback)(xmpp_stanza_t *stanza,
-                                       void *const userdata);
+typedef void (*parser_start_callback)(char *name, char **attrs, void *userdata);
+typedef void (*parser_end_callback)(char *name, void *userdata);
+typedef void (*parser_stanza_callback)(xmpp_stanza_t *stanza, void *userdata);
 
 parser_t *parser_new(xmpp_ctx_t *ctx,
                      parser_start_callback startcb,
diff --git a/src/sasl.c b/src/sasl.c
index 0ad6d7a..0a6eccc 100644
--- a/src/sasl.c
+++ b/src/sasl.c
@@ -65,7 +65,7 @@ char *sasl_plain(xmpp_ctx_t *ctx, const char *authid, const char *password)
 /** helpers for digest auth */
 
 /* create a new, null-terminated string from a substring */
-static char *_make_string(xmpp_ctx_t *ctx, const char *s, const unsigned len)
+static char *_make_string(xmpp_ctx_t *ctx, const char *s, unsigned len)
 {
     char *result;
 
diff --git a/src/sha1.c b/src/sha1.c
index 2041c34..00976d4 100644
--- a/src/sha1.c
+++ b/src/sha1.c
@@ -206,9 +206,7 @@ void crypto_SHA1_Init(SHA1_CTX *context)
 }
 
 /* Run your data through this. */
-void crypto_SHA1_Update(SHA1_CTX *context,
-                        const uint8_t *data,
-                        const size_t len)
+void crypto_SHA1_Update(SHA1_CTX *context, const uint8_t *data, size_t len)
 {
     size_t i, j;
 
diff --git a/src/sha1.h b/src/sha1.h
index 2f9a293..8da4d54 100644
--- a/src/sha1.h
+++ b/src/sha1.h
@@ -24,9 +24,7 @@ typedef struct {
 #define SHA1_DIGEST_SIZE 20
 
 void crypto_SHA1_Init(SHA1_CTX *context);
-void crypto_SHA1_Update(SHA1_CTX *context,
-                        const uint8_t *data,
-                        const size_t len);
+void crypto_SHA1_Update(SHA1_CTX *context, const uint8_t *data, size_t len);
 void crypto_SHA1_Final(SHA1_CTX *context, uint8_t *digest);
 void crypto_SHA1(const uint8_t *data, size_t len, uint8_t *digest);
 
diff --git a/src/sock.c b/src/sock.c
index 5e98db5..cbbd1dd 100644
--- a/src/sock.c
+++ b/src/sock.c
@@ -69,7 +69,7 @@ static int _in_progress(int error)
 #endif
 }
 
-sock_t sock_connect(const char *const host, const unsigned short port)
+sock_t sock_connect(const char *host, unsigned short port)
 {
     sock_t sock;
     char service[6];
@@ -109,7 +109,7 @@ sock_t sock_connect(const char *const host, const unsigned short port)
     return sock;
 }
 
-int sock_set_keepalive(const sock_t sock, int timeout, int interval)
+int sock_set_keepalive(sock_t sock, int timeout, int interval)
 {
     int ret;
     int optval = (timeout && interval) ? 1 : 0;
@@ -154,7 +154,7 @@ int sock_set_keepalive(const sock_t sock, int timeout, int interval)
     return ret;
 }
 
-int sock_close(const sock_t sock)
+int sock_close(sock_t sock)
 {
 #ifdef _WIN32
     return closesocket(sock);
@@ -180,27 +180,27 @@ static int _sock_set_blocking_mode(sock_t sock, int blocking)
 #endif
 }
 
-int sock_set_blocking(const sock_t sock)
+int sock_set_blocking(sock_t sock)
 {
     return _sock_set_blocking_mode(sock, 1);
 }
 
-int sock_set_nonblocking(const sock_t sock)
+int sock_set_nonblocking(sock_t sock)
 {
     return _sock_set_blocking_mode(sock, 0);
 }
 
-int sock_read(const sock_t sock, void *const buff, const size_t len)
+int sock_read(sock_t sock, void *buff, size_t len)
 {
     return recv(sock, buff, len, 0);
 }
 
-int sock_write(const sock_t sock, const void *const buff, const size_t len)
+int sock_write(sock_t sock, const void *buff, size_t len)
 {
     return send(sock, buff, len, 0);
 }
 
-int sock_is_recoverable(const int error)
+int sock_is_recoverable(int error)
 {
 #ifdef _WIN32
     return (error == WSAEINTR || error == WSAEWOULDBLOCK ||
@@ -210,7 +210,7 @@ int sock_is_recoverable(const int error)
 #endif
 }
 
-int sock_connect_error(const sock_t sock)
+int sock_connect_error(sock_t sock)
 {
     struct sockaddr_storage ss;
     struct sockaddr *sa = (struct sockaddr *)&ss;
diff --git a/src/sock.h b/src/sock.h
index 33825b0..ecd4686 100644
--- a/src/sock.h
+++ b/src/sock.h
@@ -30,16 +30,16 @@ void sock_shutdown(void);
 
 int sock_error(void);
 
-sock_t sock_connect(const char *const host, const unsigned short port);
-int sock_close(const sock_t sock);
+sock_t sock_connect(const char *host, unsigned short port);
+int sock_close(sock_t sock);
 
-int sock_set_blocking(const sock_t sock);
-int sock_set_nonblocking(const sock_t sock);
-int sock_read(const sock_t sock, void *const buff, const size_t len);
-int sock_write(const sock_t sock, const void *const buff, const size_t len);
-int sock_is_recoverable(const int error);
+int sock_set_blocking(sock_t sock);
+int sock_set_nonblocking(sock_t sock);
+int sock_read(sock_t sock, void *buff, size_t len);
+int sock_write(sock_t sock, const void *buff, size_t len);
+int sock_is_recoverable(int error);
 /* checks for an error after connect, return 0 if connect successful */
-int sock_connect_error(const sock_t sock);
-int sock_set_keepalive(const sock_t sock, int timeout, int interval);
+int sock_connect_error(sock_t sock);
+int sock_set_keepalive(sock_t sock, int timeout, int interval);
 
 #endif /* __LIBSTROPHE_SOCK_H__ */
diff --git a/src/stanza.c b/src/stanza.c
index e18116c..15356cf 100644
--- a/src/stanza.c
+++ b/src/stanza.c
@@ -64,7 +64,7 @@ xmpp_stanza_t *xmpp_stanza_new(xmpp_ctx_t *ctx)
  *
  *  @ingroup Stanza
  */
-xmpp_stanza_t *xmpp_stanza_clone(xmpp_stanza_t *const stanza)
+xmpp_stanza_t *xmpp_stanza_clone(xmpp_stanza_t *stanza)
 {
     stanza->ref++;
 
@@ -74,8 +74,7 @@ xmpp_stanza_t *xmpp_stanza_clone(xmpp_stanza_t *const stanza)
 /*
  * Copy the attributes of stanza src into stanza dst. Return -1 on error.
  */
-static int _stanza_copy_attributes(xmpp_stanza_t *dst,
-                                   const xmpp_stanza_t *const src)
+static int _stanza_copy_attributes(xmpp_stanza_t *dst, const xmpp_stanza_t *src)
 {
     hash_iterator_t *iter;
     const char *key;
@@ -114,7 +113,7 @@ static int _stanza_copy_attributes(xmpp_stanza_t *dst,
  *
  *  @ingroup Stanza
  */
-xmpp_stanza_t *xmpp_stanza_copy(const xmpp_stanza_t *const stanza)
+xmpp_stanza_t *xmpp_stanza_copy(const xmpp_stanza_t *stanza)
 {
     xmpp_stanza_t *copy, *child, *copychild, *tail;
 
@@ -169,7 +168,7 @@ copy_error:
  *
  *  @ingroup Stanza
  */
-int xmpp_stanza_release(xmpp_stanza_t *const stanza)
+int xmpp_stanza_release(xmpp_stanza_t *stanza)
 {
     int released = 0;
     xmpp_stanza_t *child, *tchild;
@@ -205,7 +204,7 @@ int xmpp_stanza_release(xmpp_stanza_t *const stanza)
  *
  *  @ingroup Stanza
  */
-xmpp_ctx_t *xmpp_stanza_get_context(const xmpp_stanza_t *const stanza)
+xmpp_ctx_t *xmpp_stanza_get_context(const xmpp_stanza_t *stanza)
 {
     return stanza->ctx;
 }
@@ -218,7 +217,7 @@ xmpp_ctx_t *xmpp_stanza_get_context(const xmpp_stanza_t *const stanza)
  *
  *  @ingroup Stanza
  */
-int xmpp_stanza_is_text(xmpp_stanza_t *const stanza)
+int xmpp_stanza_is_text(xmpp_stanza_t *stanza)
 {
     return (stanza && stanza->type == XMPP_STANZA_TEXT);
 }
@@ -231,7 +230,7 @@ int xmpp_stanza_is_text(xmpp_stanza_t *const stanza)
  *
  *  @ingroup Stanza
  */
-int xmpp_stanza_is_tag(xmpp_stanza_t *const stanza)
+int xmpp_stanza_is_tag(xmpp_stanza_t *stanza)
 {
     return (stanza && stanza->type == XMPP_STANZA_TAG);
 }
@@ -242,7 +241,7 @@ int xmpp_stanza_is_tag(xmpp_stanza_t *const stanza)
  * On failure, returns NULL.
  */
 
-static char *_escape_xml(xmpp_ctx_t *const ctx, char *text)
+static char *_escape_xml(xmpp_ctx_t *ctx, char *text)
 {
     size_t len = 0;
     char *src;
@@ -295,11 +294,8 @@ static char *_escape_xml(xmpp_ctx_t *const ctx, char *text)
 }
 
 /* small helper function */
-static void _render_update(int *written,
-                           const int length,
-                           const int lastwrite,
-                           size_t *left,
-                           char **ptr)
+static void _render_update(
+    int *written, int length, int lastwrite, size_t *left, char **ptr)
 {
     *written += lastwrite;
 
@@ -317,9 +313,8 @@ static void _render_update(int *written,
  * return values < 0 indicate some error occurred,
  * and return values > buflen indicate buffer was not large enough
  */
-static int _render_stanza_recursive(xmpp_stanza_t *stanza,
-                                    char *const buf,
-                                    size_t const buflen)
+static int
+_render_stanza_recursive(xmpp_stanza_t *stanza, char *buf, size_t buflen)
 {
     char *ptr = buf;
     size_t left = buflen;
@@ -444,9 +439,7 @@ static int _render_stanza_recursive(xmpp_stanza_t *stanza,
  *
  *  @ingroup Stanza
  */
-int xmpp_stanza_to_text(xmpp_stanza_t *stanza,
-                        char **const buf,
-                        size_t *const buflen)
+int xmpp_stanza_to_text(xmpp_stanza_t *stanza, char **buf, size_t *buflen)
 {
     char *buffer, *tmp;
     size_t length;
@@ -507,7 +500,7 @@ int xmpp_stanza_to_text(xmpp_stanza_t *stanza,
  *
  *  @ingroup Stanza
  */
-int xmpp_stanza_set_name(xmpp_stanza_t *stanza, const char *const name)
+int xmpp_stanza_set_name(xmpp_stanza_t *stanza, const char *name)
 {
     if (stanza->type == XMPP_STANZA_TEXT)
         return XMPP_EINVOP;
@@ -531,7 +524,7 @@ int xmpp_stanza_set_name(xmpp_stanza_t *stanza, const char *const name)
  *
  *  @ingroup Stanza
  */
-const char *xmpp_stanza_get_name(xmpp_stanza_t *const stanza)
+const char *xmpp_stanza_get_name(xmpp_stanza_t *stanza)
 {
     if (stanza->type == XMPP_STANZA_TEXT)
         return NULL;
@@ -546,7 +539,7 @@ const char *xmpp_stanza_get_name(xmpp_stanza_t *const stanza)
  *
  *  @ingroup Stanza
  */
-int xmpp_stanza_get_attribute_count(xmpp_stanza_t *const stanza)
+int xmpp_stanza_get_attribute_count(xmpp_stanza_t *stanza)
 {
     if (stanza->attributes == NULL) {
         return 0;
@@ -569,7 +562,7 @@ int xmpp_stanza_get_attribute_count(xmpp_stanza_t *const stanza)
  *
  *  @ingroup Stanza
  */
-int xmpp_stanza_get_attributes(xmpp_stanza_t *const stanza,
+int xmpp_stanza_get_attributes(xmpp_stanza_t *stanza,
                                const char **attr,
                                int attrlen)
 {
@@ -611,9 +604,9 @@ int xmpp_stanza_get_attributes(xmpp_stanza_t *const stanza,
  *
  *  @ingroup Stanza
  */
-int xmpp_stanza_set_attribute(xmpp_stanza_t *const stanza,
-                              const char *const key,
-                              const char *const value)
+int xmpp_stanza_set_attribute(xmpp_stanza_t *stanza,
+                              const char *key,
+                              const char *value)
 {
     char *val;
     int rc;
@@ -652,7 +645,7 @@ int xmpp_stanza_set_attribute(xmpp_stanza_t *const stanza,
  *
  *  @ingroup Stanza
  */
-int xmpp_stanza_set_ns(xmpp_stanza_t *const stanza, const char *const ns)
+int xmpp_stanza_set_ns(xmpp_stanza_t *stanza, const char *ns)
 {
     return xmpp_stanza_set_attribute(stanza, "xmlns", ns);
 }
@@ -727,7 +720,7 @@ int xmpp_stanza_add_child(xmpp_stanza_t *stanza, xmpp_stanza_t *child)
  *
  *  @ingroup Stanza
  */
-int xmpp_stanza_set_text(xmpp_stanza_t *stanza, const char *const text)
+int xmpp_stanza_set_text(xmpp_stanza_t *stanza, const char *text)
 {
     if (stanza->type == XMPP_STANZA_TAG)
         return XMPP_EINVOP;
@@ -756,8 +749,8 @@ int xmpp_stanza_set_text(xmpp_stanza_t *stanza, const char *const text)
  *  @ingroup Stanza
  */
 int xmpp_stanza_set_text_with_size(xmpp_stanza_t *stanza,
-                                   const char *const text,
-                                   const size_t size)
+                                   const char *text,
+                                   size_t size)
 {
     if (stanza->type == XMPP_STANZA_TAG)
         return XMPP_EINVOP;
@@ -786,7 +779,7 @@ int xmpp_stanza_set_text_with_size(xmpp_stanza_t *stanza,
  *
  *  @ingroup Stanza
  */
-const char *xmpp_stanza_get_id(xmpp_stanza_t *const stanza)
+const char *xmpp_stanza_get_id(xmpp_stanza_t *stanza)
 {
     return xmpp_stanza_get_attribute(stanza, "id");
 }
@@ -801,7 +794,7 @@ const char *xmpp_stanza_get_id(xmpp_stanza_t *const stanza)
  *
  *  @ingroup Stanza
  */
-const char *xmpp_stanza_get_ns(xmpp_stanza_t *const stanza)
+const char *xmpp_stanza_get_ns(xmpp_stanza_t *stanza)
 {
     return xmpp_stanza_get_attribute(stanza, "xmlns");
 }
@@ -816,7 +809,7 @@ const char *xmpp_stanza_get_ns(xmpp_stanza_t *const stanza)
  *
  *  @ingroup Stanza
  */
-const char *xmpp_stanza_get_type(xmpp_stanza_t *const stanza)
+const char *xmpp_stanza_get_type(xmpp_stanza_t *stanza)
 {
     return xmpp_stanza_get_attribute(stanza, "type");
 }
@@ -831,7 +824,7 @@ const char *xmpp_stanza_get_type(xmpp_stanza_t *const stanza)
  *
  *  @ingroup Stanza
  */
-const char *xmpp_stanza_get_to(xmpp_stanza_t *const stanza)
+const char *xmpp_stanza_get_to(xmpp_stanza_t *stanza)
 {
     return xmpp_stanza_get_attribute(stanza, "to");
 }
@@ -846,7 +839,7 @@ const char *xmpp_stanza_get_to(xmpp_stanza_t *const stanza)
  *
  *  @ingroup Stanza
  */
-const char *xmpp_stanza_get_from(xmpp_stanza_t *const stanza)
+const char *xmpp_stanza_get_from(xmpp_stanza_t *stanza)
 {
     return xmpp_stanza_get_attribute(stanza, "from");
 }
@@ -862,8 +855,8 @@ const char *xmpp_stanza_get_from(xmpp_stanza_t *const stanza)
  *
  *  @ingroup Stanza
  */
-xmpp_stanza_t *xmpp_stanza_get_child_by_name(xmpp_stanza_t *const stanza,
-                                             const char *const name)
+xmpp_stanza_t *xmpp_stanza_get_child_by_name(xmpp_stanza_t *stanza,
+                                             const char *name)
 {
     xmpp_stanza_t *child;
 
@@ -888,8 +881,8 @@ xmpp_stanza_t *xmpp_stanza_get_child_by_name(xmpp_stanza_t *const stanza,
  *
  *  @ingroup Stanza
  */
-xmpp_stanza_t *xmpp_stanza_get_child_by_ns(xmpp_stanza_t *const stanza,
-                                           const char *const ns)
+xmpp_stanza_t *xmpp_stanza_get_child_by_ns(xmpp_stanza_t *stanza,
+                                           const char *ns)
 {
     xmpp_stanza_t *child;
     const char *child_ns;
@@ -916,9 +909,9 @@ xmpp_stanza_t *xmpp_stanza_get_child_by_ns(xmpp_stanza_t *const stanza,
  *
  *  @ingroup Stanza
  */
-xmpp_stanza_t *xmpp_stanza_get_child_by_name_and_ns(xmpp_stanza_t *const stanza,
-                                                    const char *const name,
-                                                    const char *const ns)
+xmpp_stanza_t *xmpp_stanza_get_child_by_name_and_ns(xmpp_stanza_t *stanza,
+                                                    const char *name,
+                                                    const char *ns)
 {
     xmpp_stanza_t *child;
     const char *child_ns;
@@ -947,7 +940,7 @@ xmpp_stanza_t *xmpp_stanza_get_child_by_name_and_ns(xmpp_stanza_t *const stanza,
  *
  *  @ingroup Stanza
  */
-xmpp_stanza_t *xmpp_stanza_get_children(xmpp_stanza_t *const stanza)
+xmpp_stanza_t *xmpp_stanza_get_children(xmpp_stanza_t *stanza)
 {
     return stanza->children;
 }
@@ -960,7 +953,7 @@ xmpp_stanza_t *xmpp_stanza_get_children(xmpp_stanza_t *const stanza)
  *
  *  @ingroup Stanza
  */
-xmpp_stanza_t *xmpp_stanza_get_next(xmpp_stanza_t *const stanza)
+xmpp_stanza_t *xmpp_stanza_get_next(xmpp_stanza_t *stanza)
 {
     return stanza->next;
 }
@@ -976,7 +969,7 @@ xmpp_stanza_t *xmpp_stanza_get_next(xmpp_stanza_t *const stanza)
  *
  *  @ingroup Stanza
  */
-char *xmpp_stanza_get_text(xmpp_stanza_t *const stanza)
+char *xmpp_stanza_get_text(xmpp_stanza_t *stanza)
 {
     size_t len, clen;
     xmpp_stanza_t *child;
@@ -1027,7 +1020,7 @@ char *xmpp_stanza_get_text(xmpp_stanza_t *const stanza)
  *
  *  @ingroup Stanza
  */
-const char *xmpp_stanza_get_text_ptr(xmpp_stanza_t *const stanza)
+const char *xmpp_stanza_get_text_ptr(xmpp_stanza_t *stanza)
 {
     if (stanza->type == XMPP_STANZA_TEXT)
         return stanza->data;
@@ -1046,7 +1039,7 @@ const char *xmpp_stanza_get_text_ptr(xmpp_stanza_t *const stanza)
  *
  *  @ingroup Stanza
  */
-int xmpp_stanza_set_id(xmpp_stanza_t *const stanza, const char *const id)
+int xmpp_stanza_set_id(xmpp_stanza_t *stanza, const char *id)
 {
     return xmpp_stanza_set_attribute(stanza, "id", id);
 }
@@ -1062,7 +1055,7 @@ int xmpp_stanza_set_id(xmpp_stanza_t *const stanza, const char *const id)
  *
  *  @ingroup Stanza
  */
-int xmpp_stanza_set_type(xmpp_stanza_t *const stanza, const char *const type)
+int xmpp_stanza_set_type(xmpp_stanza_t *stanza, const char *type)
 {
     return xmpp_stanza_set_attribute(stanza, "type", type);
 }
@@ -1079,7 +1072,7 @@ int xmpp_stanza_set_type(xmpp_stanza_t *const stanza, const char *const type)
  *
  *  @ingroup Stanza
  */
-int xmpp_stanza_set_to(xmpp_stanza_t *const stanza, const char *const to)
+int xmpp_stanza_set_to(xmpp_stanza_t *stanza, const char *to)
 {
     return xmpp_stanza_set_attribute(stanza, "to", to);
 }
@@ -1096,7 +1089,7 @@ int xmpp_stanza_set_to(xmpp_stanza_t *const stanza, const char *const to)
  *
  *  @ingroup Stanza
  */
-int xmpp_stanza_set_from(xmpp_stanza_t *const stanza, const char *const from)
+int xmpp_stanza_set_from(xmpp_stanza_t *stanza, const char *from)
 {
     return xmpp_stanza_set_attribute(stanza, "from", from);
 }
@@ -1112,8 +1105,7 @@ int xmpp_stanza_set_from(xmpp_stanza_t *const stanza, const char *const from)
  *
  *  @ingroup Stanza
  */
-const char *xmpp_stanza_get_attribute(xmpp_stanza_t *const stanza,
-                                      const char *const name)
+const char *xmpp_stanza_get_attribute(xmpp_stanza_t *stanza, const char *name)
 {
     if (stanza->type != XMPP_STANZA_TAG)
         return NULL;
@@ -1133,8 +1125,7 @@ const char *xmpp_stanza_get_attribute(xmpp_stanza_t *const stanza,
  *
  *  @ingroup Stanza
  */
-int xmpp_stanza_del_attribute(xmpp_stanza_t *const stanza,
-                              const char *const name)
+int xmpp_stanza_del_attribute(xmpp_stanza_t *stanza, const char *name)
 {
     if (stanza->type != XMPP_STANZA_TAG)
         return -1;
@@ -1157,7 +1148,7 @@ int xmpp_stanza_del_attribute(xmpp_stanza_t *const stanza,
  *
  *  @ingroup Stanza
  */
-xmpp_stanza_t *xmpp_stanza_reply(xmpp_stanza_t *const stanza)
+xmpp_stanza_t *xmpp_stanza_reply(xmpp_stanza_t *stanza)
 {
     xmpp_stanza_t *copy = NULL;
     const char *from;
@@ -1212,10 +1203,10 @@ copy_error:
  *
  *  @ingroup Stanza
  */
-xmpp_stanza_t *xmpp_stanza_reply_error(xmpp_stanza_t *const stanza,
-                                       const char *const error_type,
-                                       const char *const condition,
-                                       const char *const text)
+xmpp_stanza_t *xmpp_stanza_reply_error(xmpp_stanza_t *stanza,
+                                       const char *error_type,
+                                       const char *condition,
+                                       const char *text)
 {
     xmpp_ctx_t *ctx = stanza->ctx;
     xmpp_stanza_t *reply = NULL;
@@ -1277,10 +1268,10 @@ quit_err:
 }
 
 static xmpp_stanza_t *_stanza_new_with_attrs(xmpp_ctx_t *ctx,
-                                             const char *const name,
-                                             const char *const type,
-                                             const char *const id,
-                                             const char *const to)
+                                             const char *name,
+                                             const char *type,
+                                             const char *id,
+                                             const char *to)
 {
     xmpp_stanza_t *stanza = xmpp_stanza_new(ctx);
     int ret;
@@ -1314,9 +1305,9 @@ static xmpp_stanza_t *_stanza_new_with_attrs(xmpp_ctx_t *ctx,
  *  @ingroup Stanza
  */
 xmpp_stanza_t *xmpp_message_new(xmpp_ctx_t *ctx,
-                                const char *const type,
-                                const char *const to,
-                                const char *const id)
+                                const char *type,
+                                const char *to,
+                                const char *id)
 {
     return _stanza_new_with_attrs(ctx, "message", type, id, to);
 }
@@ -1355,7 +1346,7 @@ char *xmpp_message_get_body(xmpp_stanza_t *msg)
  *
  *  @ingroup Stanza
  */
-int xmpp_message_set_body(xmpp_stanza_t *msg, const char *const text)
+int xmpp_message_set_body(xmpp_stanza_t *msg, const char *text)
 {
     xmpp_ctx_t *ctx = msg->ctx;
     xmpp_stanza_t *body;
@@ -1401,8 +1392,7 @@ int xmpp_message_set_body(xmpp_stanza_t *msg, const char *const text)
  *
  *  @ingroup Stanza
  */
-xmpp_stanza_t *
-xmpp_iq_new(xmpp_ctx_t *ctx, const char *const type, const char *const id)
+xmpp_stanza_t *xmpp_iq_new(xmpp_ctx_t *ctx, const char *type, const char *id)
 {
     return _stanza_new_with_attrs(ctx, "iq", type, id, NULL);
 }
@@ -1433,9 +1423,8 @@ xmpp_stanza_t *xmpp_presence_new(xmpp_ctx_t *ctx)
  *
  *  @ingroup Stanza
  */
-xmpp_stanza_t *xmpp_error_new(xmpp_ctx_t *ctx,
-                              xmpp_error_type_t const type,
-                              const char *const text)
+xmpp_stanza_t *
+xmpp_error_new(xmpp_ctx_t *ctx, xmpp_error_type_t type, const char *text)
 {
     xmpp_stanza_t *error =
         _stanza_new_with_attrs(ctx, "stream:error", NULL, NULL, NULL);
diff --git a/src/tls.h b/src/tls.h
index 6c0c3e7..692f5c9 100644
--- a/src/tls.h
+++ b/src/tls.h
@@ -35,8 +35,8 @@ int tls_stop(tls_t *tls);
 int tls_error(tls_t *tls);
 
 int tls_pending(tls_t *tls);
-int tls_read(tls_t *tls, void *const buff, const size_t len);
-int tls_write(tls_t *tls, const void *const buff, const size_t len);
+int tls_read(tls_t *tls, void *buff, size_t len);
+int tls_write(tls_t *tls, const void *buff, size_t len);
 
 int tls_clear_pending_write(tls_t *tls);
 int tls_is_recoverable(int error);
diff --git a/src/tls_dummy.c b/src/tls_dummy.c
index 5eb9987..9ad7611 100644
--- a/src/tls_dummy.c
+++ b/src/tls_dummy.c
@@ -78,7 +78,7 @@ int tls_pending(tls_t *tls)
     return 0;
 }
 
-int tls_read(tls_t *tls, void *const buff, const size_t len)
+int tls_read(tls_t *tls, void *buff, size_t len)
 {
     UNUSED(tls);
     UNUSED(buff);
@@ -86,7 +86,7 @@ int tls_read(tls_t *tls, void *const buff, const size_t len)
     return -1;
 }
 
-int tls_write(tls_t *tls, const void *const buff, const size_t len)
+int tls_write(tls_t *tls, const void *buff, size_t len)
 {
     UNUSED(tls);
     UNUSED(buff);
diff --git a/src/tls_gnutls.c b/src/tls_gnutls.c
index 9aa422e..0a84afb 100644
--- a/src/tls_gnutls.c
+++ b/src/tls_gnutls.c
@@ -120,7 +120,7 @@ int tls_pending(tls_t *tls)
     return gnutls_record_check_pending(tls->session);
 }
 
-int tls_read(tls_t *tls, void *const buff, const size_t len)
+int tls_read(tls_t *tls, void *buff, size_t len)
 {
     int ret;
 
@@ -130,7 +130,7 @@ int tls_read(tls_t *tls, void *const buff, const size_t len)
     return ret;
 }
 
-int tls_write(tls_t *tls, const void *const buff, const size_t len)
+int tls_write(tls_t *tls, const void *buff, size_t len)
 {
     int ret;
 
diff --git a/src/tls_openssl.c b/src/tls_openssl.c
index e517a2b..8f10f46 100644
--- a/src/tls_openssl.c
+++ b/src/tls_openssl.c
@@ -405,7 +405,7 @@ int tls_pending(tls_t *tls)
     return SSL_pending(tls->ssl);
 }
 
-int tls_read(tls_t *tls, void *const buff, const size_t len)
+int tls_read(tls_t *tls, void *buff, size_t len)
 {
     int ret;
 
@@ -415,7 +415,7 @@ int tls_read(tls_t *tls, void *const buff, const size_t len)
     return ret;
 }
 
-int tls_write(tls_t *tls, const void *const buff, const size_t len)
+int tls_write(tls_t *tls, const void *buff, size_t len)
 {
     int ret;
 
diff --git a/src/tls_schannel.c b/src/tls_schannel.c
index 3532c36..7191670 100644
--- a/src/tls_schannel.c
+++ b/src/tls_schannel.c
@@ -412,7 +412,7 @@ int tls_pending(tls_t *tls)
     return 0;
 }
 
-int tls_read(tls_t *tls, void *const buff, const size_t len)
+int tls_read(tls_t *tls, void *buff, size_t len)
 {
     int bytes;
 
@@ -557,7 +557,7 @@ int tls_clear_pending_write(tls_t *tls)
     return 1;
 }
 
-int tls_write(tls_t *tls, const void *const buff, const size_t len)
+int tls_write(tls_t *tls, const void *buff, size_t len)
 {
     SecBufferDesc sbdenc;
     SecBuffer sbenc[4];
diff --git a/src/util.c b/src/util.c
index 66f44aa..c9394df 100644
--- a/src/util.c
+++ b/src/util.c
@@ -38,7 +38,7 @@
  *
  *  @return a new allocates string with the same data as s or NULL on error
  */
-char *xmpp_strdup(const xmpp_ctx_t *const ctx, const char *const s)
+char *xmpp_strdup(const xmpp_ctx_t *ctx, const char *s)
 {
     size_t len;
     char *copy;
@@ -135,7 +135,7 @@ uint64_t time_elapsed(uint64_t t1, uint64_t t2)
  *
  *  @param conn a Strophe connection object
  */
-void disconnect_mem_error(xmpp_conn_t *const conn)
+void disconnect_mem_error(xmpp_conn_t *conn)
 {
     xmpp_error(conn->ctx, "xmpp", "Memory allocation error");
     xmpp_disconnect(conn);
diff --git a/strophe.h b/strophe.h
index daa244a..d38a8bc 100644
--- a/strophe.h
+++ b/strophe.h
@@ -122,18 +122,17 @@ typedef struct _xmpp_log_t xmpp_log_t;
 /* opaque run time context containing the above hooks */
 typedef struct _xmpp_ctx_t xmpp_ctx_t;
 
-xmpp_ctx_t *xmpp_ctx_new(const xmpp_mem_t *const mem,
-                         const xmpp_log_t *const log);
-void xmpp_ctx_free(xmpp_ctx_t *const ctx);
+xmpp_ctx_t *xmpp_ctx_new(const xmpp_mem_t *mem, const xmpp_log_t *log);
+void xmpp_ctx_free(xmpp_ctx_t *ctx);
 
 /* free some blocks returned by other APIs, for example the
    buffer you get from xmpp_stanza_to_text */
-void xmpp_free(const xmpp_ctx_t *const ctx, void *p);
+void xmpp_free(const xmpp_ctx_t *ctx, void *p);
 
 struct _xmpp_mem_t {
-    void *(*alloc)(const size_t size, void *const userdata);
-    void (*free)(void *p, void *const userdata);
-    void *(*realloc)(void *p, const size_t size, void *const userdata);
+    void *(*alloc)(size_t size, void *userdata);
+    void (*free)(void *p, void *userdata);
+    void *(*realloc)(void *p, size_t size, void *userdata);
     void *userdata;
 };
 
@@ -146,10 +145,10 @@ typedef enum {
 
 typedef enum { XMPP_UNKNOWN, XMPP_CLIENT, XMPP_COMPONENT } xmpp_conn_type_t;
 
-typedef void (*xmpp_log_handler)(void *const userdata,
-                                 const xmpp_log_level_t level,
-                                 const char *const area,
-                                 const char *const msg);
+typedef void (*xmpp_log_handler)(void *userdata,
+                                 xmpp_log_level_t level,
+                                 const char *area,
+                                 const char *msg);
 
 struct _xmpp_log_t {
     xmpp_log_handler handler;
@@ -219,112 +218,103 @@ typedef struct {
     xmpp_stanza_t *stanza;
 } xmpp_stream_error_t;
 
-typedef void (*xmpp_conn_handler)(xmpp_conn_t *const conn,
-                                  const xmpp_conn_event_t event,
-                                  const int error,
-                                  xmpp_stream_error_t *const stream_error,
-                                  void *const userdata);
+typedef void (*xmpp_conn_handler)(xmpp_conn_t *conn,
+                                  xmpp_conn_event_t event,
+                                  int error,
+                                  xmpp_stream_error_t *stream_error,
+                                  void *userdata);
 
-void xmpp_send_error(xmpp_conn_t *const conn,
-                     xmpp_error_type_t const type,
-                     char *const text);
-xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t *const ctx);
-xmpp_conn_t *xmpp_conn_clone(xmpp_conn_t *const conn);
-int xmpp_conn_release(xmpp_conn_t *const conn);
+void xmpp_send_error(xmpp_conn_t *conn, xmpp_error_type_t type, char *text);
+xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t *ctx);
+xmpp_conn_t *xmpp_conn_clone(xmpp_conn_t *conn);
+int xmpp_conn_release(xmpp_conn_t *conn);
 
-long xmpp_conn_get_flags(const xmpp_conn_t *const conn);
-int xmpp_conn_set_flags(xmpp_conn_t *const conn, long flags);
-const char *xmpp_conn_get_jid(const xmpp_conn_t *const conn);
-const char *xmpp_conn_get_bound_jid(const xmpp_conn_t *const conn);
-void xmpp_conn_set_jid(xmpp_conn_t *const conn, const char *const jid);
-const char *xmpp_conn_get_pass(const xmpp_conn_t *const conn);
-void xmpp_conn_set_pass(xmpp_conn_t *const conn, const char *const pass);
-xmpp_ctx_t *xmpp_conn_get_context(xmpp_conn_t *const conn);
-void xmpp_conn_disable_tls(xmpp_conn_t *const conn);
-int xmpp_conn_is_secured(xmpp_conn_t *const conn);
-void xmpp_conn_set_keepalive(xmpp_conn_t *const conn,
-                             int timeout,
-                             int interval);
-int xmpp_conn_is_connecting(xmpp_conn_t *const conn);
-int xmpp_conn_is_connected(xmpp_conn_t *const conn);
-int xmpp_conn_is_disconnected(xmpp_conn_t *const conn);
+long xmpp_conn_get_flags(const xmpp_conn_t *conn);
+int xmpp_conn_set_flags(xmpp_conn_t *conn, long flags);
+const char *xmpp_conn_get_jid(const xmpp_conn_t *conn);
+const char *xmpp_conn_get_bound_jid(const xmpp_conn_t *conn);
+void xmpp_conn_set_jid(xmpp_conn_t *conn, const char *jid);
+const char *xmpp_conn_get_pass(const xmpp_conn_t *conn);
+void xmpp_conn_set_pass(xmpp_conn_t *conn, const char *pass);
+xmpp_ctx_t *xmpp_conn_get_context(xmpp_conn_t *conn);
+void xmpp_conn_disable_tls(xmpp_conn_t *conn);
+int xmpp_conn_is_secured(xmpp_conn_t *conn);
+void xmpp_conn_set_keepalive(xmpp_conn_t *conn, int timeout, int interval);
+int xmpp_conn_is_connecting(xmpp_conn_t *conn);
+int xmpp_conn_is_connected(xmpp_conn_t *conn);
+int xmpp_conn_is_disconnected(xmpp_conn_t *conn);
 
-int xmpp_connect_client(xmpp_conn_t *const conn,
-                        const char *const altdomain,
+int xmpp_connect_client(xmpp_conn_t *conn,
+                        const char *altdomain,
                         unsigned short altport,
                         xmpp_conn_handler callback,
-                        void *const userdata);
+                        void *userdata);
 
-int xmpp_connect_component(xmpp_conn_t *const conn,
-                           const char *const server,
+int xmpp_connect_component(xmpp_conn_t *conn,
+                           const char *server,
                            unsigned short port,
                            xmpp_conn_handler callback,
-                           void *const userdata);
+                           void *userdata);
 
-int xmpp_connect_raw(xmpp_conn_t *const conn,
-                     const char *const altdomain,
+int xmpp_connect_raw(xmpp_conn_t *conn,
+                     const char *altdomain,
                      unsigned short altport,
                      xmpp_conn_handler callback,
-                     void *const userdata);
-int xmpp_conn_open_stream_default(xmpp_conn_t *const conn);
-int xmpp_conn_open_stream(xmpp_conn_t *const conn,
+                     void *userdata);
+int xmpp_conn_open_stream_default(xmpp_conn_t *conn);
+int xmpp_conn_open_stream(xmpp_conn_t *conn,
                           char **attributes,
                           size_t attributes_len);
-int xmpp_conn_tls_start(xmpp_conn_t *const conn);
+int xmpp_conn_tls_start(xmpp_conn_t *conn);
 
-void xmpp_disconnect(xmpp_conn_t *const conn);
+void xmpp_disconnect(xmpp_conn_t *conn);
 
-void xmpp_send(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza);
+void xmpp_send(xmpp_conn_t *conn, xmpp_stanza_t *stanza);
 
-void xmpp_send_raw_string(xmpp_conn_t *const conn, const char *const fmt, ...);
-void xmpp_send_raw(xmpp_conn_t *const conn,
-                   const char *const data,
-                   const size_t len);
+void xmpp_send_raw_string(xmpp_conn_t *conn, const char *fmt, ...);
+void xmpp_send_raw(xmpp_conn_t *conn, const char *data, size_t len);
 
 /* handlers */
 
 /* if the handler returns false it is removed */
-typedef int (*xmpp_timed_handler)(xmpp_conn_t *const conn,
-                                  void *const userdata);
+typedef int (*xmpp_timed_handler)(xmpp_conn_t *conn, void *userdata);
 
-void xmpp_timed_handler_add(xmpp_conn_t *const conn,
+void xmpp_timed_handler_add(xmpp_conn_t *conn,
                             xmpp_timed_handler handler,
-                            const unsigned long period,
-                            void *const userdata);
-void xmpp_timed_handler_delete(xmpp_conn_t *const conn,
-                               xmpp_timed_handler handler);
+                            unsigned long period,
+                            void *userdata);
+void xmpp_timed_handler_delete(xmpp_conn_t *conn, xmpp_timed_handler handler);
 
 /* if the handler returns false it is removed */
-typedef int (*xmpp_global_timed_handler)(xmpp_ctx_t *const ctx,
-                                         void *const userdata);
+typedef int (*xmpp_global_timed_handler)(xmpp_ctx_t *ctx, void *userdata);
 
-void xmpp_global_timed_handler_add(xmpp_ctx_t *const ctx,
+void xmpp_global_timed_handler_add(xmpp_ctx_t *ctx,
                                    xmpp_global_timed_handler handler,
-                                   const unsigned long period,
-                                   void *const userdata);
-void xmpp_global_timed_handler_delete(xmpp_ctx_t *const ctx,
+                                   unsigned long period,
+                                   void *userdata);
+void xmpp_global_timed_handler_delete(xmpp_ctx_t *ctx,
                                       xmpp_global_timed_handler handler);
 
 /* if the handler returns false it is removed */
-typedef int (*xmpp_handler)(xmpp_conn_t *const conn,
-                            xmpp_stanza_t *const stanza,
-                            void *const userdata);
+typedef int (*xmpp_handler)(xmpp_conn_t *conn,
+                            xmpp_stanza_t *stanza,
+                            void *userdata);
 
-void xmpp_handler_add(xmpp_conn_t *const conn,
+void xmpp_handler_add(xmpp_conn_t *conn,
                       xmpp_handler handler,
-                      const char *const ns,
-                      const char *const name,
-                      const char *const type,
-                      void *const userdata);
-void xmpp_handler_delete(xmpp_conn_t *const conn, xmpp_handler handler);
+                      const char *ns,
+                      const char *name,
+                      const char *type,
+                      void *userdata);
+void xmpp_handler_delete(xmpp_conn_t *conn, xmpp_handler handler);
 
-void xmpp_id_handler_add(xmpp_conn_t *const conn,
+void xmpp_id_handler_add(xmpp_conn_t *conn,
                          xmpp_handler handler,
-                         const char *const id,
-                         void *const userdata);
-void xmpp_id_handler_delete(xmpp_conn_t *const conn,
+                         const char *id,
+                         void *userdata);
+void xmpp_id_handler_delete(xmpp_conn_t *conn,
                             xmpp_handler handler,
-                            const char *const id);
+                            const char *id);
 
 /*
 void xmpp_register_stanza_handler(conn, stanza, xmlns, type, handler)
@@ -337,94 +327,88 @@ xmpp_stanza_t *xmpp_stanza_new(xmpp_ctx_t *ctx);
 xmpp_stanza_t *xmpp_stanza_new_from_string(xmpp_ctx_t *ctx, const char *str);
 
 /* clone a stanza */
-xmpp_stanza_t *xmpp_stanza_clone(xmpp_stanza_t *const stanza);
+xmpp_stanza_t *xmpp_stanza_clone(xmpp_stanza_t *stanza);
 
 /* copies a stanza and all children */
-xmpp_stanza_t *xmpp_stanza_copy(const xmpp_stanza_t *const stanza);
+xmpp_stanza_t *xmpp_stanza_copy(const xmpp_stanza_t *stanza);
 
 /* free a stanza object and it's contents */
-int xmpp_stanza_release(xmpp_stanza_t *const stanza);
+int xmpp_stanza_release(xmpp_stanza_t *stanza);
 
-xmpp_ctx_t *xmpp_stanza_get_context(const xmpp_stanza_t *const stanza);
+xmpp_ctx_t *xmpp_stanza_get_context(const xmpp_stanza_t *stanza);
 
-int xmpp_stanza_is_text(xmpp_stanza_t *const stanza);
-int xmpp_stanza_is_tag(xmpp_stanza_t *const stanza);
+int xmpp_stanza_is_text(xmpp_stanza_t *stanza);
+int xmpp_stanza_is_tag(xmpp_stanza_t *stanza);
 
 /* marshall a stanza into text for transmission or display */
-int xmpp_stanza_to_text(xmpp_stanza_t *stanza,
-                        char **const buf,
-                        size_t *const buflen);
+int xmpp_stanza_to_text(xmpp_stanza_t *stanza, char **buf, size_t *buflen);
 
-xmpp_stanza_t *xmpp_stanza_get_children(xmpp_stanza_t *const stanza);
-xmpp_stanza_t *xmpp_stanza_get_child_by_name(xmpp_stanza_t *const stanza,
-                                             const char *const name);
-xmpp_stanza_t *xmpp_stanza_get_child_by_ns(xmpp_stanza_t *const stanza,
-                                           const char *const ns);
-xmpp_stanza_t *xmpp_stanza_get_child_by_name_and_ns(xmpp_stanza_t *const stanza,
-                                                    const char *const name,
-                                                    const char *const ns);
-xmpp_stanza_t *xmpp_stanza_get_next(xmpp_stanza_t *const stanza);
+xmpp_stanza_t *xmpp_stanza_get_children(xmpp_stanza_t *stanza);
+xmpp_stanza_t *xmpp_stanza_get_child_by_name(xmpp_stanza_t *stanza,
+                                             const char *name);
+xmpp_stanza_t *xmpp_stanza_get_child_by_ns(xmpp_stanza_t *stanza,
+                                           const char *ns);
+xmpp_stanza_t *xmpp_stanza_get_child_by_name_and_ns(xmpp_stanza_t *stanza,
+                                                    const char *name,
+                                                    const char *ns);
+xmpp_stanza_t *xmpp_stanza_get_next(xmpp_stanza_t *stanza);
 int xmpp_stanza_add_child(xmpp_stanza_t *stanza, xmpp_stanza_t *child);
 int xmpp_stanza_add_child_ex(xmpp_stanza_t *stanza,
                              xmpp_stanza_t *child,
                              int do_clone);
 
-const char *xmpp_stanza_get_attribute(xmpp_stanza_t *const stanza,
-                                      const char *const name);
-int xmpp_stanza_get_attribute_count(xmpp_stanza_t *const stanza);
-int xmpp_stanza_get_attributes(xmpp_stanza_t *const stanza,
+const char *xmpp_stanza_get_attribute(xmpp_stanza_t *stanza, const char *name);
+int xmpp_stanza_get_attribute_count(xmpp_stanza_t *stanza);
+int xmpp_stanza_get_attributes(xmpp_stanza_t *stanza,
                                const char **attr,
                                int attrlen);
 /* concatenate all child text nodes.  this function
  * returns a string that must be freed by the caller */
-char *xmpp_stanza_get_text(xmpp_stanza_t *const stanza);
-const char *xmpp_stanza_get_text_ptr(xmpp_stanza_t *const stanza);
-const char *xmpp_stanza_get_name(xmpp_stanza_t *const stanza);
+char *xmpp_stanza_get_text(xmpp_stanza_t *stanza);
+const char *xmpp_stanza_get_text_ptr(xmpp_stanza_t *stanza);
+const char *xmpp_stanza_get_name(xmpp_stanza_t *stanza);
 /* set_attribute adds/replaces attributes */
-int xmpp_stanza_set_attribute(xmpp_stanza_t *const stanza,
-                              const char *const key,
-                              const char *const value);
-int xmpp_stanza_set_name(xmpp_stanza_t *stanza, const char *const name);
-int xmpp_stanza_set_text(xmpp_stanza_t *stanza, const char *const text);
+int xmpp_stanza_set_attribute(xmpp_stanza_t *stanza,
+                              const char *key,
+                              const char *value);
+int xmpp_stanza_set_name(xmpp_stanza_t *stanza, const char *name);
+int xmpp_stanza_set_text(xmpp_stanza_t *stanza, const char *text);
 int xmpp_stanza_set_text_with_size(xmpp_stanza_t *stanza,
-                                   const char *const text,
-                                   const size_t size);
-int xmpp_stanza_del_attribute(xmpp_stanza_t *const stanza,
-                              const char *const name);
+                                   const char *text,
+                                   size_t size);
+int xmpp_stanza_del_attribute(xmpp_stanza_t *stanza, const char *name);
 
 /* common stanza helpers */
-const char *xmpp_stanza_get_ns(xmpp_stanza_t *const stanza);
-const char *xmpp_stanza_get_type(xmpp_stanza_t *const stanza);
-const char *xmpp_stanza_get_id(xmpp_stanza_t *const stanza);
-const char *xmpp_stanza_get_to(xmpp_stanza_t *const stanza);
-const char *xmpp_stanza_get_from(xmpp_stanza_t *const stanza);
-int xmpp_stanza_set_ns(xmpp_stanza_t *const stanza, const char *const ns);
-int xmpp_stanza_set_id(xmpp_stanza_t *const stanza, const char *const id);
-int xmpp_stanza_set_type(xmpp_stanza_t *const stanza, const char *const type);
-int xmpp_stanza_set_to(xmpp_stanza_t *const stanza, const char *const to);
-int xmpp_stanza_set_from(xmpp_stanza_t *const stanza, const char *const from);
+const char *xmpp_stanza_get_ns(xmpp_stanza_t *stanza);
+const char *xmpp_stanza_get_type(xmpp_stanza_t *stanza);
+const char *xmpp_stanza_get_id(xmpp_stanza_t *stanza);
+const char *xmpp_stanza_get_to(xmpp_stanza_t *stanza);
+const char *xmpp_stanza_get_from(xmpp_stanza_t *stanza);
+int xmpp_stanza_set_ns(xmpp_stanza_t *stanza, const char *ns);
+int xmpp_stanza_set_id(xmpp_stanza_t *stanza, const char *id);
+int xmpp_stanza_set_type(xmpp_stanza_t *stanza, const char *type);
+int xmpp_stanza_set_to(xmpp_stanza_t *stanza, const char *to);
+int xmpp_stanza_set_from(xmpp_stanza_t *stanza, const char *from);
 
 /* allocate and initialize a stanza in reply to another */
-xmpp_stanza_t *xmpp_stanza_reply(xmpp_stanza_t *const stanza);
-xmpp_stanza_t *xmpp_stanza_reply_error(xmpp_stanza_t *const stanza,
-                                       const char *const error_type,
-                                       const char *const condition,
-                                       const char *const text);
+xmpp_stanza_t *xmpp_stanza_reply(xmpp_stanza_t *stanza);
+xmpp_stanza_t *xmpp_stanza_reply_error(xmpp_stanza_t *stanza,
+                                       const char *error_type,
+                                       const char *condition,
+                                       const char *text);
 
 /* stanza subclasses */
 xmpp_stanza_t *xmpp_message_new(xmpp_ctx_t *ctx,
-                                const char *const type,
-                                const char *const to,
-                                const char *const id);
+                                const char *type,
+                                const char *to,
+                                const char *id);
 char *xmpp_message_get_body(xmpp_stanza_t *msg);
-int xmpp_message_set_body(xmpp_stanza_t *msg, const char *const text);
+int xmpp_message_set_body(xmpp_stanza_t *msg, const char *text);
 
-xmpp_stanza_t *
-xmpp_iq_new(xmpp_ctx_t *ctx, const char *const type, const char *const id);
+xmpp_stanza_t *xmpp_iq_new(xmpp_ctx_t *ctx, const char *type, const char *id);
 xmpp_stanza_t *xmpp_presence_new(xmpp_ctx_t *ctx);
-xmpp_stanza_t *xmpp_error_new(xmpp_ctx_t *ctx,
-                              xmpp_error_type_t const type,
-                              const char *const text);
+xmpp_stanza_t *
+xmpp_error_new(xmpp_ctx_t *ctx, xmpp_error_type_t type, const char *text);
 
 /* jid */
 
@@ -440,10 +424,10 @@ char *xmpp_jid_resource(xmpp_ctx_t *ctx, const char *jid);
 
 /* event loop */
 
-void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout);
+void xmpp_run_once(xmpp_ctx_t *ctx, unsigned long timeout);
 void xmpp_run(xmpp_ctx_t *ctx);
 void xmpp_stop(xmpp_ctx_t *ctx);
-void xmpp_ctx_set_timeout(xmpp_ctx_t *const ctx, const unsigned long timeout);
+void xmpp_ctx_set_timeout(xmpp_ctx_t *ctx, unsigned long timeout);
 
 /* UUID */
 
diff --git a/tests/test.c b/tests/test.c
index 09d623c..6b51c99 100644
--- a/tests/test.c
+++ b/tests/test.c
@@ -16,9 +16,9 @@
 
 static uint8_t char_to_bin(char c)
 {
-    return c <= '9'
-               ? (uint8_t)(c - '0')
-               : c <= 'Z' ? (uint8_t)(c - 'A' + 10) : (uint8_t)(c - 'a' + 10);
+    return c <= '9'   ? (uint8_t)(c - '0')
+           : c <= 'Z' ? (uint8_t)(c - 'A' + 10)
+                      : (uint8_t)(c - 'a' + 10);
 }
 
 void test_hex_to_bin(const char *hex, uint8_t *bin, size_t *bin_len)
diff --git a/tests/test_ctx.c b/tests/test_ctx.c
index 5de7b03..a39024f 100644
--- a/tests/test_ctx.c
+++ b/tests/test_ctx.c
@@ -22,7 +22,7 @@ static int mem_alloc_called = 0;
 static int mem_free_called = 0;
 static int mem_realloc_called = 0;
 
-void *my_alloc(const size_t size, void *const userdata)
+void *my_alloc(size_t size, void *userdata)
 {
     (void)userdata;
 
@@ -30,7 +30,7 @@ void *my_alloc(const size_t size, void *const userdata)
     return malloc(size);
 }
 
-void my_free(void *p, void *const userdata)
+void my_free(void *p, void *userdata)
 {
     (void)userdata;
 
@@ -38,7 +38,7 @@ void my_free(void *p, void *const userdata)
     return free(p);
 }
 
-void *my_realloc(void *p, const size_t size, void *const userdata)
+void *my_realloc(void *p, size_t size, void *userdata)
 {
     (void)userdata;
 
@@ -46,10 +46,10 @@ void *my_realloc(void *p, const size_t size, void *const userdata)
     return realloc(p, size);
 }
 
-void my_logger(void *const userdata,
-               const xmpp_log_level_t level,
-               const char *const area,
-               const char *const msg)
+void my_logger(void *userdata,
+               xmpp_log_level_t level,
+               const char *area,
+               const char *msg)
 {
     if (strcmp((char *)userdata, "asdf") == 0 && level == XMPP_LEVEL_DEBUG &&
         strcmp(area, "test") == 0 && strcmp(msg, "hello") == 0)
diff --git a/tests/test_rand.c b/tests/test_rand.c
index 85deddd..6f04551 100644
--- a/tests/test_rand.c
+++ b/tests/test_rand.c
@@ -21,14 +21,14 @@
 #include "rand.c"
 
 /* stubs to build test without whole libstrophe */
-void *xmpp_alloc(const xmpp_ctx_t *const ctx, const size_t size)
+void *xmpp_alloc(const xmpp_ctx_t *ctx, size_t size)
 {
     (void)ctx;
     (void)size;
     return NULL;
 }
 
-void xmpp_free(const xmpp_ctx_t *const ctx, void *p)
+void xmpp_free(const xmpp_ctx_t *ctx, void *p)
 {
     (void)ctx;
     (void)p;