diff --git a/src/channel.c b/src/channel.c
index 61be7b7c..f01b1dcd 100644
--- a/src/channel.c
+++ b/src/channel.c
@@ -183,7 +183,7 @@ libssh2_channel_open_ex(LIBSSH2_SESSION *session, const char *channel_type,
 			unsigned int packet_size, const char *message,
 			unsigned int message_len)
 {
-	unsigned char reply_codes[3] = {
+	static const unsigned char reply_codes[3] = {
 		SSH_MSG_CHANNEL_OPEN_CONFIRMATION,
 		SSH_MSG_CHANNEL_OPEN_FAILURE,
 		0
@@ -373,7 +373,8 @@ LIBSSH2_API LIBSSH2_CHANNEL *libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION *se
  */
 LIBSSH2_API LIBSSH2_LISTENER *libssh2_channel_forward_listen_ex(LIBSSH2_SESSION *session, char *host, int port, int *bound_port, int queue_maxsize)
 {
-	unsigned char *packet, *s, *data, reply_codes[3] = { SSH_MSG_REQUEST_SUCCESS, SSH_MSG_REQUEST_FAILURE, 0 };
+	unsigned char *packet, *s, *data;
+	static const unsigned char reply_codes[3] = { SSH_MSG_REQUEST_SUCCESS, SSH_MSG_REQUEST_FAILURE, 0 };
 	unsigned long data_len;
 	unsigned long host_len = (host ? strlen(host) : (sizeof("0.0.0.0") - 1));
 	unsigned long packet_len = host_len + (sizeof("tcpip-forward") - 1) + 14;
@@ -575,7 +576,8 @@ libssh2_channel_forward_accept(LIBSSH2_LISTENER *listener)
 LIBSSH2_API int libssh2_channel_setenv_ex(LIBSSH2_CHANNEL *channel, char *varname, unsigned int varname_len, char *value, unsigned int value_len)
 {
 	LIBSSH2_SESSION *session = channel->session;
-	unsigned char *s, *packet, *data, reply_codes[3] = { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 }, local_channel[4];
+	unsigned char *s, *packet, *data, local_channel[4];
+	static const unsigned char reply_codes[3] = { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 };
 	unsigned long data_len;
 	unsigned long packet_len = varname_len + value_len + 21; /* packet_type(1) + channel_id(4) + request_len(4) + request(3)"env" +
 																want_reply(1) + varname_len(4) + value_len(4) */
@@ -634,7 +636,8 @@ LIBSSH2_API int libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL *channel, char *t
 																		 int width_px, int height_px)
 {
 	LIBSSH2_SESSION *session = channel->session;
-	unsigned char *s, *packet, *data, reply_codes[3] = { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 }, local_channel[4];
+	unsigned char *s, *packet, *data, local_channel[4];
+	static const unsigned char reply_codes[3] = { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 };
 	unsigned long data_len;
 	unsigned long packet_len = term_len + modes_len + 41; /*  packet_type(1) + channel(4) + pty_req_len(4) + "pty_req"(7) + want_reply(1) +
 															  term_len(4) + width(4) + height(4) + width_px(4) + height_px(4) + modes_len(4) */
@@ -700,7 +703,8 @@ LIBSSH2_API int libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL *channel, char *t
 LIBSSH2_API int libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL *channel, int single_connection, char *auth_proto, char *auth_cookie, int screen_number)
 {
 	LIBSSH2_SESSION *session = channel->session;
-	unsigned char *s, *packet, *data, reply_codes[3] = { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 }, local_channel[4];
+	unsigned char *s, *packet, *data, local_channel[4];
+	static const unsigned char reply_codes[3] = { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 };
 	unsigned long data_len;
 	unsigned long proto_len = auth_proto ? strlen(auth_proto) : (sizeof("MIT-MAGIC-COOKIE-1") - 1);
 	unsigned long cookie_len = auth_cookie ? strlen(auth_cookie) : LIBSSH2_X11_RANDOM_COOKIE_LEN;
@@ -776,7 +780,8 @@ LIBSSH2_API int libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL *channel, int single_
 LIBSSH2_API int libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel, const char *request, unsigned int request_len, const char *message, unsigned int message_len)
 {
 	LIBSSH2_SESSION *session = channel->session;
-	unsigned char *s, *packet, *data, reply_codes[3] = { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 }, local_channel[4];
+	unsigned char *s, *packet, *data, local_channel[4];
+	static const unsigned char reply_codes[3] = { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 };
 	unsigned long data_len;
 	unsigned long packet_len = request_len + 10; /* packet_type(1) + channel(4) + request_len(4) + want_reply(1) */
 	libssh2pack_t rc;
diff --git a/src/comp.c b/src/comp.c
index 721227ac..3b98c5bc 100644
--- a/src/comp.c
+++ b/src/comp.c
@@ -70,8 +70,8 @@ static int libssh2_comp_method_none_comp(LIBSSH2_SESSION *session,
 }
 /* }}} */
 
-static LIBSSH2_COMP_METHOD libssh2_comp_method_none = {
-	(char *)"none",
+static const LIBSSH2_COMP_METHOD libssh2_comp_method_none = {
+	"none",
 	NULL,
 	libssh2_comp_method_none_comp,
 	NULL
@@ -288,8 +288,8 @@ static int libssh2_comp_method_zlib_dtor(LIBSSH2_SESSION *session, int compress,
 }
 /* }}} */
 
-static LIBSSH2_COMP_METHOD libssh2_comp_method_zlib = {
-	(char *)"zlib",
+static const LIBSSH2_COMP_METHOD libssh2_comp_method_zlib = {
+	"zlib",
 	libssh2_comp_method_zlib_init,
 	libssh2_comp_method_zlib_comp,
 	libssh2_comp_method_zlib_dtor,
@@ -300,7 +300,7 @@ static LIBSSH2_COMP_METHOD libssh2_comp_method_zlib = {
    * Compression Methods *
    *********************** */
 
-static LIBSSH2_COMP_METHOD *_libssh2_comp_methods[] = {
+static const LIBSSH2_COMP_METHOD *_libssh2_comp_methods[] = {
 	&libssh2_comp_method_none,
 #ifdef LIBSSH2_HAVE_ZLIB
 	&libssh2_comp_method_zlib,
@@ -308,7 +308,7 @@ static LIBSSH2_COMP_METHOD *_libssh2_comp_methods[] = {
 	NULL
 };
 
-LIBSSH2_COMP_METHOD **libssh2_comp_methods(void) {
+const LIBSSH2_COMP_METHOD **libssh2_comp_methods(void) {
 	return _libssh2_comp_methods;
 }
 
diff --git a/src/crypt.c b/src/crypt.c
index 1eec902c..c8f1dbff 100644
--- a/src/crypt.c
+++ b/src/crypt.c
@@ -48,7 +48,7 @@ static int libssh2_crypt_none_crypt(LIBSSH2_SESSION *session, unsigned char *buf
 }
 /* }}} */
 
-static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_none = {
+static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_none = {
 	"none",
 	8, /* blocksize (SSH2 defines minimum blocksize as 8) */
 	0, /* iv_len */
@@ -67,7 +67,7 @@ struct crypt_ctx {
 };
 
 static int _libssh2_init (LIBSSH2_SESSION *session,
-		 LIBSSH2_CRYPT_METHOD *method,
+		 const LIBSSH2_CRYPT_METHOD *method,
 		 unsigned char *iv, int *free_iv,
 		 unsigned char *secret, int *free_secret,
 		 int encrypt, void **abstract)
@@ -110,7 +110,7 @@ static int _libssh2_dtor(LIBSSH2_SESSION *session, void **abstract)
 }
 
 #if LIBSSH2_AES
-static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes128_cbc = {
+static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes128_cbc = {
 	"aes128-cbc",
 	16, /* blocksize */
 	16, /* initial value length */
@@ -122,7 +122,7 @@ static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes128_cbc = {
 	_libssh2_cipher_aes128
 };
 
-static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes192_cbc = {
+static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes192_cbc = {
 	"aes192-cbc",
 	16, /* blocksize */
 	16, /* initial value length */
@@ -134,7 +134,7 @@ static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes192_cbc = {
 	_libssh2_cipher_aes192
 };
 
-static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes256_cbc = {
+static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes256_cbc = {
 	"aes256-cbc",
 	16, /* blocksize */
 	16, /* initial value length */
@@ -147,7 +147,7 @@ static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes256_cbc = {
 };
 
 /* rijndael-cbc@lysator.liu.se == aes256-cbc */
-static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_rijndael_cbc_lysator_liu_se = {
+static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_rijndael_cbc_lysator_liu_se = {
 	"rijndael-cbc@lysator.liu.se",
 	16, /* blocksize */
 	16, /* initial value length */
@@ -161,7 +161,7 @@ static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_rijndael_cbc_lysator_liu_se = {
 #endif /* LIBSSH2_AES */
 
 #if LIBSSH2_BLOWFISH
-static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_blowfish_cbc = {
+static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_blowfish_cbc = {
 	"blowfish-cbc",
 	8, /* blocksize */
 	8, /* initial value length */
@@ -175,7 +175,7 @@ static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_blowfish_cbc = {
 #endif /* LIBSSH2_BLOWFISH */
 
 #if LIBSSH2_RC4
-static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_arcfour = {
+static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_arcfour = {
 	"arcfour",
 	8, /* blocksize */
 	8, /* initial value length */
@@ -189,7 +189,7 @@ static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_arcfour = {
 #endif /* LIBSSH2_RC4 */
 
 #if LIBSSH2_CAST
-static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_cast128_cbc = {
+static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_cast128_cbc = {
 	"cast128-cbc",
 	8, /* blocksize */
 	8, /* initial value length */
@@ -203,7 +203,7 @@ static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_cast128_cbc = {
 #endif /* LIBSSH2_CAST */
 
 #if LIBSSH2_3DES
-static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_3des_cbc = {
+static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_3des_cbc = {
 	"3des-cbc",
 	8, /* blocksize */
 	8, /* initial value length */
@@ -216,7 +216,7 @@ static LIBSSH2_CRYPT_METHOD libssh2_crypt_method_3des_cbc = {
 };
 #endif
 
-static LIBSSH2_CRYPT_METHOD *_libssh2_crypt_methods[] = {
+static const LIBSSH2_CRYPT_METHOD *_libssh2_crypt_methods[] = {
 #if LIBSSH2_AES
 	&libssh2_crypt_method_aes256_cbc,
 	&libssh2_crypt_method_rijndael_cbc_lysator_liu_se, /* == aes256-cbc */
@@ -242,6 +242,6 @@ static LIBSSH2_CRYPT_METHOD *_libssh2_crypt_methods[] = {
 };
 
 /* Expose to kex.c */
-LIBSSH2_CRYPT_METHOD **libssh2_crypt_methods(void) {
+const LIBSSH2_CRYPT_METHOD **libssh2_crypt_methods(void) {
 	return _libssh2_crypt_methods;
 }
diff --git a/src/hostkey.c b/src/hostkey.c
index 64d79d85..3c4cb4b4 100644
--- a/src/hostkey.c
+++ b/src/hostkey.c
@@ -191,7 +191,7 @@ static int libssh2_hostkey_method_ssh_rsa_dtor(LIBSSH2_SESSION *session,
 }
 /* }}} */
 
-static LIBSSH2_HOSTKEY_METHOD libssh2_hostkey_method_ssh_rsa = {
+static const LIBSSH2_HOSTKEY_METHOD libssh2_hostkey_method_ssh_rsa = {
 	"ssh-rsa",
 	MD5_DIGEST_LENGTH,
 	libssh2_hostkey_method_ssh_rsa_init,
@@ -358,7 +358,7 @@ static int libssh2_hostkey_method_ssh_dss_dtor(LIBSSH2_SESSION *session,
 }
 /* }}} */
 
-static LIBSSH2_HOSTKEY_METHOD libssh2_hostkey_method_ssh_dss = {
+static const LIBSSH2_HOSTKEY_METHOD libssh2_hostkey_method_ssh_dss = {
 	"ssh-dss",
 	MD5_DIGEST_LENGTH,
 	libssh2_hostkey_method_ssh_dss_init,
@@ -370,7 +370,7 @@ static LIBSSH2_HOSTKEY_METHOD libssh2_hostkey_method_ssh_dss = {
 };
 #endif /* LIBSSH2_DSA */
 
-static LIBSSH2_HOSTKEY_METHOD *_libssh2_hostkey_methods[] = {
+static const LIBSSH2_HOSTKEY_METHOD *_libssh2_hostkey_methods[] = {
 #if LIBSSH2_RSA
 	&libssh2_hostkey_method_ssh_rsa,
 #endif /* LIBSSH2_RSA */
@@ -380,7 +380,7 @@ static LIBSSH2_HOSTKEY_METHOD *_libssh2_hostkey_methods[] = {
 	NULL
 };
 
-LIBSSH2_HOSTKEY_METHOD **libssh2_hostkey_methods(void)
+const LIBSSH2_HOSTKEY_METHOD **libssh2_hostkey_methods(void)
 {
 	return _libssh2_hostkey_methods;
 }
diff --git a/src/kex.c b/src/kex.c
index 28aeb2d4..b828a6dc 100644
--- a/src/kex.c
+++ b/src/kex.c
@@ -481,7 +481,7 @@ static int libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_S
  */
 static int libssh2_kex_method_diffie_hellman_group1_sha1_key_exchange(LIBSSH2_SESSION *session)
 {
-	unsigned char p_value[128] = {
+	static const unsigned char p_value[128] = {
 		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 		0xC9, 0x0F, 0xDA, 0xA2, 0x21, 0x68, 0xC2, 0x34,
 		0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
@@ -523,7 +523,7 @@ static int libssh2_kex_method_diffie_hellman_group1_sha1_key_exchange(LIBSSH2_SE
  */
 static int libssh2_kex_method_diffie_hellman_group14_sha1_key_exchange(LIBSSH2_SESSION *session)
 {
-	unsigned char p_value[256] = {
+	static const unsigned char p_value[256] = {
 		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 		0xC9, 0x0F, 0xDA, 0xA2, 0x21, 0x68, 0xC2, 0x34,
 		0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
@@ -636,25 +636,25 @@ static int libssh2_kex_method_diffie_hellman_group_exchange_sha1_key_exchange(LI
 #define LIBSSH2_KEX_METHOD_FLAG_REQ_ENC_HOSTKEY		0x0001
 #define LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY	0x0002
 
-LIBSSH2_KEX_METHOD libssh2_kex_method_diffie_helman_group1_sha1 = {
+const LIBSSH2_KEX_METHOD libssh2_kex_method_diffie_helman_group1_sha1 = {
 	"diffie-hellman-group1-sha1",
 	libssh2_kex_method_diffie_hellman_group1_sha1_key_exchange,
 	LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
 };
 
-LIBSSH2_KEX_METHOD libssh2_kex_method_diffie_helman_group14_sha1 = {
+const LIBSSH2_KEX_METHOD libssh2_kex_method_diffie_helman_group14_sha1 = {
 	"diffie-hellman-group14-sha1",
 	libssh2_kex_method_diffie_hellman_group14_sha1_key_exchange,
 	LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
 };
 
-LIBSSH2_KEX_METHOD libssh2_kex_method_diffie_helman_group_exchange_sha1 = {
+const LIBSSH2_KEX_METHOD libssh2_kex_method_diffie_helman_group_exchange_sha1 = {
 	"diffie-hellman-group-exchange-sha1",
 	libssh2_kex_method_diffie_hellman_group_exchange_sha1_key_exchange,
 	LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
 };
 
-LIBSSH2_KEX_METHOD *libssh2_kex_methods[] = {
+const LIBSSH2_KEX_METHOD *libssh2_kex_methods[] = {
 	&libssh2_kex_method_diffie_helman_group14_sha1,
 	&libssh2_kex_method_diffie_helman_group_exchange_sha1,
 	&libssh2_kex_method_diffie_helman_group1_sha1,
@@ -662,7 +662,7 @@ LIBSSH2_KEX_METHOD *libssh2_kex_methods[] = {
 };
 
 typedef struct _LIBSSH2_COMMON_METHOD {
-	char *name;
+	const char *name;
 } LIBSSH2_COMMON_METHOD;
 
 /* {{{ libssh2_kex_method_strlen
@@ -791,7 +791,7 @@ static int libssh2_kexinit(LIBSSH2_SESSION *session)
 #ifdef LIBSSH2DEBUG
 {
 	/* Funnily enough, they'll all "appear" to be '\0' terminated */
-	char *p = data + 21; /* type(1) + cookie(16) + len(4) */
+	unsigned char *p = data + 21; /* type(1) + cookie(16) + len(4) */
 
 	_libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent KEX: %s", p);				p += kex_len + 4;
 	_libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent HOSTKEY: %s", p);			p += hostkey_len + 4;
@@ -827,7 +827,7 @@ static int libssh2_kexinit(LIBSSH2_SESSION *session)
  * Needle must be preceed by BOL or ',', and followed by ',' or EOL
  */
 static unsigned char *libssh2_kex_agree_instr(unsigned char *haystack, unsigned long haystack_len,
-											  unsigned char *needle, unsigned long needle_len)
+											  const unsigned char *needle, unsigned long needle_len)
 {
 	unsigned char *s;
 
@@ -860,7 +860,7 @@ static unsigned char *libssh2_kex_agree_instr(unsigned char *haystack, unsigned
 
 /* {{{ libssh2_get_method_by_name
  */
-static LIBSSH2_COMMON_METHOD *libssh2_get_method_by_name(char *name, int name_len, LIBSSH2_COMMON_METHOD **methodlist)
+static const LIBSSH2_COMMON_METHOD *libssh2_get_method_by_name(const char *name, int name_len, const LIBSSH2_COMMON_METHOD **methodlist)
 {
 	while (*methodlist) {
 		if ((strlen((*methodlist)->name) == name_len) &&
@@ -878,7 +878,7 @@ static LIBSSH2_COMMON_METHOD *libssh2_get_method_by_name(char *name, int name_le
  */
 static int libssh2_kex_agree_hostkey(LIBSSH2_SESSION *session, unsigned long kex_flags, unsigned char *hostkey, unsigned long hostkey_len)
 {
-	LIBSSH2_HOSTKEY_METHOD	**hostkeyp	= libssh2_hostkey_methods();
+	const LIBSSH2_HOSTKEY_METHOD	**hostkeyp	= libssh2_hostkey_methods();
 	unsigned char *s;
 
 	if (session->hostkey_prefs) {
@@ -888,7 +888,7 @@ static int libssh2_kex_agree_hostkey(LIBSSH2_SESSION *session, unsigned long kex
 			unsigned char *p = strchr(s, ',');
 			int method_len = (p ? (p - s) : strlen(s));
 			if (libssh2_kex_agree_instr(hostkey, hostkey_len, s, method_len)) {
-				LIBSSH2_HOSTKEY_METHOD *method = (LIBSSH2_HOSTKEY_METHOD*)libssh2_get_method_by_name(s, method_len, (LIBSSH2_COMMON_METHOD**)hostkeyp);
+				const LIBSSH2_HOSTKEY_METHOD *method = (const LIBSSH2_HOSTKEY_METHOD*)libssh2_get_method_by_name(s, method_len, (const LIBSSH2_COMMON_METHOD**)hostkeyp);
 
 				if (!method) {
 					/* Invalid method -- Should never be reached */
@@ -943,7 +943,7 @@ static int libssh2_kex_agree_hostkey(LIBSSH2_SESSION *session, unsigned long kex
 static int libssh2_kex_agree_kex_hostkey(LIBSSH2_SESSION *session, unsigned char *kex, unsigned long kex_len,
 																   unsigned char *hostkey, unsigned long hostkey_len)
 {
-	LIBSSH2_KEX_METHOD **kexp = libssh2_kex_methods;
+	const LIBSSH2_KEX_METHOD **kexp = libssh2_kex_methods;
 	unsigned char *s;
 
 	if (session->kex_prefs) {
@@ -953,7 +953,7 @@ static int libssh2_kex_agree_kex_hostkey(LIBSSH2_SESSION *session, unsigned char
 			unsigned char *q, *p = strchr(s, ',');
 			int method_len = (p ? (p - s) : strlen(s));
 			if ((q = libssh2_kex_agree_instr(kex, kex_len, s, method_len))) {
-				LIBSSH2_KEX_METHOD *method = (LIBSSH2_KEX_METHOD*)libssh2_get_method_by_name(s, method_len, (LIBSSH2_COMMON_METHOD**)kexp);
+				const LIBSSH2_KEX_METHOD *method = (const LIBSSH2_KEX_METHOD*)libssh2_get_method_by_name(s, method_len, (const LIBSSH2_COMMON_METHOD**)kexp);
 
 				if (!method) {
 					/* Invalid method -- Should never be reached */
@@ -1013,8 +1013,9 @@ static int libssh2_kex_agree_crypt(LIBSSH2_SESSION *session,
 				   unsigned char *crypt,
 				   unsigned long crypt_len)
 {
-	LIBSSH2_CRYPT_METHOD **cryptp = libssh2_crypt_methods();
+	const LIBSSH2_CRYPT_METHOD **cryptp = libssh2_crypt_methods();
 	unsigned char *s;
+	(void)session;
 
 	if (endpoint->crypt_prefs) {
 		s = endpoint->crypt_prefs;
@@ -1024,8 +1025,8 @@ static int libssh2_kex_agree_crypt(LIBSSH2_SESSION *session,
 			int method_len = (p ? (p - s) : strlen(s));
 
 			if (libssh2_kex_agree_instr(crypt, crypt_len, s, method_len)) {
-				LIBSSH2_CRYPT_METHOD *method =
-					(LIBSSH2_CRYPT_METHOD*)libssh2_get_method_by_name((char *)s, method_len, (LIBSSH2_COMMON_METHOD**)cryptp);
+				const LIBSSH2_CRYPT_METHOD *method =
+					(const LIBSSH2_CRYPT_METHOD*)libssh2_get_method_by_name((char *)s, method_len, (const LIBSSH2_COMMON_METHOD**)cryptp);
 
 				if (!method) {
 					/* Invalid method -- Should never be reached */
@@ -1061,8 +1062,9 @@ static int libssh2_kex_agree_crypt(LIBSSH2_SESSION *session,
  */
 static int libssh2_kex_agree_mac(LIBSSH2_SESSION *session, libssh2_endpoint_data *endpoint, unsigned char *mac, unsigned long mac_len)
 {
-	LIBSSH2_MAC_METHOD **macp = libssh2_mac_methods();
+	const LIBSSH2_MAC_METHOD **macp = libssh2_mac_methods();
 	unsigned char *s;
+	(void)session;
 
 	if (endpoint->mac_prefs) {
 		s = endpoint->mac_prefs;
@@ -1072,7 +1074,7 @@ static int libssh2_kex_agree_mac(LIBSSH2_SESSION *session, libssh2_endpoint_data
 			int method_len = (p ? (p - s) : strlen(s));
 
 			if (libssh2_kex_agree_instr(mac, mac_len, s, method_len)) {
-				LIBSSH2_MAC_METHOD *method = (LIBSSH2_MAC_METHOD*)libssh2_get_method_by_name(s, method_len, (LIBSSH2_COMMON_METHOD**)macp);
+				const LIBSSH2_MAC_METHOD *method = (const LIBSSH2_MAC_METHOD*)libssh2_get_method_by_name(s, method_len, (const LIBSSH2_COMMON_METHOD**)macp);
 
 				if (!method) {
 					/* Invalid method -- Should never be reached */
@@ -1110,6 +1112,7 @@ static int libssh2_kex_agree_comp(LIBSSH2_SESSION *session, libssh2_endpoint_dat
 {
 	LIBSSH2_COMP_METHOD **compp = libssh2_comp_methods();
 	unsigned char *s;
+	(void)session;
 
 	if (endpoint->comp_prefs) {
 		s = endpoint->comp_prefs;
@@ -1119,7 +1122,7 @@ static int libssh2_kex_agree_comp(LIBSSH2_SESSION *session, libssh2_endpoint_dat
 			int method_len = (p ? (p - s) : strlen(s));
 
 			if (libssh2_kex_agree_instr(comp, comp_len, s, method_len)) {
-				LIBSSH2_COMP_METHOD *method = (LIBSSH2_COMP_METHOD*)libssh2_get_method_by_name(s, method_len, (LIBSSH2_COMMON_METHOD**)compp);
+				const LIBSSH2_COMP_METHOD *method = (const LIBSSH2_COMP_METHOD*)libssh2_get_method_by_name(s, method_len, (const LIBSSH2_COMMON_METHOD**)compp);
 
 				if (!method) {
 					/* Invalid method -- Should never be reached */
@@ -1321,40 +1324,40 @@ LIBSSH2_API int libssh2_session_method_pref(LIBSSH2_SESSION *session, int method
 {
 	char **prefvar, *s, *newprefs;
 	int prefs_len = strlen(prefs);
-	LIBSSH2_COMMON_METHOD **mlist;
+	const LIBSSH2_COMMON_METHOD **mlist;
 
 	switch (method_type) {
 		case LIBSSH2_METHOD_KEX:
 			prefvar = &session->kex_prefs;
-			mlist = (LIBSSH2_COMMON_METHOD**)libssh2_kex_methods;
+			mlist = (const LIBSSH2_COMMON_METHOD**)libssh2_kex_methods;
 			break;
 		case LIBSSH2_METHOD_HOSTKEY:
 			prefvar = &session->hostkey_prefs;
-			mlist = (LIBSSH2_COMMON_METHOD**)libssh2_hostkey_methods();
+			mlist = (const LIBSSH2_COMMON_METHOD**)libssh2_hostkey_methods();
 			break;
 		case LIBSSH2_METHOD_CRYPT_CS:
 			prefvar = &session->local.crypt_prefs;
-			mlist = (LIBSSH2_COMMON_METHOD**)libssh2_crypt_methods();
+			mlist = (const LIBSSH2_COMMON_METHOD**)libssh2_crypt_methods();
 			break;
 		case LIBSSH2_METHOD_CRYPT_SC:
 			prefvar = &session->remote.crypt_prefs;
-			mlist = (LIBSSH2_COMMON_METHOD**)libssh2_crypt_methods();
+			mlist = (const LIBSSH2_COMMON_METHOD**)libssh2_crypt_methods();
 			break;
 		case LIBSSH2_METHOD_MAC_CS:
 			prefvar = &session->local.mac_prefs;
-			mlist = (LIBSSH2_COMMON_METHOD**)libssh2_mac_methods();
+			mlist = (const LIBSSH2_COMMON_METHOD**)libssh2_mac_methods();
 			break;
 		case LIBSSH2_METHOD_MAC_SC:
 			prefvar = &session->remote.mac_prefs;
-			mlist = (LIBSSH2_COMMON_METHOD**)libssh2_mac_methods();
+			mlist = (const LIBSSH2_COMMON_METHOD**)libssh2_mac_methods();
 			break;
 		case LIBSSH2_METHOD_COMP_CS:
 			prefvar = &session->local.comp_prefs;
-			mlist = (LIBSSH2_COMMON_METHOD**)libssh2_comp_methods();
+			mlist = (const LIBSSH2_COMMON_METHOD**)libssh2_comp_methods();
 			break;
 		case LIBSSH2_METHOD_COMP_SC:
 			prefvar = &session->remote.comp_prefs;
-			mlist = (LIBSSH2_COMMON_METHOD**)libssh2_comp_methods();
+			mlist = (const LIBSSH2_COMMON_METHOD**)libssh2_comp_methods();
 			break;
 		case LIBSSH2_METHOD_LANG_CS:
 			prefvar = &session->local.lang_prefs;
@@ -1378,7 +1381,7 @@ LIBSSH2_API int libssh2_session_method_pref(LIBSSH2_SESSION *session, int method
 
 	while (s && *s) {
 		char *p = strchr(s, ',');
-		int method_len = p ? (p - s) : strlen(s);
+		int method_len = p ? (p - s) : (int) strlen(s);
 
 		if (!libssh2_get_method_by_name(s, method_len, mlist)) {
 			/* Strip out unsupported method */
diff --git a/src/libssh2_priv.h b/src/libssh2_priv.h
index d8c0a1b3..270bae09 100644
--- a/src/libssh2_priv.h
+++ b/src/libssh2_priv.h
@@ -192,14 +192,14 @@ typedef struct _libssh2_endpoint_data {
 	unsigned char *kexinit;
 	unsigned long kexinit_len;
 
-	LIBSSH2_CRYPT_METHOD *crypt;
+	const LIBSSH2_CRYPT_METHOD *crypt;
 	void *crypt_abstract;
 
-	LIBSSH2_MAC_METHOD *mac;
+	const LIBSSH2_MAC_METHOD *mac;
 	unsigned long seqno;
 	void *mac_abstract;
 
-	LIBSSH2_COMP_METHOD *comp;
+	const LIBSSH2_COMP_METHOD *comp;
 	void *comp_abstract;
 
 	/* Method Preferences -- NULL yields "load order" */
@@ -268,14 +268,14 @@ struct _LIBSSH2_SESSION {
 	int flags;
 
 	/* Agreed Key Exchange Method */
-	LIBSSH2_KEX_METHOD *kex;
+	const LIBSSH2_KEX_METHOD *kex;
 	int burn_optimistic_kexinit:1;
 
 	unsigned char *session_id;
 	unsigned long session_id_len;
 
 	/* Server's public key */
-	LIBSSH2_HOSTKEY_METHOD *hostkey;
+	const LIBSSH2_HOSTKEY_METHOD *hostkey;
 	void *server_hostkey_abstract;
 
 	/* Either set with libssh2_session_hostkey() (for server mode)
@@ -370,7 +370,7 @@ struct _LIBSSH2_CRYPT_METHOD {
 
 	long flags;
 
-	int (*init)(LIBSSH2_SESSION *session, LIBSSH2_CRYPT_METHOD *method, unsigned char *iv, int *free_iv, unsigned char *secret, int *free_secret, int encrypt, void **abstract);
+	int (*init)(LIBSSH2_SESSION *session, const LIBSSH2_CRYPT_METHOD *method, unsigned char *iv, int *free_iv, unsigned char *secret, int *free_secret, int encrypt, void **abstract);
 	int (*crypt)(LIBSSH2_SESSION *session, unsigned char *block, void **abstract);
 	int (*dtor)(LIBSSH2_SESSION *session, void **abstract);
 
@@ -550,13 +550,13 @@ libssh2pack_t libssh2_packet_read(LIBSSH2_SESSION *session);
 int libssh2_packet_ask_ex(LIBSSH2_SESSION *session, unsigned char packet_type, unsigned char **data, unsigned long *data_len, unsigned long match_ofs, const unsigned char *match_buf, unsigned long match_len, int poll_socket);
 #define libssh2_packet_ask(session, packet_type, data, data_len, poll_socket)	\
 		libssh2_packet_ask_ex((session), (packet_type), (data), (data_len), 0, NULL, 0, (poll_socket))
-int libssh2_packet_askv_ex(LIBSSH2_SESSION *session, unsigned char *packet_types, unsigned char **data, unsigned long *data_len, unsigned long match_ofs, const unsigned char *match_buf, unsigned long match_len, int poll_socket);
+int libssh2_packet_askv_ex(LIBSSH2_SESSION *session, const unsigned char *packet_types, unsigned char **data, unsigned long *data_len, unsigned long match_ofs, const unsigned char *match_buf, unsigned long match_len, int poll_socket);
 #define libssh2_packet_askv(session, packet_types, data, data_len, poll_socket)	\
 		libssh2_packet_askv_ex((session), (packet_types), (data), (data_len), 0, NULL, 0, (poll_socket))
 int libssh2_packet_require_ex(LIBSSH2_SESSION *session, unsigned char packet_type, unsigned char **data, unsigned long *data_len, unsigned long match_ofs, const unsigned char *match_buf, unsigned long match_len);
 #define libssh2_packet_require(session, packet_type, data, data_len) \
  libssh2_packet_require_ex((session), (packet_type), (data), (data_len), 0, NULL, 0)
-int libssh2_packet_requirev_ex(LIBSSH2_SESSION *session, unsigned char *packet_types, unsigned char **data, unsigned long *data_len, unsigned long match_ofs, const unsigned char *match_buf, unsigned long match_len);
+int libssh2_packet_requirev_ex(LIBSSH2_SESSION *session, const unsigned char *packet_types, unsigned char **data, unsigned long *data_len, unsigned long match_ofs, const unsigned char *match_buf, unsigned long match_len);
 #define libssh2_packet_requirev(session, packet_types, data, data_len)			\
 		libssh2_packet_requirev_ex((session), (packet_types), (data), (data_len), 0, NULL, 0)
 int libssh2_packet_burn(LIBSSH2_SESSION *session);
@@ -582,10 +582,10 @@ int _libssh2_channel_write_ex(LIBSSH2_CHANNEL *channel,
 int _libssh2_channel_set_blocking(LIBSSH2_CHANNEL *channel, int blocking);
 
 /* Let crypt.c/hostkey.c/comp.c/mac.c expose their method structs */
-LIBSSH2_CRYPT_METHOD **libssh2_crypt_methods(void);
-LIBSSH2_HOSTKEY_METHOD **libssh2_hostkey_methods(void);
-LIBSSH2_COMP_METHOD **libssh2_comp_methods(void);
-LIBSSH2_MAC_METHOD **libssh2_mac_methods(void);
+const LIBSSH2_CRYPT_METHOD **libssh2_crypt_methods(void);
+const LIBSSH2_HOSTKEY_METHOD **libssh2_hostkey_methods(void);
+const LIBSSH2_COMP_METHOD **libssh2_comp_methods(void);
+const LIBSSH2_MAC_METHOD **libssh2_mac_methods(void);
 
 /* Language API doesn't exist yet.  Just act like we've agreed on a language */
 #define libssh2_kex_agree_lang(session, endpoint, str, str_len)	0
diff --git a/src/mac.c b/src/mac.c
index 56bc0664..531d94bb 100644
--- a/src/mac.c
+++ b/src/mac.c
@@ -113,7 +113,7 @@ static int libssh2_mac_method_hmac_sha1_hash(LIBSSH2_SESSION *session, unsigned
 }
 /* }}} */
 
-static LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_sha1 = {
+static const LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_sha1 = {
 	"hmac-sha1",
 	20,
 	20,
@@ -138,7 +138,7 @@ static int libssh2_mac_method_hmac_sha1_96_hash(LIBSSH2_SESSION *session, unsign
 }
 /* }}} */
 
-static LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_sha1_96 = {
+static const LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_sha1_96 = {
 	"hmac-sha1-96",
 	12,
 	20,
@@ -173,7 +173,7 @@ static int libssh2_mac_method_hmac_md5_hash(LIBSSH2_SESSION *session, unsigned c
 }
 /* }}} */
 
-static LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_md5 = {
+static const LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_md5 = {
 	"hmac-md5",
 	16,
 	16,
@@ -198,7 +198,7 @@ static int libssh2_mac_method_hmac_md5_96_hash(LIBSSH2_SESSION *session, unsigne
 }
 /* }}} */
 
-static LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_md5_96 = {
+static const LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_md5_96 = {
 	"hmac-md5-96",
 	12,
 	16,
@@ -234,7 +234,7 @@ static int libssh2_mac_method_hmac_ripemd160_hash(LIBSSH2_SESSION *session, unsi
 }
 /* }}} */
 
-static LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_ripemd160 = {
+static const LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_ripemd160 = {
 	"hmac-ripemd160",
 	20,
 	20,
@@ -243,7 +243,7 @@ static LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_ripemd160 = {
 	libssh2_mac_method_common_dtor,
 };
 
-static LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_ripemd160_openssh_com = {
+static const LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_ripemd160_openssh_com = {
 	"hmac-ripemd160@openssh.com",
 	20,
 	20,
@@ -253,7 +253,7 @@ static LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_ripemd160_openssh_com = {
 };
 #endif /* LIBSSH2_HMAC_RIPEMD */
 
-static LIBSSH2_MAC_METHOD *_libssh2_mac_methods[] = {
+static const LIBSSH2_MAC_METHOD *_libssh2_mac_methods[] = {
 	&libssh2_mac_method_hmac_sha1,
 	&libssh2_mac_method_hmac_sha1_96,
 	&libssh2_mac_method_hmac_md5,
@@ -268,7 +268,7 @@ static LIBSSH2_MAC_METHOD *_libssh2_mac_methods[] = {
 	NULL
 };
 
-LIBSSH2_MAC_METHOD **libssh2_mac_methods(void) {
+const LIBSSH2_MAC_METHOD **libssh2_mac_methods(void) {
 	return _libssh2_mac_methods;
 }
 
diff --git a/src/misc.c b/src/misc.c
index 43a98dc8..cbb29df3 100644
--- a/src/misc.c
+++ b/src/misc.c
@@ -186,10 +186,10 @@ void _libssh2_debug(LIBSSH2_SESSION *session, int context,
 	char buffer[1536];
 	int len;
 	va_list vargs;
-	static const char *contexts[9] = {
+	static const char * const contexts[9] = {
 		"Unknown",
 		"Transport",
-		"Key Exhange",
+		"Key Exchange",
 		"Userauth",
 		"Connection",
 		"scp",
diff --git a/src/packet.c b/src/packet.c
index 8cdf856d..699b69aa 100644
--- a/src/packet.c
+++ b/src/packet.c
@@ -651,7 +651,7 @@ int libssh2_packet_ask_ex(LIBSSH2_SESSION *session, unsigned char packet_type,
  * socket for a packet first
  */
 int libssh2_packet_askv_ex(LIBSSH2_SESSION *session,
-                           unsigned char *packet_types,
+                           const unsigned char *packet_types,
                            unsigned char **data,
                            unsigned long *data_len,
                            unsigned long match_ofs,
@@ -816,7 +816,7 @@ int libssh2_packet_burn(LIBSSH2_SESSION *session)
  */
 
 int libssh2_packet_requirev_ex(LIBSSH2_SESSION *session,
-                               unsigned char *packet_types,
+                               const unsigned char *packet_types,
                                unsigned char **data, unsigned long *data_len,
                                unsigned long match_ofs,
                                const unsigned char *match_buf,
diff --git a/src/session.c b/src/session.c
index 7276d8bf..95c7944e 100644
--- a/src/session.c
+++ b/src/session.c
@@ -555,7 +555,7 @@ LIBSSH2_API int libssh2_session_disconnect_ex(LIBSSH2_SESSION *session, int reas
 LIBSSH2_API const char *libssh2_session_methods(LIBSSH2_SESSION *session, int method_type)
 {
 	/* All methods have char *name as their first element */
-	LIBSSH2_KEX_METHOD *method = NULL;
+	const LIBSSH2_KEX_METHOD *method = NULL;
 
 	switch(method_type) {
 		case LIBSSH2_METHOD_KEX:
diff --git a/src/sftp.c b/src/sftp.c
index 97edd1bb..c643aea7 100644
--- a/src/sftp.c
+++ b/src/sftp.c
@@ -293,7 +293,7 @@ static int libssh2_sftp_packet_require(LIBSSH2_SFTP *sftp, unsigned char packet_
  */
 static int libssh2_sftp_packet_requirev(LIBSSH2_SFTP *sftp,
                                         int num_valid_responses,
-                                        unsigned char *valid_responses,
+                                        const unsigned char *valid_responses,
                                         unsigned long request_id,
                                         unsigned char **data,
                                         unsigned long *data_len)
@@ -572,7 +572,7 @@ LIBSSH2_API LIBSSH2_SFTP_HANDLE *libssh2_sftp_open_ex(LIBSSH2_SFTP *sftp, char *
 	ssize_t packet_len = filename_len + 13 + ((open_type == LIBSSH2_SFTP_OPENFILE) ? (4 + libssh2_sftp_attrsize(&attrs)) : 0);
                                                         /* packet_len(4) + packet_type(1) + request_id(4) + filename_len(4) + flags(4) */
         unsigned char *packet, *data, *s;
-        unsigned char fopen_responses[2] = { SSH_FXP_HANDLE,    SSH_FXP_STATUS  };
+        static const unsigned char fopen_responses[2] = { SSH_FXP_HANDLE,    SSH_FXP_STATUS  };
         unsigned long request_id;
 
         s = packet = LIBSSH2_ALLOC(session, packet_len);
@@ -666,7 +666,7 @@ static ssize_t _libssh2_sftp_read(LIBSSH2_SFTP_HANDLE *handle,
         unsigned long data_len, request_id;
         ssize_t packet_len = handle->handle_len + 25; /* packet_len(4) + packet_type(1) + request_id(4) + handle_len(4) + offset(8) + length(4) */
         unsigned char *packet, *s, *data;
-        unsigned char read_responses[2] = { SSH_FXP_DATA,               SSH_FXP_STATUS };
+        static const unsigned char read_responses[2] = { SSH_FXP_DATA,               SSH_FXP_STATUS };
         size_t bytes_read = 0;
         size_t bytes_requested = 0;
         size_t total_read = 0;
@@ -822,7 +822,7 @@ LIBSSH2_API int libssh2_sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
         unsigned long data_len, request_id, filename_len, num_names;
         ssize_t packet_len = handle->handle_len + 13; /* packet_len(4) + packet_type(1) + request_id(4) + handle_len(4) */
         unsigned char *packet, *s, *data;
-        unsigned char read_responses[2] = { SSH_FXP_NAME,               SSH_FXP_STATUS };
+        static const unsigned char read_responses[2] = { SSH_FXP_NAME,               SSH_FXP_STATUS };
 
         if (handle->u.dir.names_left) {
                 /* A prior request returned more than one directory entry, feed it back from the buffer */
@@ -1051,7 +1051,7 @@ LIBSSH2_API int libssh2_sftp_fstat_ex(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_
         ssize_t packet_len = handle->handle_len + 13 + (setstat ? libssh2_sftp_attrsize(attrs) : 0);
                                                                                         /* packet_len(4) + packet_type(1) + request_id(4) + handle_len(4) */
         unsigned char *packet, *s, *data;
-        unsigned char fstat_responses[2] = { SSH_FXP_ATTRS,             SSH_FXP_STATUS };
+        static const unsigned char fstat_responses[2] = { SSH_FXP_ATTRS,             SSH_FXP_STATUS };
 
         _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Issuing %s command", setstat ? "set-stat" : "stat");
         s = packet = LIBSSH2_ALLOC(session, packet_len);
@@ -1442,7 +1442,7 @@ LIBSSH2_API int libssh2_sftp_stat_ex(LIBSSH2_SFTP *sftp, char *path, unsigned in
         ssize_t packet_len = path_len + 13 + ((stat_type == LIBSSH2_SFTP_SETSTAT) ? libssh2_sftp_attrsize(attrs) : 0);
                                                                         /* packet_len(4) + packet_type(1) + request_id(4) + path_len(4) */
         unsigned char *packet, *s, *data;
-        unsigned char stat_responses[2] = { SSH_FXP_ATTRS,              SSH_FXP_STATUS  };
+        static const unsigned char stat_responses[2] = { SSH_FXP_ATTRS,              SSH_FXP_STATUS  };
 
         _libssh2_debug(session, LIBSSH2_DBG_SFTP, "%s %s", (stat_type == LIBSSH2_SFTP_SETSTAT) ? "Set-statting" : (stat_type == LIBSSH2_SFTP_LSTAT ? "LStatting" : "Statting"), path);
         s = packet = LIBSSH2_ALLOC(session, packet_len);
@@ -1517,7 +1517,7 @@ LIBSSH2_API int libssh2_sftp_symlink_ex(LIBSSH2_SFTP *sftp, const char *path, un
         ssize_t packet_len = path_len + 13 + ((link_type == LIBSSH2_SFTP_SYMLINK) ? (4 + target_len) : 0);
                                                                         /* packet_len(4) + packet_type(1) + request_id(4) + path_len(4) */
         unsigned char *packet, *s, *data;
-        unsigned char link_responses[2] = { SSH_FXP_NAME,               SSH_FXP_STATUS  };
+        static const unsigned char link_responses[2] = { SSH_FXP_NAME,               SSH_FXP_STATUS  };
 
         if ((sftp->version < 3) &&
                 (link_type != LIBSSH2_SFTP_REALPATH)) {
diff --git a/src/userauth.c b/src/userauth.c
index 5959c54e..94b61d0e 100644
--- a/src/userauth.c
+++ b/src/userauth.c
@@ -54,7 +54,7 @@
  */
 LIBSSH2_API char *libssh2_userauth_list(LIBSSH2_SESSION *session, const char *username, unsigned int username_len)
 {
-	unsigned char reply_codes[3] = { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, 0 };
+	static const unsigned char reply_codes[3] = { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, 0 };
 	unsigned long data_len = username_len + 31; /* packet_type(1) + username_len(4) + service_len(4) + service(14)"ssh-connection" +
 												   method_len(4) + method(4)"none" */
 	unsigned long methods_len;
@@ -121,7 +121,8 @@ LIBSSH2_API int libssh2_userauth_password_ex(LIBSSH2_SESSION *session, const cha
 																	   const char *password, unsigned int password_len,
 																	   LIBSSH2_PASSWD_CHANGEREQ_FUNC((*passwd_change_cb)))
 {
-	unsigned char *data, *s, reply_codes[4] = { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, SSH_MSG_USERAUTH_PASSWD_CHANGEREQ, 0 };
+	unsigned char *data, *s;
+	static const unsigned char reply_codes[4] = { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, SSH_MSG_USERAUTH_PASSWD_CHANGEREQ, 0 };
 	unsigned long data_len = username_len + password_len + 40; /* packet_type(1) + username_len(4) + service_len(4) + service(14)"ssh-connection" + 
 																  method_len(4) + method(8)"password" + chgpwdbool(1) + password_len(4) */
 
@@ -316,11 +317,11 @@ static int libssh2_file_read_publickey(LIBSSH2_SESSION *session, unsigned char *
 /* {{{ libssh2_file_read_privatekey
  * Read a PEM encoded private key from an id_??? style file
  */
-static int libssh2_file_read_privatekey(LIBSSH2_SESSION *session,	LIBSSH2_HOSTKEY_METHOD **hostkey_method, void **hostkey_abstract,
+static int libssh2_file_read_privatekey(LIBSSH2_SESSION *session,	const LIBSSH2_HOSTKEY_METHOD **hostkey_method, void **hostkey_abstract,
 																	const char *method, int method_len,
 																	const char *privkeyfile, const char *passphrase)
 {
-	LIBSSH2_HOSTKEY_METHOD **hostkey_methods_avail = libssh2_hostkey_methods();
+	const LIBSSH2_HOSTKEY_METHOD **hostkey_methods_avail = libssh2_hostkey_methods();
 
 	_libssh2_debug(session, LIBSSH2_DBG_AUTH, "Loading private key file: %s", privkeyfile);
 	*hostkey_method = NULL;
@@ -356,11 +357,12 @@ LIBSSH2_API int libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION *session,
 																				 const char *hostname, unsigned int hostname_len,
 																				 const char *local_username, unsigned int local_username_len)
 {
-	LIBSSH2_HOSTKEY_METHOD *privkeyobj;
+	const LIBSSH2_HOSTKEY_METHOD *privkeyobj;
 	void *abstract;
 	unsigned char buf[5];
 	struct iovec datavec[4];
-	unsigned char *method, *pubkeydata, *packet, *s, *sig, *data, reply_codes[3] = { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, 0 };
+	unsigned char *method, *pubkeydata, *packet, *s, *sig, *data;
+	static const unsigned char reply_codes[3] = { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, 0 };
 	unsigned long method_len, pubkeydata_len, packet_len, sig_len, data_len;
 
 	if (libssh2_file_read_publickey(session, &method, &method_len, &pubkeydata, &pubkeydata_len, publickey)) {
@@ -490,7 +492,7 @@ LIBSSH2_API int libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
                                                                                  const char *publickey, const char *privatekey,
                                                                                  const char *passphrase)
 {
-	LIBSSH2_HOSTKEY_METHOD *privkeyobj;
+	const LIBSSH2_HOSTKEY_METHOD *privkeyobj;
 	void *abstract;
 	unsigned char buf[5];
 	struct iovec datavec[4];
@@ -707,7 +709,7 @@ LIBSSH2_API int libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION *sessio
 	LIBSSH2_FREE(session, data);
 
 	for (;;) {
-		unsigned char reply_codes[4] = { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, SSH_MSG_USERAUTH_INFO_REQUEST, 0 };
+		static const unsigned char reply_codes[4] = { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, SSH_MSG_USERAUTH_INFO_REQUEST, 0 };
 		unsigned int auth_name_len;
 		char* auth_name = NULL;
 		unsigned auth_instruction_len;