diff --git a/TODO b/TODO
index 7d28a3f0..832c7e05 100644
--- a/TODO
+++ b/TODO
@@ -1,3 +1,8 @@
+ - New proxy code crashes if an invalid proxy_type setting is used
+ - Remove old socks code
+ - Lots of warnings at least when using socks5
+ - Clean up coding style
+
 19:36 [IRCNet] [muzzy] more bugs in irssi, apparently the new version:  foo splits out,
       	       	       bar joins, bar changes his nick to foo, foo splits again ->
 		       Glib warning "is already in split list (how?)" .. :)
diff --git a/src/core/network-openssl.c b/src/core/network-openssl.c
index fc729dde..680feffd 100644
--- a/src/core/network-openssl.c
+++ b/src/core/network-openssl.c
@@ -565,7 +565,7 @@ static GIOChannel *irssi_ssl_get_iochannel(GIOChannel *handle, int port, SERVER_
 	return gchan;
 }
 
-GIOChannel *net_connect_proxy_ssl(struct network_proxy const *proxy, char const *host, int port,
+GIOChannel *net_connect_proxy_ssl(const struct network_proxy *proxy, const char *host, int port,
                                   IPADDR *ip, IPADDR *my_ip, SERVER_REC *server)
 {
 	GIOChannel *handle, *ssl_handle;
diff --git a/src/core/network-proxy-http.c b/src/core/network-proxy-http.c
index 07966b3f..fa27c7c1 100644
--- a/src/core/network-proxy-http.c
+++ b/src/core/network-proxy-http.c
@@ -25,10 +25,9 @@
 #include "network.h"
 #include "network-proxy-priv.h"
 
-static void
-network_proxy_http_destroy(struct network_proxy *proxy)
+static void network_proxy_http_destroy(struct network_proxy *proxy)
 {
-    struct _network_proxy_http  *self = container_of(proxy, struct _network_proxy_http, proxy);
+    struct _network_proxy_http *self = container_of(proxy, struct _network_proxy_http, proxy);
 
     g_free((void *)self->password);
     _network_proxy_destroy(proxy);
@@ -39,8 +38,8 @@ network_proxy_http_destroy(struct network_proxy *proxy)
 static struct network_proxy *
 network_proxy_http_clone(struct network_proxy const *proxy)
 {
-    struct _network_proxy_http  *self = container_of(proxy, struct _network_proxy_http, proxy);
-    struct _network_proxy_http  *res;
+    struct _network_proxy_http *self = container_of(proxy, struct _network_proxy_http, proxy);
+    struct _network_proxy_http *res;
 
     res = g_malloc0(sizeof *res);
 
@@ -49,18 +48,18 @@ network_proxy_http_clone(struct network_proxy const *proxy)
     return &res->proxy;
 }
 
-static bool
-send_connect(struct _network_proxy_http *proxy, GIOChannel *ch, char const *address, uint16_t port)
+static bool send_connect(struct _network_proxy_http *proxy, GIOChannel *ch,
+						 char const *address, uint16_t port)
 {
-    char                port_str[6];
+    char port_str[6];
 
     (void)proxy;
     sprintf(port_str, "%u", port);
 
     if (!_network_proxy_send_all(ch, "CONNECT ", -1) ||
-        !_network_proxy_send_all(ch, address,    -1) ||
-        !_network_proxy_send_all(ch, ":",        -1) ||
-        !_network_proxy_send_all(ch, port_str,   -1) ||
+        !_network_proxy_send_all(ch, address, -1) ||
+        !_network_proxy_send_all(ch, ":", -1) ||
+        !_network_proxy_send_all(ch, port_str, -1) ||
         !_network_proxy_send_all(ch, " HTTP/1.0\r\n\r\n", -1) ||
         !_network_proxy_flush(ch))
         return false;
@@ -68,16 +67,15 @@ send_connect(struct _network_proxy_http *proxy, GIOChannel *ch, char const *addr
     return true;
 }
 
-static int
-read_response(struct _network_proxy_http *proxy, GIOChannel *ch)
+static int read_response(struct _network_proxy_http *proxy, GIOChannel *ch)
 {
-    GIOStatus           status;
-    GString             line = { .str = NULL };
-    gsize               term_pos;
-    GError              *err = NULL;
-    int             state = 0;
-    int             rc = 0;
-    gchar               *resp = NULL;
+    GIOStatus status;
+    GString line = { .str = NULL };
+    gsize term_pos;
+    GError *err = NULL;
+    int state = 0;
+    int rc = 0;
+    gchar *resp = NULL;
 
     (void)proxy;
     for (;;) {
@@ -97,7 +95,7 @@ read_response(struct _network_proxy_http *proxy, GIOChannel *ch)
         if (state==0) {
             if (g_str_has_prefix(line.str, "HTTP/1.0 ")) {
                 resp = g_strndup(line.str+9, line.len-9-2);
-                rc   = g_ascii_strtoull(resp, NULL, 10);
+                rc = g_ascii_strtoull(resp, NULL, 10);
             } else {
                 g_warning("unexpected HTTP response: '%s'", line.str);
                 goto err;
@@ -125,16 +123,15 @@ err:
     return -1;
 }
 
-static GIOChannel *
-network_proxy_http_connect(struct network_proxy const *proxy, IPADDR const *hint_ip,
-                           char const *address, int port)
+static GIOChannel *network_proxy_http_connect(struct network_proxy const *proxy, IPADDR const *hint_ip,
+											  char const *address, int port)
 {
-    struct _network_proxy_http  *self = container_of(proxy, struct _network_proxy_http, proxy);
-    GIOChannel          *ch;
-    GIOFlags            old_flags;
-    GError              *err = NULL;
-    gchar const         *line_term;
-    gint                line_term_sz;
+    struct _network_proxy_http *self = container_of(proxy, struct _network_proxy_http, proxy);
+    GIOChannel *ch;
+    GIOFlags old_flags;
+    GError *err = NULL;
+    gchar const *line_term;
+    gint line_term_sz;
 
     if (hint_ip)
         ch = net_connect_ip(hint_ip, self->proxy.port, NULL);
@@ -175,19 +172,18 @@ err:
 }
 
 
-struct network_proxy *
-_network_proxy_http_create(void)
+struct network_proxy *_network_proxy_http_create(void)
 {
-    struct _network_proxy_http  *res;
+    struct _network_proxy_http *res;
 
     res = g_malloc0(sizeof *res);
 
     _network_proxy_create(&res->proxy);
-    res->password    = g_strdup(settings_get_str("proxy_password"));
+    res->password = g_strdup(settings_get_str("proxy_password"));
 
     res->proxy.destroy = network_proxy_http_destroy;
     res->proxy.connect = network_proxy_http_connect;
-    res->proxy.clone   = network_proxy_http_clone;
+    res->proxy.clone = network_proxy_http_clone;
 
     return &res->proxy;
 }
diff --git a/src/core/network-proxy-http.h b/src/core/network-proxy-http.h
index 67eb208d..b47bfc5e 100644
--- a/src/core/network-proxy-http.h
+++ b/src/core/network-proxy-http.h
@@ -20,10 +20,10 @@
 #include "network-proxy.h"
 
 struct _network_proxy_http {
-    struct network_proxy    proxy;
-    char const      *password;
+    struct network_proxy proxy;
+    char const *password;
 };
 
-struct network_proxy *      _network_proxy_http_create(void);
+struct network_proxy *_network_proxy_http_create(void);
 
 #endif  /* H_IRSSI_SRC_CORE_PROXY_HTTP_H */
diff --git a/src/core/network-proxy-priv.h b/src/core/network-proxy-priv.h
index e4d5e22b..8e5fcf95 100644
--- a/src/core/network-proxy-priv.h
+++ b/src/core/network-proxy-priv.h
@@ -26,38 +26,34 @@
             (type *)( (char *)__mptr - offsetof(type,member) );})
         
             
-inline static void
-_network_proxy_create(struct network_proxy *dst)
+inline static void _network_proxy_create(struct network_proxy *dst)
 {
-    dst->port  = settings_get_int("proxy_port");
-    dst->host  = g_strdup(settings_get_str("proxy_address"));
+    dst->port = settings_get_int("proxy_port");
+    dst->host = g_strdup(settings_get_str("proxy_address"));
 }
         
-inline static void
-_network_proxy_clone(struct network_proxy *dst, struct network_proxy const *src)
+inline static void _network_proxy_clone(struct network_proxy *dst, struct network_proxy const *src)
 {
-    dst->host  = g_strdup(src->host);
-    dst->port  = src->port;
+    dst->host = g_strdup(src->host);
+    dst->port = src->port;
     
     dst->destroy = src->destroy;
     dst->connect = src->connect;
-    dst->clone   = src->clone;
+    dst->clone = src->clone;
 }
 
-inline static void
-_network_proxy_destroy(struct network_proxy *proxy)
+inline static void _network_proxy_destroy(struct network_proxy *proxy)
 {
     g_free((void *)proxy->host);
 }
 
 
 
-inline static bool
-_network_proxy_send_all(GIOChannel *ch, void const *buf, ssize_t len)
+inline static bool _network_proxy_send_all(GIOChannel *ch, void const *buf, ssize_t len)
 {
-    GError              *err = NULL;
-    gsize               written;
-    GIOStatus           status;
+    GError *err = NULL;
+    gsize written;
+    GIOStatus status;
     
     while ((status=g_io_channel_write_chars(ch, buf, len, &written,
                                             &err))==G_IO_STATUS_AGAIN)
@@ -74,15 +70,14 @@ _network_proxy_send_all(GIOChannel *ch, void const *buf, ssize_t len)
     return false;
 }
 
-inline static bool
-_network_proxy_recv_all(GIOChannel *ch, void *buf_v, size_t len)
+inline static bool _network_proxy_recv_all(GIOChannel *ch, void *buf_v, size_t len)
 {
-    GError              *err = NULL;
-    gchar               *buf = buf_v;
+    GError *err = NULL;
+    gchar *buf = buf_v;
     
     while (len>0) {
-        GIOStatus       status;
-        gsize           l;
+        GIOStatus status;
+        gsize l;
         
         status = g_io_channel_read_chars(ch, buf, len, &l, &err);
         if (status==G_IO_STATUS_AGAIN)
@@ -105,11 +100,10 @@ _network_proxy_recv_all(GIOChannel *ch, void *buf_v, size_t len)
     return false;
 }
 
-inline static bool
-_network_proxy_flush(GIOChannel *ch)
+inline static bool _network_proxy_flush(GIOChannel *ch)
 {
-    GError          *err = NULL;
-    GIOStatus       status;
+    GError *err = NULL;
+    GIOStatus status;
     
     while ((status=g_io_channel_flush(ch, &err))==G_IO_STATUS_AGAIN)
         continue;
diff --git a/src/core/network-proxy-simple.c b/src/core/network-proxy-simple.c
new file mode 100644
index 00000000..980215b5
--- /dev/null
+++ b/src/core/network-proxy-simple.c
@@ -0,0 +1,128 @@
+/*
+ network-proxy-simple.c : irssi
+
+    Copyright (C) 2008 Enrico Scholz <enrico.scholz@informatik.tu-chemnitz.de>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; version 2 and/or 3 of the License.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "module.h"
+#include "network-proxy-simple.h"
+
+#include "network-proxy-priv.h"
+#include "network.h"
+
+static void network_proxy_simple_destroy(struct network_proxy *proxy)
+{
+	struct network_proxy_simple *self = (struct network_proxy_simple *)proxy->privdata;
+
+	g_free(self->password);
+	g_free(self->string_after);
+	g_free(self->string);
+
+	g_free(self);
+
+	_network_proxy_destroy(proxy);
+
+	// We are responsible for the whole proxy struct
+	g_free(proxy);
+}
+
+static struct network_proxy *network_proxy_simple_clone(const struct network_proxy *proxy)
+{
+	struct network_proxy_simple *self = (struct network_proxy_simple *)proxy->privdata;
+	struct network_proxy *res;
+	struct network_proxy_simple *newself;
+
+	// First make and set the parent struct
+	res = g_malloc0(sizeof(struct network_proxy));
+	_network_proxy_clone(res, proxy);
+
+	// Then allocate and set the private data
+	newself = g_malloc0(sizeof(struct network_proxy_simple));
+	res->privdata = (void *)newself;
+
+	newself->string = g_strdup(self->string);
+	newself->string_after = g_strdup(self->string_after);
+	newself->password = g_strdup(self->password);
+
+	return res;
+}
+
+static GIOChannel *network_proxy_simple_connect(const struct network_proxy *proxy,
+						const IPADDR *hint_ip, char const *address, int port)
+{
+	if (hint_ip)
+		return net_connect_ip(hint_ip, proxy->port, NULL);
+	else
+		return net_connect(proxy->host, proxy->port, NULL);
+}
+
+static void network_proxy_simple_send_string(const struct network_proxy *proxy,
+					     const struct network_proxy_send_string_info *info)
+{
+	struct network_proxy_simple *self = (struct network_proxy_simple *)proxy->privdata;
+	char *cmd;
+
+	if (self->password && self->password[0]) {
+		cmd = g_strdup_printf("PASS %s", self->password);
+		info->func(info->obj, cmd);
+		g_free(cmd);
+	}
+
+	if (self->string && self->string[0]) {
+		cmd = g_strdup_printf(self->string, info->host, info->port);
+		info->func(info->obj, cmd);
+		g_free(cmd);
+	}
+}
+
+static void network_proxy_simple_send_string_after(const struct network_proxy *proxy,
+						   const struct network_proxy_send_string_info *info)
+{
+	struct network_proxy_simple *self = (struct network_proxy_simple *)proxy->privdata;
+	char *cmd;
+
+	if (self->string_after && self->string_after[0]) {
+		cmd = g_strdup_printf(self->string_after, info->host, info->port);
+		info->func(info->obj, cmd);
+		g_free(cmd);
+	}
+}
+
+struct network_proxy *network_proxy_simple_create(void)
+{
+	struct network_proxy *proxy;
+	struct network_proxy_simple *self;
+
+	proxy = g_malloc0(sizeof(struct network_proxy));
+
+	// assume it could reset every variable to a known state
+	_network_proxy_create(proxy);
+
+	self = g_malloc0(sizeof(struct network_proxy_simple));
+	proxy->privdata = (void *)self;
+
+	self->string = g_strdup(settings_get_str("proxy_string"));
+	self->string_after = g_strdup(settings_get_str("proxy_string_after"));
+	self->password = g_strdup(settings_get_str("proxy_password"));
+
+	proxy->destroy = network_proxy_simple_destroy;
+	proxy->connect = network_proxy_simple_connect;
+	proxy->clone = network_proxy_simple_clone;
+
+	proxy->send_string = network_proxy_simple_send_string;
+	proxy->send_string_after = network_proxy_simple_send_string_after;
+
+	return proxy;
+}
diff --git a/src/core/network-proxy-simple.h b/src/core/network-proxy-simple.h
new file mode 100644
index 00000000..010d8e4a
--- /dev/null
+++ b/src/core/network-proxy-simple.h
@@ -0,0 +1,14 @@
+#ifndef H_IRSSI_SRC_CORE_PROXY_SIMPLE_H
+#define H_IRSSI_SRC_CORE_PROXY_SIMPLE_H
+
+#include "network-proxy.h"
+
+struct network_proxy_simple {
+	char *string_after;
+	char *string;
+	char *password;
+};
+
+struct network_proxy *network_proxy_simple_create(void);
+
+#endif
diff --git a/src/core/network-proxy-socks5.c b/src/core/network-proxy-socks5.c
index 64a8f510..69214b10 100644
--- a/src/core/network-proxy-socks5.c
+++ b/src/core/network-proxy-socks5.c
@@ -26,45 +26,44 @@
 /* RFC 1928 */
 struct client_greeting
 {
-	uint8_t		ver;
-	uint8_t		nmethods;
-	uint8_t		methods[];
+	uint8_t	ver;
+	uint8_t	nmethods;
+	uint8_t	methods[];
 } __attribute__((__packed__));
 
 struct server_greeting
 {
-	uint8_t		ver;
-	uint8_t		method;
+	uint8_t	ver;
+	uint8_t	method;
 } __attribute__((__packed__));
 
 struct server_response_plain
 {
-	uint8_t		ver;
-	uint8_t		status;
+	uint8_t	ver;
+	uint8_t	status;
 } __attribute__((__packed__));
 
 struct client_request
 {
-	uint8_t		ver;
-	uint8_t		cmd;
-	uint8_t		rsv;
-	uint8_t		atyp;
-	uint8_t		dst[];
+	uint8_t	ver;
+	uint8_t	cmd;
+	uint8_t	rsv;
+	uint8_t	atyp;
+	uint8_t	dst[];
 } __attribute__((__packed__));
 
 struct server_response
 {
-	uint8_t		ver;
-	uint8_t		rep;
-	uint8_t		res;
-	uint8_t		atyp;
-	uint8_t		bnd[];
+	uint8_t	ver;
+	uint8_t	rep;
+	uint8_t	res;
+	uint8_t	atyp;
+	uint8_t	bnd[];
 } __attribute__((__packed__));
 
-static void
-network_proxy_socks5_destroy(struct network_proxy *proxy)
+static void network_proxy_socks5_destroy(struct network_proxy *proxy)
 {
-	struct _network_proxy_socks5	*self = container_of(proxy, struct _network_proxy_socks5, proxy);
+	struct _network_proxy_socks5 *self = container_of(proxy, struct _network_proxy_socks5, proxy);
 
 	g_free((void *)self->password);
 	g_free((void *)self->username);
@@ -72,11 +71,10 @@ network_proxy_socks5_destroy(struct network_proxy *proxy)
 	g_free(self);
 }
 
-static struct network_proxy *
-network_proxy_socks5_clone(struct network_proxy const *proxy)
+static struct network_proxy *network_proxy_socks5_clone(struct network_proxy const *proxy)
 {
-	struct _network_proxy_socks5	*self = container_of(proxy, struct _network_proxy_socks5, proxy);
-	struct _network_proxy_socks5	*res;
+	struct _network_proxy_socks5 *self = container_of(proxy, struct _network_proxy_socks5, proxy);
+	struct _network_proxy_socks5 *res;
 
 	res = g_malloc0(sizeof *res);
 
@@ -86,8 +84,7 @@ network_proxy_socks5_clone(struct network_proxy const *proxy)
 	return &res->proxy;
 }
 
-static bool
-socks5_connect_unauthorized(GIOChannel *ch)
+static bool socks5_connect_unauthorized(GIOChannel *ch)
 {
 	/* nothing to do here */
 	(void)ch;
@@ -95,12 +92,11 @@ socks5_connect_unauthorized(GIOChannel *ch)
 }
 
 /* TODO: test this method! */
-static bool
-socks5_connect_plain(struct _network_proxy_socks5 const *proxy, GIOChannel *ch)
+static bool socks5_connect_plain(struct _network_proxy_socks5 const *proxy, GIOChannel *ch)
 {
-	uint8_t				ver  = 0x01;
-	uint8_t				ulen = strlen(proxy->username);
-	uint8_t				plen = proxy->password ? strlen(proxy->password) : 0;
+	uint8_t	ver  = 0x01;
+	uint8_t	ulen = strlen(proxy->username);
+	uint8_t	plen = proxy->password ? strlen(proxy->password) : 0;
 	struct server_response_plain	resp;
 
 	if (ulen==0 ||
@@ -126,30 +122,29 @@ socks5_connect_plain(struct _network_proxy_socks5 const *proxy, GIOChannel *ch)
 	return true;
 }
 
-static bool
-socks5_connect(struct _network_proxy_socks5 const *proxy, GIOChannel *ch,
-	       char const *address, uint16_t port)
+static bool socks5_connect(struct _network_proxy_socks5 const *proxy, GIOChannel *ch,
+						   char const *address, uint16_t port)
 {
-	bool				rc;
+	bool rc;
 
-	struct server_greeting		s_greeting;
-	struct server_response		s_response;
+	struct server_greeting s_greeting;
+	struct server_response s_response;
 
 
 	/* Phase 1: exchange greeting */
 	{
-		struct client_greeting		c_greeting = {
+		struct client_greeting c_greeting = {
 			.ver      = 0x05,
 			.nmethods = proxy->username && proxy->username[0] ? 2 : 1
 		};
 		/* HACK: order is important because it depends upon
 		 * c_greeting.nmethods  */
-		char const			methods[] = {
-			0x00,			/* no authentication */
-			0x02			/* username/password */
+		char const methods[] = {
+			0x00, /* no authentication */
+			0x02 /* username/password */
 		};
 		if (!_network_proxy_send_all(ch, &c_greeting, sizeof c_greeting) ||
-		    !_network_proxy_send_all(ch, methods,     c_greeting.nmethods) ||
+		    !_network_proxy_send_all(ch, methods, c_greeting.nmethods) ||
 		    !_network_proxy_flush(ch) ||
 		    !_network_proxy_recv_all(ch, &s_greeting, sizeof s_greeting))
 			goto err;
@@ -178,21 +173,21 @@ socks5_connect(struct _network_proxy_socks5 const *proxy, GIOChannel *ch,
 	/* Phase 3: connection request */
 	{
 		struct client_request		c_request = {
-			.ver	  = 0x05,
-			.cmd	  = 0x01,	/* CONNECT */
-			.atyp     = 0x03,	/* domain name */
+			.ver = 0x05,
+			.cmd = 0x01,	/* CONNECT */
+			.atyp = 0x03,	/* domain name */
 		};
-		uint8_t				address_len = strlen(address);
-		uint16_t			dst_port = htons(port);
-		uint16_t			bnd_port;
-		char				bnd_address[257];
+		uint8_t	address_len = strlen(address);
+		uint16_t dst_port = htons(port);
+		uint16_t bnd_port;
+		char bnd_address[257];
 
-		if (!_network_proxy_send_all(ch, &c_request,   sizeof c_request) ||
+		if (!_network_proxy_send_all(ch, &c_request, sizeof c_request) ||
 		    !_network_proxy_send_all(ch, &address_len, sizeof address_len) ||
-		    !_network_proxy_send_all(ch, address,      address_len) ||
-		    !_network_proxy_send_all(ch, &dst_port,    sizeof dst_port) ||
+		    !_network_proxy_send_all(ch, address, address_len) ||
+		    !_network_proxy_send_all(ch, &dst_port, sizeof dst_port) ||
 		    !_network_proxy_flush(ch) ||
-		    !_network_proxy_recv_all(ch, &s_response,  sizeof s_response))
+		    !_network_proxy_recv_all(ch, &s_response, sizeof s_response))
 			goto err;
 
 		if (s_response.ver != 0x05) {
@@ -212,7 +207,7 @@ socks5_connect(struct _network_proxy_socks5 const *proxy, GIOChannel *ch,
 		case 0x06: g_warning("SOCKS5: TTL expired"); break;
 		case 0x07: g_warning("SOCKS5: Command not supported"); break;
 		case 0x08: g_warning("SOCKS5: Address type not supported"); break;
-		default:   g_warning("SOCKS5: unknown error %#04x", s_response.rep); break;
+		default: g_warning("SOCKS5: unknown error %#04x", s_response.rep); break;
 		}
 
 		if (!rc)
@@ -221,7 +216,7 @@ socks5_connect(struct _network_proxy_socks5 const *proxy, GIOChannel *ch,
 		switch(s_response.atyp) {
 		case 0x01: {
 			struct in_addr	ip;
-			if (!_network_proxy_recv_all(ch, &ip,     sizeof ip) ||
+			if (!_network_proxy_recv_all(ch, &ip, sizeof ip) ||
 			    !inet_ntop(AF_INET, &ip, bnd_address, sizeof bnd_address))
 				rc = false;
 			break;
@@ -229,14 +224,14 @@ socks5_connect(struct _network_proxy_socks5 const *proxy, GIOChannel *ch,
 
 		case 0x04: {
 			struct in6_addr	ip;
-			if (!_network_proxy_recv_all(ch, &ip,      sizeof ip) ||
+			if (!_network_proxy_recv_all(ch, &ip, sizeof ip) ||
 			    !inet_ntop(AF_INET6, &ip, bnd_address, sizeof bnd_address))
 				rc = false;
 			break;
 		}
 
 		case 0x03: {
-			uint8_t		tmp;
+			uint8_t	tmp;
 			if (!_network_proxy_recv_all(ch, &tmp, sizeof tmp) ||
 			    tmp==0 ||
 			    !_network_proxy_recv_all(ch, &bnd_address, tmp))
@@ -267,17 +262,16 @@ err:
 }
 
 
-static GIOChannel *
-network_proxy_socks5_connect(struct network_proxy const *proxy, IPADDR const *hint_ip,
-			     char const *address, int port)
+static GIOChannel *network_proxy_socks5_connect(struct network_proxy const *proxy, IPADDR const *hint_ip,
+												char const *address, int port)
 {
-	struct _network_proxy_socks5	*self = container_of(proxy, struct _network_proxy_socks5, proxy);
-	GIOChannel			*ch;
+	struct _network_proxy_socks5 *self = container_of(proxy, struct _network_proxy_socks5, proxy);
+	GIOChannel *ch;
 
-	GIOFlags			old_flags;
-	gchar const			*old_enc;
-	gboolean			old_buf;
-	GError				*err = NULL;
+	GIOFlags old_flags;
+	gchar const	*old_enc;
+	gboolean old_buf;
+	GError *err = NULL;
 
 	if (hint_ip)
 		ch = net_connect_ip(hint_ip, self->proxy.port, NULL);
@@ -287,9 +281,9 @@ network_proxy_socks5_connect(struct network_proxy const *proxy, IPADDR const *hi
 	if (!ch)
 		return NULL;
 
-	old_enc   = g_io_channel_get_encoding(ch);
+	old_enc = g_io_channel_get_encoding(ch);
 	old_flags = g_io_channel_get_flags(ch);
-	old_buf   = g_io_channel_get_buffered(ch);
+	old_buf = g_io_channel_get_buffered(ch);
 
 	if (g_io_channel_set_encoding(ch, NULL, &err)!=G_IO_STATUS_NORMAL ||
 	    g_io_channel_set_flags(ch, old_flags & ~G_IO_FLAG_NONBLOCK, &err)!=G_IO_STATUS_NORMAL)
@@ -319,20 +313,19 @@ err:
 	return NULL;
 }
 
-struct network_proxy *
-_network_proxy_socks5_create(void)
+struct network_proxy *_network_proxy_socks5_create(void)
 {
-	struct _network_proxy_socks5	*res;
+	struct _network_proxy_socks5 *res;
 
 	res = g_malloc0(sizeof *res);
 
 	_network_proxy_create(&res->proxy);
-	res->username    = g_strdup(settings_get_str("proxy_username"));
-	res->password    = g_strdup(settings_get_str("proxy_password"));
+	res->username = g_strdup(settings_get_str("proxy_username"));
+	res->password = g_strdup(settings_get_str("proxy_password"));
 
 	res->proxy.destroy = network_proxy_socks5_destroy;
 	res->proxy.connect = network_proxy_socks5_connect;
-	res->proxy.clone   = network_proxy_socks5_clone;
+	res->proxy.clone = network_proxy_socks5_clone;
 
 	return &res->proxy;
 }
diff --git a/src/core/network-proxy-socks5.h b/src/core/network-proxy-socks5.h
index 963bad3d..c1e7e22c 100644
--- a/src/core/network-proxy-socks5.h
+++ b/src/core/network-proxy-socks5.h
@@ -20,12 +20,12 @@
 #include "network-proxy.h"
 
 struct _network_proxy_socks5 {
-	struct network_proxy	proxy;
+	struct network_proxy proxy;
 
-	char const		*username;
-	char const		*password;
+	char const *username;
+	char const *password;
 };
 
-struct network_proxy *		_network_proxy_socks5_create(void);
+struct network_proxy *_network_proxy_socks5_create(void);
 
 #endif	/* H_IRSSI_SRC_CORE_PROXY_SOCKS5_H */
diff --git a/src/core/network-proxy.h b/src/core/network-proxy.h
index 15ff33a0..89b195bc 100644
--- a/src/core/network-proxy.h
+++ b/src/core/network-proxy.h
@@ -24,20 +24,20 @@
  * class */
 struct network_proxy_send_string_info
 {
-    char const      *host;  /* hostname of the IRC server */
-    uint16_t        port;   /* portnumber of the IRC server */
+    char const *host;  /* hostname of the IRC server */
+    uint16_t port;   /* portnumber of the IRC server */
     
     /* function which is used to send string; usually irc_send_cmd_now() */
-    void            (*func)(void *obj, char const *);
+    void (*func)(void *obj, char const *);
     
     /* object for func */
-    void            *obj;
+    void *obj;
 };
 
 struct network_proxy {
     /* destroys the network_proxy structure which must not be used anymore
      * after; this memberfunction is mandatory */
-    void            (*destroy)(struct network_proxy *);
+    void (*destroy)(struct network_proxy *);
         
     /* connects through the proxy; this memberfunction is mandatory
      *
@@ -46,36 +46,36 @@ struct network_proxy {
      * \arg address   the hostname where proxy shall connect to
      * \arg port      port address where proxy shall connect to
      */
-    GIOChannel *        (*connect)(struct network_proxy const *, IPADDR const *hint_ip,
+    GIOChannel *(*connect)(struct network_proxy const *, IPADDR const *hint_ip,
                                    char const *address, int port);
         
     /* clones the given network_proxy object; this memberfunction is
      * mandatory */
-    struct network_proxy *  (*clone)(struct network_proxy const *);
+    struct network_proxy * (*clone)(struct network_proxy const *);
         
         
     /* sends a string after connection has been established but before IRC
      * authentication begins; this memberfunction is optional
      */
-    void            (*send_string)(struct network_proxy const *,
-                                   struct network_proxy_send_string_info const *);
+    void (*send_string)(struct network_proxy const *,
+						struct network_proxy_send_string_info const *);
         
     /* sends a string after connection IRC authentication suceeded; this
      * memberfunction is optional
      */
-    void            (*send_string_after)(struct network_proxy const *,
-                                         struct network_proxy_send_string_info const *);
+    void (*send_string_after)(struct network_proxy const *,
+							  struct network_proxy_send_string_info const *);
         
         
     /* hostname of proxy host */
-    char const      *host;
+    char const *host;
         
     /* portnumber of proxy */
-    int         port;
+    int port;
 };
 
 /* factory method to create a proxy object based upon value of 'type' */
-struct network_proxy *      network_proxy_create(char const *type);
+struct network_proxy *network_proxy_create(char const *type);
 
 
 #endif  /* H_IRSSI_SRC_CORE_PROXY_H */
diff --git a/src/core/network.c b/src/core/network.c
index cb1a966e..32601228 100644
--- a/src/core/network.c
+++ b/src/core/network.c
@@ -198,8 +198,8 @@ GIOChannel *net_connect_ip(IPADDR *ip, int port, IPADDR *my_ip)
 }
 
 /* Connect to socket */
-GIOChannel *net_connect_proxy(struct network_proxy const *proxy,
-							  char const *host, int port, IPADDR *ip, IPADDR *my_ip)
+GIOChannel *net_connect_proxy(const struct network_proxy *proxy,
+			      const char *host, int port, IPADDR *ip, IPADDR *my_ip)
 {
 	if (proxy)
 		return proxy->connect(proxy, ip, host, port);
diff --git a/src/core/network.h b/src/core/network.h
index 513a367f..ab37cd1d 100644
--- a/src/core/network.h
+++ b/src/core/network.h
@@ -20,8 +20,8 @@
 #endif
 
 struct _IPADDR {
-	unsigned short family;
-	struct in6_addr ip;
+    unsigned short family;
+    struct in6_addr ip;
 };
 
 /* maxmimum string length of IP address */
@@ -40,12 +40,14 @@ int net_ip_compare(IPADDR *ip1, IPADDR *ip2);
 /* Connect to socket */
 GIOChannel *net_connect(const char *addr, int port, IPADDR *my_ip);
 /* Connect to socket with ip address and SSL*/
-GIOChannel *net_connect_proxy_ssl(struct network_proxy const *proxy, char const *host, int port, IPADDR *ip, IPADDR *my_ip, SERVER_REC *server);
+GIOChannel *net_connect_proxy_ssl(const struct network_proxy *proxy, const char c*host, int port,
+                                  IPADDR *ip, IPADDR *my_ip, SERVER_REC *server);
 
 int irssi_ssl_handshake(GIOChannel *handle);
 /* Connect to socket with ip address */
 GIOChannel *net_connect_ip(IPADDR *ip, int port, IPADDR *my_ip);
-GIOChannel *net_connect_proxy(struct network_proxy const *proxy, char const *host, int port, IPADDR *ip, IPADDR *my_ip);
+GIOChannel *net_connect_proxy(const struct network_proxy *proxy, const char *host, int port,
+                              IPADDR *ip, IPADDR *my_ip);
 /* Connect to named UNIX socket */
 GIOChannel *net_connect_unix(const char *path);
 /* Disconnect socket */
diff --git a/src/core/server-connect-rec.h b/src/core/server-connect-rec.h
index e6345692..399ddd11 100644
--- a/src/core/server-connect-rec.h
+++ b/src/core/server-connect-rec.h
@@ -5,7 +5,7 @@ int chat_type; /* chat_protocol_lookup(xx) */
 
 int refcount;
 
-struct network_proxy	*proxy;
+struct network_proxy *proxy;
 
 unsigned short family; /* 0 = don't care, AF_INET or AF_INET6 */
 char *tag; /* try to keep this tag when connected to server */
diff --git a/src/irc/core/irc-servers.c b/src/irc/core/irc-servers.c
index 284f2b6e..28812e5e 100644
--- a/src/irc/core/irc-servers.c
+++ b/src/irc/core/irc-servers.c
@@ -215,11 +215,11 @@ static void server_init(IRC_SERVER_REC *server)
 	char *address, *ptr, *username, *cmd;
 	GTimeVal now;
 
-	struct network_proxy_send_string_info const	send_info = {
-		.host	=  server->connrec->address,
-		.port	=  server->connrec->port,
-		.func	=  irc_send_cmd_now_wrapper,
-		.obj    =  server
+	const struct network_proxy_send_string_info send_info = {
+		.host = server->connrec->address,
+		.port = server->connrec->port,
+		.func = irc_send_cmd_now_wrapper,
+		.obj = server
 	};
 	
 	g_return_if_fail(server != NULL);