diff --git a/buildconf/all.ini b/buildconf/all.ini
index 2410a7d0..7d2a223c 100644
--- a/buildconf/all.ini
+++ b/buildconf/all.ini
@@ -1,3 +1,3 @@
 [uwsgi]
-main_plugin = python,gevent,psgi,lua,php,rack,jvm,jwsgi,ring,mono,transformation_toupper,coroae,v8,cgi,xslt,webdav,ssi,ldap,gccgo,rados,pypy,zabbix,curl_cron,tornado,tuntap,pty,mongrel2,alarm_curl,router_radius,airbrake
+main_plugin = python,gevent,psgi,lua,php,rack,jvm,jwsgi,ring,mono,transformation_toupper,coroae,v8,cgi,xslt,webdav,ssi,ldap,gccgo,rados,pypy,zabbix,curl_cron,tornado,tuntap,pty,mongrel2,alarm_curl,router_radius,airbrake,gridfs
 inherit = base
diff --git a/core/cache.c b/core/cache.c
index 224a95e2..c45d0696 100644
--- a/core/cache.c
+++ b/core/cache.c
@@ -948,7 +948,7 @@ static void cache_send_udp_command(struct uwsgi_cache *uc, char *key, uint16_t k
 		iov[2].iov_base = key;
 		iov[2].iov_len = keylen;
 
-		uh.pktsize = 2 + keylen;
+		uh._pktsize = 2 + keylen;
 
 		if (cmd == 10) {
 			u_v[0] = (uint8_t) (vallen16 & 0xff);
@@ -972,7 +972,7 @@ static void cache_send_udp_command(struct uwsgi_cache *uc, char *key, uint16_t k
                 	iov[6].iov_base = es;
                 	iov[6].iov_len = es_size;
 
-			uh.pktsize += 2 + vallen16 + 2 + es_size;
+			uh._pktsize += 2 + vallen16 + 2 + es_size;
 		}
 
 		uh.modifier1 = 111;
diff --git a/core/emperor.c b/core/emperor.c
index d32e01ea..19d0f719 100644
--- a/core/emperor.c
+++ b/core/emperor.c
@@ -969,7 +969,7 @@ static void emperor_push_config(struct uwsgi_instance *c_ui) {
 
 	if (c_ui->use_config) {
 		uh.modifier1 = 115;
-		uh.pktsize = c_ui->config_len;
+		uh._pktsize = c_ui->config_len;
 		uh.modifier2 = 0;
 		if (write(c_ui->pipe_config[0], &uh, 4) != 4) {
 			uwsgi_error("[uwsgi-emperor] write() header config");
diff --git a/core/exceptions.c b/core/exceptions.c
index 63c1371a..fc6fe1ca 100644
--- a/core/exceptions.c
+++ b/core/exceptions.c
@@ -46,7 +46,7 @@ extern struct uwsgi_server uwsgi;
 
 struct uwsgi_buffer *uwsgi_exception_handler_object(struct wsgi_request *wsgi_req) {
 	struct uwsgi_buffer *ub = uwsgi_buffer_new(4096);
-	if (uwsgi_buffer_append_keyval(ub, "vars", 4, wsgi_req->buffer,wsgi_req->uh->pktsize)) goto error;
+	if (uwsgi_buffer_append_keyval(ub, "vars", 4, wsgi_req->buffer, wsgi_req->len)) goto error;
 	if (uwsgi.p[wsgi_req->uh->modifier1]->backtrace) {
                 struct uwsgi_buffer *bt = uwsgi.p[wsgi_req->uh->modifier1]->backtrace(wsgi_req);
 		if (bt) {
@@ -280,7 +280,7 @@ notavail4:
 
         if (uwsgi_buffer_append(ub, "\n\n", 2)) goto error;
 
-	if (uwsgi_hooked_parse(wsgi_req->buffer, wsgi_req->uh->pktsize, append_vars_to_ubuf, ub)) {
+	if (uwsgi_hooked_parse(wsgi_req->buffer, wsgi_req->len, append_vars_to_ubuf, ub)) {
 		goto error;
 	}
 
diff --git a/core/fork_server.c b/core/fork_server.c
index 03caec58..5a0baaaa 100644
--- a/core/fork_server.c
+++ b/core/fork_server.c
@@ -85,8 +85,8 @@ void uwsgi_fork_server(char *socket) {
 
 		struct uwsgi_header *uh = (struct uwsgi_header *) hbuf;
 		// this memory area must be freed in the right place !!!
-		char *body_argv = uwsgi_malloc(uh->pktsize);
-		if (uwsgi_read_nb(client_fd, body_argv, uh->pktsize, uwsgi.socket_timeout)) {
+		char *body_argv = uwsgi_malloc(uh->_pktsize);
+		if (uwsgi_read_nb(client_fd, body_argv, uh->_pktsize, uwsgi.socket_timeout)) {
 			free(body_argv);
                         uwsgi_error("uwsgi_fork_server()/uwsgi_read_nb()");
                         goto end;
@@ -184,7 +184,7 @@ void uwsgi_fork_server(char *socket) {
 
 				// now parse the uwsgi packet array and build the argv
 				struct uwsgi_string_list *usl = NULL, *usl_argv = NULL;
-				uwsgi_hooked_parse_array(body_argv, uh->pktsize, parse_argv_hook, &usl_argv);
+				uwsgi_hooked_parse_array(body_argv, uh->_pktsize, parse_argv_hook, &usl_argv);
 				free(body_argv);
 
 				// build new argc/argv
diff --git a/core/io.c b/core/io.c
index 7e0b5ff9..dc492b0f 100644
--- a/core/io.c
+++ b/core/io.c
@@ -277,7 +277,7 @@ static char *uwsgi_scheme_emperor(char *url, size_t *size, int add_zero) {
 		remains-=rlen;
 	}
 
-	remains = uh.pktsize;
+	remains = uh._pktsize;
 	if (!remains) {
 		uwsgi_log("[uwsgi-vassal] invalid config from %s\n", url);
 		exit(1);
@@ -300,7 +300,7 @@ static char *uwsgi_scheme_emperor(char *url, size_t *size, int add_zero) {
                 remains-=rlen;
 	}
 
-	*size = uh.pktsize + add_zero;
+	*size = uh._pktsize + add_zero;
 	return buffer;
 }
 
@@ -1063,7 +1063,7 @@ readok:
         }
 
 	struct uwsgi_header *uh = (struct uwsgi_header *) buf;
-	uint16_t pktsize = uh->pktsize;
+	uint16_t pktsize = uh->_pktsize;
 	if (modifier1)
 		*modifier1 = uh->modifier1;
 	if (modifier2)
diff --git a/core/legion.c b/core/legion.c
index 997bf0b5..b767e3cf 100644
--- a/core/legion.c
+++ b/core/legion.c
@@ -572,7 +572,7 @@ static void *legion_loop(void *foobar) {
 
 			d_len += d2_len;
 
-			if (d_len != uh->pktsize) {
+			if (d_len != uh->_pktsize) {
 				uwsgi_log("[uwsgi-legion] invalid packet size\n");
 				continue;
 			}
diff --git a/core/logging.c b/core/logging.c
index ec219aba..8c1d05fa 100644
--- a/core/logging.c
+++ b/core/logging.c
@@ -715,12 +715,12 @@ void uwsgi_logit_simple(struct wsgi_request *wsgi_req) {
 
 	}
 
-	rlen = snprintf(logpkt, 4096, "[pid: %d|app: %d|req: %d/%llu] %.*s (%.*s) {%d vars in %d bytes} [%.*s] %.*s %.*s => generated %llu bytes in %llu %s%s(%.*s %d) %d headers in %llu bytes (%d switches on core %d)\n", (int) uwsgi.mypid, wsgi_req->app_id, app_req, (unsigned long long) uwsgi.workers[0].requests, wsgi_req->remote_addr_len, wsgi_req->remote_addr, wsgi_req->remote_user_len, wsgi_req->remote_user, wsgi_req->var_cnt, wsgi_req->uh->pktsize,
+	rlen = snprintf(logpkt, 4096, "[pid: %d|app: %d|req: %d/%llu] %.*s (%.*s) {%d vars in %llu bytes} [%.*s] %.*s %.*s => generated %llu bytes in %llu %s%s(%.*s %d) %d headers in %llu bytes (%d switches on core %d)\n", (int) uwsgi.mypid, wsgi_req->app_id, app_req, (unsigned long long) uwsgi.workers[0].requests, wsgi_req->remote_addr_len, wsgi_req->remote_addr, wsgi_req->remote_user_len, wsgi_req->remote_user, wsgi_req->var_cnt, (unsigned long long) wsgi_req->len,
 			24, time_request, wsgi_req->method_len, wsgi_req->method, wsgi_req->uri_len, wsgi_req->uri, (unsigned long long) wsgi_req->response_size, (unsigned long long) rt, tsize, via, wsgi_req->protocol_len, wsgi_req->protocol, wsgi_req->status, wsgi_req->header_cnt, (unsigned long long) wsgi_req->headers_size, wsgi_req->switches, wsgi_req->async_id);
 
 	// not enough space for logging the request, just log a (safe) minimal message
 	if (rlen > 4096) {
-		rlen = snprintf(logpkt, 4096, "[pid: %d|app: %d|req: %d/%llu] 0.0.0.0 () {%d vars in %d bytes} [%.*s] - - => generated %llu bytes in %llu %s%s(- %d) %d headers in %llu bytes (%d switches on core %d)\n", (int) uwsgi.mypid, wsgi_req->app_id, app_req, (unsigned long long) uwsgi.workers[0].requests, wsgi_req->var_cnt, wsgi_req->uh->pktsize,
+		rlen = snprintf(logpkt, 4096, "[pid: %d|app: %d|req: %d/%llu] 0.0.0.0 () {%d vars in %llu bytes} [%.*s] - - => generated %llu bytes in %llu %s%s(- %d) %d headers in %llu bytes (%d switches on core %d)\n", (int) uwsgi.mypid, wsgi_req->app_id, app_req, (unsigned long long) uwsgi.workers[0].requests, wsgi_req->var_cnt, (unsigned long long) wsgi_req->len,
 		24, time_request, (unsigned long long) wsgi_req->response_size, (unsigned long long) rt, tsize, via, wsgi_req->status, wsgi_req->header_cnt, (unsigned long long) wsgi_req->headers_size, wsgi_req->switches, wsgi_req->async_id);
 		// argh, last resort, truncate it
 		if (rlen > 4096) {
@@ -1215,7 +1215,7 @@ static ssize_t uwsgi_lf_rssM(struct wsgi_request * wsgi_req, char **buf) {
 }
 
 static ssize_t uwsgi_lf_pktsize(struct wsgi_request * wsgi_req, char **buf) {
-	*buf = uwsgi_num2str(wsgi_req->uh->pktsize);
+	*buf = uwsgi_num2str(wsgi_req->len);
 	return strlen(*buf);
 }
 
diff --git a/core/protocol.c b/core/protocol.c
index 3872301f..5e650afb 100644
--- a/core/protocol.c
+++ b/core/protocol.c
@@ -46,10 +46,10 @@ int uwsgi_read_response(int fd, struct uwsgi_header *uh, int timeout, char **buf
 		break;
 	}
 
-	if (buf && uh->pktsize > 0) {
+	if (buf && uh->_pktsize > 0) {
 		if (*buf == NULL)
-			*buf = uwsgi_malloc(uh->pktsize);
-		remains = uh->pktsize;
+			*buf = uwsgi_malloc(uh->_pktsize);
+		remains = uh->_pktsize;
 		ptr = *buf;
 		ret = -1;
 		while (remains > 0) {
@@ -578,7 +578,7 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 	struct uwsgi_dyn_dict *udd;
 
 	ptrbuf = buffer;
-	bufferend = ptrbuf + wsgi_req->uh->pktsize;
+	bufferend = ptrbuf + wsgi_req->len;
 	int i;
 
 	/* set an HTTP 500 status as default */
@@ -1035,7 +1035,7 @@ char *uwsgi_req_append(struct wsgi_request *wsgi_req, char *key, uint16_t keylen
 		}
 	}
 
-	if ((wsgi_req->uh->pktsize + (2 + keylen + 2 + vallen)) > uwsgi.buffer_size) {
+	if ((wsgi_req->len + (2 + keylen + 2 + vallen)) > uwsgi.buffer_size) {
 		uwsgi_log("not enough buffer space to add %.*s variable, consider increasing it with the --buffer-size option\n", keylen, key);
 		return NULL;
 	}
@@ -1045,7 +1045,7 @@ char *uwsgi_req_append(struct wsgi_request *wsgi_req, char *key, uint16_t keylen
 		return NULL;
 	}
 
-	char *ptr = wsgi_req->buffer + wsgi_req->uh->pktsize;
+	char *ptr = wsgi_req->buffer + wsgi_req->len;
 
 	*ptr++ = (uint8_t) (keylen & 0xff);
 	*ptr++ = (uint8_t) ((keylen >> 8) & 0xff);
@@ -1066,7 +1066,7 @@ char *uwsgi_req_append(struct wsgi_request *wsgi_req, char *key, uint16_t keylen
         wsgi_req->hvec[wsgi_req->var_cnt].iov_len = vallen;
 	wsgi_req->var_cnt++;
 
-	wsgi_req->uh->pktsize += (2 + keylen + 2 + vallen);
+	wsgi_req->len += (2 + keylen + 2 + vallen);
 
 	return ptr;
 }
@@ -1091,7 +1091,7 @@ int uwsgi_req_append_path_info_with_index(struct wsgi_request *wsgi_req, char *i
 	wsgi_req->path_info_len += need_slash + index_len;
 
 	// 2 + 9 + 2
-	if ((wsgi_req->uh->pktsize + (13 + wsgi_req->path_info_len)) > uwsgi.buffer_size) {
+	if ((wsgi_req->len + (13 + wsgi_req->path_info_len)) > uwsgi.buffer_size) {
                 uwsgi_log("not enough buffer space to transform the PATH_INFO variable, consider increasing it with the --buffer-size option\n");
                 return -1;
         }
@@ -1102,7 +1102,7 @@ int uwsgi_req_append_path_info_with_index(struct wsgi_request *wsgi_req, char *i
         }
 
 	uint16_t keylen = 9;
-	char *ptr = wsgi_req->buffer + wsgi_req->uh->pktsize;
+	char *ptr = wsgi_req->buffer + wsgi_req->len;
 	*ptr++ = (uint8_t) (keylen & 0xff);
         *ptr++ = (uint8_t) ((keylen >> 8) & 0xff);
 
@@ -1128,7 +1128,7 @@ int uwsgi_req_append_path_info_with_index(struct wsgi_request *wsgi_req, char *i
         wsgi_req->hvec[wsgi_req->var_cnt].iov_len = wsgi_req->path_info_len;
         wsgi_req->var_cnt++;
 
-	wsgi_req->uh->pktsize += 13 + wsgi_req->path_info_len;
+	wsgi_req->len += 13 + wsgi_req->path_info_len;
 	wsgi_req->path_info = new_path_info;
 	
 	return 0;
diff --git a/core/rpc.c b/core/rpc.c
index 5aab1503..00084830 100644
--- a/core/rpc.c
+++ b/core/rpc.c
@@ -145,7 +145,7 @@ char *uwsgi_do_rpc(char *node, char *func, uint8_t argc, char *argv[], uint16_t
 	// set the uwsgi header
 	uh = (struct uwsgi_header *) buffer;
 	uh->modifier1 = 173;
-	uh->pktsize = buffer_size;
+	uh->_pktsize = buffer_size;
 	uh->modifier2 = 0;
 
 	// add func to the array
diff --git a/core/signal.c b/core/signal.c
index f496d761..093e598c 100644
--- a/core/signal.c
+++ b/core/signal.c
@@ -266,7 +266,7 @@ int uwsgi_remote_signal_send(char *addr, uint8_t sig) {
 	struct uwsgi_header uh;
 
 	uh.modifier1 = 110;
-	uh.pktsize = 0;
+	uh._pktsize = 0;
 	uh.modifier2 = sig;
 
         int fd = uwsgi_connect(addr, 0, 1);
diff --git a/core/spooler.c b/core/spooler.c
index 3b43eb9e..b4b43c0b 100644
--- a/core/spooler.c
+++ b/core/spooler.c
@@ -303,9 +303,9 @@ char *uwsgi_spool_request(struct wsgi_request *wsgi_req, char *buf, size_t len,
 	struct uwsgi_header uh;
 	uh.modifier1 = 17;
 	uh.modifier2 = 0;
-	uh.pktsize = (uint16_t) len;
+	uh._pktsize = (uint16_t) len;
 #ifdef __BIG_ENDIAN__
-	uh.pktsize = uwsgi_swap16(uh.pktsize);
+	uh._pktsize = uwsgi_swap16(uh._pktsize);
 #endif
 
 	if (write(fd, &uh, 4) != 4) {
@@ -587,10 +587,10 @@ void spooler_manage_task(struct uwsgi_spooler *uspool, char *dir, char *task) {
 			}
 
 #ifdef __BIG_ENDIAN__
-			uh.pktsize = uwsgi_swap16(uh.pktsize);
+			uh._pktsize = uwsgi_swap16(uh._pktsize);
 #endif
 
-			if (uwsgi_protected_read(spool_fd, spool_buf, uh.pktsize) != uh.pktsize) {
+			if (uwsgi_protected_read(spool_fd, spool_buf, uh._pktsize) != uh._pktsize) {
 				uwsgi_error("read()");
 				destroy_spool(dir, task);
 				uwsgi_protected_close(spool_fd);
@@ -598,8 +598,8 @@ void spooler_manage_task(struct uwsgi_spooler *uspool, char *dir, char *task) {
 			}
 
 			// body available ?
-			if (sf_lstat.st_size > (uh.pktsize + 4)) {
-				body_len = sf_lstat.st_size - (uh.pktsize + 4);
+			if (sf_lstat.st_size > (uh._pktsize + 4)) {
+				body_len = sf_lstat.st_size - (uh._pktsize + 4);
 				body = uwsgi_malloc(body_len);
 				if ((size_t) uwsgi_protected_read(spool_fd, body, body_len) != body_len) {
 					uwsgi_error("read()");
@@ -631,7 +631,7 @@ void spooler_manage_task(struct uwsgi_spooler *uspool, char *dir, char *task) {
 					if (uwsgi.harakiri_options.spoolers > 0) {
 						set_spooler_harakiri(uwsgi.harakiri_options.spoolers);
 					}
-					ret = uwsgi.p[i]->spooler(task, spool_buf, uh.pktsize, body, body_len);
+					ret = uwsgi.p[i]->spooler(task, spool_buf, uh._pktsize, body, body_len);
 					if (uwsgi.harakiri_options.spoolers > 0) {
 						set_spooler_harakiri(0);
 					}
diff --git a/core/stats.c b/core/stats.c
index c54b1864..22a4b93c 100644
--- a/core/stats.c
+++ b/core/stats.c
@@ -569,14 +569,13 @@ static void stats_dump_var(char *k, uint16_t kl, char *v, uint16_t vl, void *dat
 
 int uwsgi_stats_dump_vars(struct uwsgi_stats *us, struct uwsgi_core *uc) {
 	if (!uc->in_request) return 0;
-	struct uwsgi_header *uh = (struct uwsgi_header *) uc->buffer;
-	uint16_t pktsize = uh->pktsize;
+	uint64_t pktsize = uc->req.len;
 	if (!pktsize) return 0;
 	char *dst = uwsgi.workers[0].cores[0].buffer;
 	memcpy(dst, uc->buffer+4, uwsgi.buffer_size);
 	// ok now check if something changed...
 	if (!uc->in_request) return 0;
-	if (uh->pktsize != pktsize) return 0;
+	if (uc->req.len != pktsize) return 0;
 	if (memcmp(dst, uc->buffer+4, uwsgi.buffer_size)) return 0;
 	// nothing changed let's dump vars
 	int ret = uwsgi_hooked_parse(dst, pktsize, stats_dump_var, us);
diff --git a/core/utils.c b/core/utils.c
index 52a72114..1d3eb417 100644
--- a/core/utils.c
+++ b/core/utils.c
@@ -1034,7 +1034,7 @@ void uwsgi_destroy_request(struct wsgi_request *wsgi_req) {
 
 	// reset for avoiding following requests to fail on non-uwsgi protocols
 	// thanks Marko Tiikkaja for catching it
-	wsgi_req->uh->pktsize = 0;
+	wsgi_req->uh->_pktsize = 0;
 
 	// some plugins expected async_id to be defined before setup
         int tmp_id = wsgi_req->async_id;
@@ -1182,7 +1182,7 @@ void uwsgi_close_request(struct wsgi_request *wsgi_req) {
 
 
 	// reset request
-	wsgi_req->uh->pktsize = 0;
+	wsgi_req->uh->_pktsize = 0;
 	tmp_id = wsgi_req->async_id;
 	memset(wsgi_req, 0, sizeof(struct wsgi_request));
 	// some plugins expected async_id to be defined before setup
diff --git a/core/uwsgi.c b/core/uwsgi.c
index 9f5f122a..1b854207 100644
--- a/core/uwsgi.c
+++ b/core/uwsgi.c
@@ -172,7 +172,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"listen", required_argument, 'l', "set the socket listen queue size", uwsgi_opt_set_int, &uwsgi.listen_queue, 0},
 	{"max-vars", required_argument, 'v', "set the amount of internal iovec/vars structures", uwsgi_opt_max_vars, NULL, 0},
 	{"max-apps", required_argument, 0, "set the maximum number of per-worker applications", uwsgi_opt_set_int, &uwsgi.max_apps, 0},
-	{"buffer-size", required_argument, 'b', "set internal buffer size", uwsgi_opt_set_16bit, &uwsgi.buffer_size, 0},
+	{"buffer-size", required_argument, 'b', "set internal buffer size", uwsgi_opt_set_64bit, &uwsgi.buffer_size, 0},
 	{"memory-report", no_argument, 'm', "enable memory report", uwsgi_opt_true, &uwsgi.logging_options.memory_report, 0},
 	{"profiler", required_argument, 0, "enable the specified profiler", uwsgi_opt_set_str, &uwsgi.profiler, 0},
 	{"cgi-mode", no_argument, 'c', "force CGI-mode for plugins supporting it", uwsgi_opt_true, &uwsgi.cgi_mode, 0},
diff --git a/plugins/cache/cache.c b/plugins/cache/cache.c
index c0da1fc8..2e9100bf 100644
--- a/plugins/cache/cache.c
+++ b/plugins/cache/cache.c
@@ -208,10 +208,10 @@ static int uwsgi_cache_request(struct wsgi_request *wsgi_req) {
         switch(wsgi_req->uh->modifier2) {
                 case 0:
                         // get
-                        if (wsgi_req->uh->pktsize > 0) {
-                                value = uwsgi_cache_magic_get(wsgi_req->buffer, wsgi_req->uh->pktsize, &vallen, NULL, NULL);
+                        if (wsgi_req->uh->_pktsize > 0) {
+                                value = uwsgi_cache_magic_get(wsgi_req->buffer, wsgi_req->uh->_pktsize, &vallen, NULL, NULL);
                                 if (value) {
-                                        wsgi_req->uh->pktsize = vallen;
+                                        wsgi_req->uh->_pktsize = vallen;
 					if (uwsgi_response_write_body_do(wsgi_req, (char *)&wsgi_req->uh, 4)) { free(value) ; return -1;}
 					uwsgi_response_write_body_do(wsgi_req, value, vallen);
 					free(value);
@@ -220,10 +220,10 @@ static int uwsgi_cache_request(struct wsgi_request *wsgi_req) {
                         break;
                 case 1:
                         // set
-                        if (wsgi_req->uh->pktsize > 0) {
+                        if (wsgi_req->uh->_pktsize > 0) {
 				// max 3 items
                                 argc = 3;
-                                if (!uwsgi_parse_array(wsgi_req->buffer, wsgi_req->uh->pktsize, argv, argvs, &argc)) {
+                                if (!uwsgi_parse_array(wsgi_req->buffer, wsgi_req->uh->_pktsize, argv, argvs, &argc)) {
                                         if (argc > 1) {
 						uwsgi_cache_magic_set(argv[0], argvs[0], argv[1], argvs[1], 0, 0, NULL);
                                         }
@@ -232,30 +232,30 @@ static int uwsgi_cache_request(struct wsgi_request *wsgi_req) {
                         break;
                 case 2:
                         // del
-                        if (wsgi_req->uh->pktsize > 0) {
-                                uwsgi_cache_magic_del(wsgi_req->buffer, wsgi_req->uh->pktsize, NULL);
+                        if (wsgi_req->uh->_pktsize > 0) {
+                                uwsgi_cache_magic_del(wsgi_req->buffer, wsgi_req->uh->_pktsize, NULL);
                         }
                         break;
                 case 3:
                 case 4:
                         // dict
-                        if (wsgi_req->uh->pktsize > 0) {
-                                uwsgi_hooked_parse(wsgi_req->buffer, wsgi_req->uh->pktsize, cache_simple_command, (void *) wsgi_req);
+                        if (wsgi_req->uh->_pktsize > 0) {
+                                uwsgi_hooked_parse(wsgi_req->buffer, wsgi_req->uh->_pktsize, cache_simple_command, (void *) wsgi_req);
                         }
                         break;
                 case 5:
                         // get (uwsgi + stream)
-                        if (wsgi_req->uh->pktsize > 0) {
-                                value = uwsgi_cache_magic_get(wsgi_req->buffer, wsgi_req->uh->pktsize, &vallen, NULL, NULL);
+                        if (wsgi_req->uh->_pktsize > 0) {
+                                value = uwsgi_cache_magic_get(wsgi_req->buffer, wsgi_req->uh->_pktsize, &vallen, NULL, NULL);
                                 if (value) {
-                                        wsgi_req->uh->pktsize = 0;
+                                        wsgi_req->uh->_pktsize = 0;
                                         wsgi_req->uh->modifier2 = 1;
 					if (uwsgi_response_write_body_do(wsgi_req, (char *)&wsgi_req->uh, 4)) { free(value) ;return -1;}
 					uwsgi_response_write_body_do(wsgi_req, value, vallen);
 					free(value);
                                 }
                                 else {
-                                        wsgi_req->uh->pktsize = 0;
+                                        wsgi_req->uh->_pktsize = 0;
                                         wsgi_req->uh->modifier2 = 0;
 					uwsgi_response_write_body_do(wsgi_req, (char *)&wsgi_req->uh, 4);
 					free(value);
@@ -265,8 +265,8 @@ static int uwsgi_cache_request(struct wsgi_request *wsgi_req) {
 		case 6:
 			// dump
 			uc = uwsgi.caches;
-			if (wsgi_req->uh->pktsize > 0) {
-				uc = uwsgi_cache_by_namelen(wsgi_req->buffer, wsgi_req->uh->pktsize);
+			if (wsgi_req->uh->_pktsize > 0) {
+				uc = uwsgi_cache_by_namelen(wsgi_req->buffer, wsgi_req->uh->_pktsize);
 			}
 
 			if (!uc) break;
@@ -299,9 +299,9 @@ static int uwsgi_cache_request(struct wsgi_request *wsgi_req) {
 			uwsgi_buffer_destroy(cache_dump);
 			break;
 		case 17:
-			if (wsgi_req->uh->pktsize == 0) break;
+			if (wsgi_req->uh->_pktsize == 0) break;
 			memset(&ucmc, 0, sizeof(struct uwsgi_cache_magic_context));
-			if (uwsgi_hooked_parse(wsgi_req->buffer, wsgi_req->uh->pktsize, uwsgi_cache_magic_context_hook, &ucmc)) {
+			if (uwsgi_hooked_parse(wsgi_req->buffer, wsgi_req->uh->_pktsize, uwsgi_cache_magic_context_hook, &ucmc)) {
 				break;
 			}
 			manage_magic_context(wsgi_req, &ucmc);
diff --git a/plugins/cgi/cgi_plugin.c b/plugins/cgi/cgi_plugin.c
index d343d59f..0c7d3eb0 100644
--- a/plugins/cgi/cgi_plugin.c
+++ b/plugins/cgi/cgi_plugin.c
@@ -480,7 +480,7 @@ static int uwsgi_cgi_request(struct wsgi_request *wsgi_req) {
 	char *script_name = NULL;
 
 	/* Standard CGI request */
-	if (!wsgi_req->uh->pktsize) {
+	if (!wsgi_req->len) {
 		uwsgi_log("Empty CGI request. skip.\n");
 		return -1;
 	}
diff --git a/plugins/fastrouter/fastrouter.c b/plugins/fastrouter/fastrouter.c
index 0fe24394..ba2a2170 100644
--- a/plugins/fastrouter/fastrouter.c
+++ b/plugins/fastrouter/fastrouter.c
@@ -202,7 +202,7 @@ static ssize_t fr_instance_connected(struct corerouter_peer *peer) {
 static ssize_t fr_recv_uwsgi_vars(struct corerouter_peer *main_peer) {
 	struct uwsgi_header *uh = (struct uwsgi_header *) main_peer->in->buf;
 	// better to store it as the original buf address could change
-	uint16_t pktsize = uh->pktsize;
+	uint16_t pktsize = uh->_pktsize;
 	// increase buffer if needed
 	if (uwsgi_buffer_fix(main_peer->in, pktsize+4))
 		return -1;
diff --git a/plugins/gccgo/gccgo_plugin.c b/plugins/gccgo/gccgo_plugin.c
index d67eefd1..09cfd69b 100644
--- a/plugins/gccgo/gccgo_plugin.c
+++ b/plugins/gccgo/gccgo_plugin.c
@@ -222,7 +222,7 @@ static int uwsgi_gccgo_request(struct wsgi_request *wsgi_req) {
 		goto end;
 	}
 	/* Standard GO request */
-        if (!wsgi_req->uh->pktsize) {
+        if (!wsgi_req->len) {
                 uwsgi_log("Empty GO request. skip.\n");
                 return -1;
         }
diff --git a/plugins/glusterfs/glusterfs.c b/plugins/glusterfs/glusterfs.c
index 33f0ddfc..bab76c79 100644
--- a/plugins/glusterfs/glusterfs.c
+++ b/plugins/glusterfs/glusterfs.c
@@ -213,7 +213,7 @@ static void uwsgi_glusterfs_setup() {
 static int uwsgi_glusterfs_request(struct wsgi_request *wsgi_req) {
 	char filename[PATH_MAX+1];
 	/* Standard GlusterFS request */
-        if (!wsgi_req->uh->pktsize) {
+        if (!wsgi_req->len) {
                 uwsgi_log( "Empty GlusterFS request. skip.\n");
                 return -1;
         }
diff --git a/plugins/gridfs/gridfs.cc b/plugins/gridfs/gridfs.cc
index d11451ad..b9c0e244 100644
--- a/plugins/gridfs/gridfs.cc
+++ b/plugins/gridfs/gridfs.cc
@@ -193,7 +193,7 @@ extern "C" int uwsgi_gridfs_request(struct wsgi_request *wsgi_req) {
         char *itemname = NULL;
 
         /* Standard GridFS request */
-        if (!wsgi_req->uh->pktsize) {
+        if (!wsgi_req->len) {
                 uwsgi_log( "Empty GridFS request. skip.\n");
                 return -1;
         }
diff --git a/plugins/jvm/jvm_plugin.c b/plugins/jvm/jvm_plugin.c
index f709ed1a..511f8936 100644
--- a/plugins/jvm/jvm_plugin.c
+++ b/plugins/jvm/jvm_plugin.c
@@ -1257,7 +1257,7 @@ static int uwsgi_jvm_request(struct wsgi_request *wsgi_req) {
 	}
 
 	/* Standard JVM request */
-        if (!wsgi_req->uh->pktsize) {
+        if (!wsgi_req->len) {
                 uwsgi_log("Empty JVM request. skip.\n");
                 return -1;
         }
diff --git a/plugins/lua/lua_plugin.c b/plugins/lua/lua_plugin.c
index 0bd96a7e..89c50cf9 100644
--- a/plugins/lua/lua_plugin.c
+++ b/plugins/lua/lua_plugin.c
@@ -746,7 +746,7 @@ static int uwsgi_lua_request(struct wsgi_request *wsgi_req) {
 	}
 
 	/* Standard WSAPI request */
-	if (!wsgi_req->uh->pktsize) {
+	if (!wsgi_req->len) {
 		uwsgi_log( "Empty lua request. skip.\n");
 		return -1;
 	}
diff --git a/plugins/mongrel2/mongrel2.c b/plugins/mongrel2/mongrel2.c
index 1dbf6f9c..4eaef1a4 100644
--- a/plugins/mongrel2/mongrel2.c
+++ b/plugins/mongrel2/mongrel2.c
@@ -64,7 +64,7 @@ static int uwsgi_mongrel2_json_parse(json_t * root, struct wsgi_request *wsgi_re
 		if (!strcmp(json_val, "JSON")) {
 			return -1;
 		}
-		wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_METHOD", 14, json_val, strlen(json_val));
+		wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_METHOD", 14, json_val, strlen(json_val));
 	}
 
 	// pretty easy, we get the file and we map it to wsgi_req->post_file, uWSGI read api will automatically use this
@@ -80,49 +80,49 @@ static int uwsgi_mongrel2_json_parse(json_t * root, struct wsgi_request *wsgi_re
 	}
 
 
-	wsgi_req->uh->pktsize += uwsgi_mongrel2_json_add(wsgi_req, root, "VERSION", "SERVER_PROTOCOL", 15, NULL, NULL);
-	wsgi_req->uh->pktsize += uwsgi_mongrel2_json_add(wsgi_req, root, "QUERY", "QUERY_STRING", 12, &query_string, &query_string_len);
+	wsgi_req->len += uwsgi_mongrel2_json_add(wsgi_req, root, "VERSION", "SERVER_PROTOCOL", 15, NULL, NULL);
+	wsgi_req->len += uwsgi_mongrel2_json_add(wsgi_req, root, "QUERY", "QUERY_STRING", 12, &query_string, &query_string_len);
 	if (query_string == NULL) {
 		// always set QUERY_STRING
-		wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "QUERY_STRING", 12, "", 0);
+		wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "QUERY_STRING", 12, "", 0);
 	}
 
 	// set SCRIPT_NAME to an empty value
-	wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "SCRIPT_NAME", 11, "", 0);
+	wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "SCRIPT_NAME", 11, "", 0);
 
 	if ((json_val = uwsgi_mongrel2_json_get_string(root, "PATH"))) {
-		wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "PATH_INFO", 9, json_val + script_name_len, strlen(json_val + script_name_len));
+		wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "PATH_INFO", 9, json_val + script_name_len, strlen(json_val + script_name_len));
 		if (query_string_len) {
 			char *request_uri = uwsgi_concat3n(json_val, strlen(json_val), "?", 1, query_string, query_string_len);
-			wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_URI", 11, request_uri, strlen(json_val) + 1 + query_string_len);
+			wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_URI", 11, request_uri, strlen(json_val) + 1 + query_string_len);
 			free(request_uri);
 		}
 		else {
-			wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_URI", 11, json_val, strlen(json_val));
+			wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_URI", 11, json_val, strlen(json_val));
 		}
 	}
 
 	if ((json_val = uwsgi_mongrel2_json_get_string(root, "URL_SCHEME"))) {
-                wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "UWSGI_SCHEME", 12, json_val, strlen(json_val));
+                wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "UWSGI_SCHEME", 12, json_val, strlen(json_val));
         }
 
 	if ((json_val = uwsgi_mongrel2_json_get_string(root, "host"))) {
 		char *colon = strchr(json_val, ':');
 		if (colon) {
-			wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, colon + 1, strlen(colon + 1));
+			wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, colon + 1, strlen(colon + 1));
 		}
 		else {
-			wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, "80", 2);
+			wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, "80", 2);
 		}
 	}
 
 	if ((json_val = uwsgi_mongrel2_json_get_string(root, "x-forwarded-for"))) {
 		char *colon = strchr(json_val, ',');
 		if (colon) {
-			wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "REMOTE_ADDR", 11, colon + 1, (colon + 1) - json_val);
+			wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "REMOTE_ADDR", 11, colon + 1, (colon + 1) - json_val);
 		}
 		else {
-			wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "REMOTE_ADDR", 11, json_val, strlen(json_val));
+			wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "REMOTE_ADDR", 11, json_val, strlen(json_val));
 		}
 	}
 
@@ -131,7 +131,7 @@ static int uwsgi_mongrel2_json_parse(json_t * root, struct wsgi_request *wsgi_re
 		wsgi_req->post_cl = atoi(json_val);
 	}
 
-	wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_NAME", 11, uwsgi.hostname, uwsgi.hostname_len);
+	wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "SERVER_NAME", 11, uwsgi.hostname, uwsgi.hostname_len);
 
 	json_iter = json_object_iter(root);
 
@@ -142,7 +142,7 @@ static int uwsgi_mongrel2_json_parse(json_t * root, struct wsgi_request *wsgi_re
 			json_value = json_object_iter_value(json_iter);
 			if (json_is_string(json_value)) {
 				json_val = (char *) json_string_value(json_value);
-				wsgi_req->uh->pktsize += proto_base_add_uwsgi_header(wsgi_req, json_key, strlen(json_key), json_val, strlen(json_val));
+				wsgi_req->len += proto_base_add_uwsgi_header(wsgi_req, json_key, strlen(json_key), json_val, strlen(json_val));
 			}
 		}
 		json_iter = json_object_iter_next(root, json_iter);
@@ -169,7 +169,7 @@ static int uwsgi_mongrel2_tnetstring_parse(struct wsgi_request *wsgi_req, char *
 	int async_upload = 0;
 
 	// set an empty SCRIPT_NAME
-	wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "SCRIPT_NAME", 11, "", 0);
+	wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "SCRIPT_NAME", 11, "", 0);
 
 	while (ptr < watermark) {
 
@@ -193,29 +193,29 @@ static int uwsgi_mongrel2_tnetstring_parse(struct wsgi_request *wsgi_req, char *
 				if (!uwsgi_strncmp("JSON", 4, val, vallen)) {
 					return -1;
 				}
-				wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_METHOD", 14, val, vallen);
+				wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_METHOD", 14, val, vallen);
 			}
 			else if (!uwsgi_strncmp("VERSION", 7, key, keylen)) {
-				wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PROTOCOL", 15, val, vallen);
+				wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PROTOCOL", 15, val, vallen);
 			}
 			else if (!uwsgi_strncmp("QUERY", 5, key, keylen)) {
-				wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "QUERY_STRING", 12, val, vallen);
+				wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "QUERY_STRING", 12, val, vallen);
 				query_string = val;
 				query_string_len = vallen;
 			}
 			else if (!uwsgi_strncmp("PATH", 4, key, keylen)) {
-				wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "PATH_INFO", 9, val + script_name_len, vallen - script_name_len);
+				wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "PATH_INFO", 9, val + script_name_len, vallen - script_name_len);
 				if (query_string_len) {
 					char *request_uri = uwsgi_concat3n(val, vallen, "?", 1, query_string, query_string_len);
-					wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_URI", 11, request_uri, vallen + 1 + query_string_len);
+					wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_URI", 11, request_uri, vallen + 1 + query_string_len);
 					free(request_uri);
 				}
 				else {
-					wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_URI", 11, val, vallen);
+					wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_URI", 11, val, vallen);
 				}
 			}
 			else if (!uwsgi_strncmp("URL_SCHEME", 10, key, keylen)) {	
-				wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "UWSGI_SCHEME", 12, val, vallen);
+				wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "UWSGI_SCHEME", 12, val, vallen);
 			}
 		}
 		else {
@@ -223,10 +223,10 @@ static int uwsgi_mongrel2_tnetstring_parse(struct wsgi_request *wsgi_req, char *
 			if (!uwsgi_strncmp("host", 4, key, keylen)) {
 				char *colon = memchr(val, ':', vallen);
 				if (colon) {
-					wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, colon + 1, vallen - ((colon + 1) - val));
+					wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, colon + 1, vallen - ((colon + 1) - val));
 				}
 				else {
-					wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, "80", 2);
+					wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, "80", 2);
 				}
 			}
 			else if (!uwsgi_strncmp("content-length", 14, key, keylen)) {
@@ -245,24 +245,24 @@ static int uwsgi_mongrel2_tnetstring_parse(struct wsgi_request *wsgi_req, char *
 			else if (!uwsgi_strncmp("x-forwarded-for", 15, key, keylen)) {
 				char *colon = memchr(val, ',', vallen);
 				if (colon) {
-					wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "REMOTE_ADDR", 11, colon + 1, (colon + 1) - val);
+					wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "REMOTE_ADDR", 11, colon + 1, (colon + 1) - val);
 				}
 				else {
-					wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "REMOTE_ADDR", 11, val, vallen);
+					wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "REMOTE_ADDR", 11, val, vallen);
 				}
 			}
 			else if (!uwsgi_strncmp("x-mongrel2-upload-start", 23, key, keylen)) {
 				async_upload += 1;
 			}
-			wsgi_req->uh->pktsize += proto_base_add_uwsgi_header(wsgi_req, key, keylen, val, vallen);
+			wsgi_req->len += proto_base_add_uwsgi_header(wsgi_req, key, keylen, val, vallen);
 		}
 	}
 
-	wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_NAME", 11, uwsgi.hostname, uwsgi.hostname_len);
+	wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "SERVER_NAME", 11, uwsgi.hostname, uwsgi.hostname_len);
 
 	if (query_string == NULL) {
 		// always set QUERY_STRING
-		wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "QUERY_STRING", 12, "", 0);
+		wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "QUERY_STRING", 12, "", 0);
 	}
 
 	// reject uncomplete upload
diff --git a/plugins/mono/mono_plugin.c b/plugins/mono/mono_plugin.c
index b0c2a131..c1ae15d7 100644
--- a/plugins/mono/mono_plugin.c
+++ b/plugins/mono/mono_plugin.c
@@ -516,7 +516,7 @@ static void uwsgi_mono_init_apps() {
 static int uwsgi_mono_request(struct wsgi_request *wsgi_req) {
 
 	/* Standard ASP.NET request */
-        if (!wsgi_req->uh->pktsize) {
+        if (!wsgi_req->len) {
                 uwsgi_log("Empty Mono/ASP.NET request. skip.\n");
                 return -1;
         }
diff --git a/plugins/nagios/nagios.c b/plugins/nagios/nagios.c
index ee0ac868..200f7833 100644
--- a/plugins/nagios/nagios.c
+++ b/plugins/nagios/nagios.c
@@ -36,7 +36,7 @@ int nagios() {
 	}
 
 	uh.modifier1 = UWSGI_MODIFIER_PING;
-	uh.pktsize = 0;
+	uh._pktsize = 0;
 	uh.modifier2 = 0;
 	if (write(fd, &uh, 4) != 4) {
 		uwsgi_error("write()");
@@ -56,8 +56,8 @@ int nagios() {
 		exit(2);
 	}
 	else {
-		if (uh.pktsize > 0 && buf) {
-			fprintf(stdout, "UWSGI WARNING: %.*s\n", uh.pktsize, buf);
+		if (uh._pktsize > 0 && buf) {
+			fprintf(stdout, "UWSGI WARNING: %.*s\n", uh._pktsize, buf);
 			exit(1);
 		}
 		else {
diff --git a/plugins/ping/ping_plugin.c b/plugins/ping/ping_plugin.c
index 384fa972..c620c723 100644
--- a/plugins/ping/ping_plugin.c
+++ b/plugins/ping/ping_plugin.c
@@ -29,7 +29,7 @@ static void ping() {
 	}
 
 	uh.modifier1 = UWSGI_MODIFIER_PING;
-	uh.pktsize = 0;
+	uh._pktsize = 0;
 	uh.modifier2 = 0;
 
 	if (write(fd, &uh, 4) != 4) {
@@ -42,8 +42,8 @@ static void ping() {
 		exit(1);
 	}
 	else {
-		if (uh.pktsize > 0) {
-			uwsgi_log("[WARNING] node %s message: %.*s\n", uping.ping, uh.pktsize, buf);
+		if (uh._pktsize > 0) {
+			uwsgi_log("[WARNING] node %s message: %.*s\n", uping.ping, uh._pktsize, buf);
 			exit(2);
 		}
 		else {
@@ -70,13 +70,13 @@ int uwsgi_request_ping(struct wsgi_request *wsgi_req) {
 
 	uwsgi_log( "PING\n");
 	wsgi_req->uh->modifier2 = 1;
-	wsgi_req->uh->pktsize = 0;
+	wsgi_req->uh->_pktsize = 0;
 	wsgi_req->do_not_account = 1;
 
 	len = strlen(uwsgi.shared->warning_message);
 	if (len > 0) {
 		// TODO: check endianess ?
-		wsgi_req->uh->pktsize = len;
+		wsgi_req->uh->_pktsize = len;
 	}
 
 	if (uwsgi_response_write_body_do(wsgi_req, (char *) wsgi_req->uh, 4)) {
diff --git a/plugins/psgi/psgi_plugin.c b/plugins/psgi/psgi_plugin.c
index 4fb6de91..02e3c12a 100644
--- a/plugins/psgi/psgi_plugin.c
+++ b/plugins/psgi/psgi_plugin.c
@@ -541,7 +541,7 @@ int uwsgi_perl_request(struct wsgi_request *wsgi_req) {
 	}
 
 	/* Standard PSGI request */
-	if (!wsgi_req->uh->pktsize) {
+	if (!wsgi_req->len) {
 		uwsgi_log("Empty PSGI request. skip.\n");
 		return -1;
 	}
diff --git a/plugins/pty/pty.c b/plugins/pty/pty.c
index 87d4f6bf..a90965d5 100644
--- a/plugins/pty/pty.c
+++ b/plugins/pty/pty.c
@@ -331,7 +331,7 @@ static int uwsgi_pty_client() {
 			if (upty.uremote) {
 				struct uwsgi_header uh;
 				uh.modifier1 = 0;
-				uh.pktsize = rlen;
+				uh._pktsize = rlen;
 				uh.modifier2 = 0;
 				if (write(upty.server_fd, &uh, 4) != 4) break;
 			}
diff --git a/plugins/pypy/pypy_plugin.c b/plugins/pypy/pypy_plugin.c
index a14dddab..8aafd24a 100644
--- a/plugins/pypy/pypy_plugin.c
+++ b/plugins/pypy/pypy_plugin.c
@@ -207,7 +207,7 @@ static void uwsgi_pypy_preinit_apps() {
 
 static int uwsgi_pypy_request(struct wsgi_request *wsgi_req) {
 	/* Standard WSGI request */
-        if (!wsgi_req->uh->pktsize) {
+        if (!wsgi_req->len) {
                 uwsgi_log( "Empty pypy request. skip.\n");
                 return -1;
         }
diff --git a/plugins/python/uwsgi_pymodule.c b/plugins/python/uwsgi_pymodule.c
index a1f70ab6..34f4df88 100644
--- a/plugins/python/uwsgi_pymodule.c
+++ b/plugins/python/uwsgi_pymodule.c
@@ -2339,14 +2339,14 @@ PyObject *py_uwsgi_parse_file(PyObject * self, PyObject * args) {
 		goto clear2;
 	}
 
-	buffer = malloc(uh.pktsize);
+	buffer = malloc(uh._pktsize);
 	if (!buffer) {
 		uwsgi_error("malloc()");
 		UWSGI_GET_GIL
 		goto clear2;
 	}
-	len = read(fd, buffer, uh.pktsize);
-	if (len != uh.pktsize) {
+	len = read(fd, buffer, uh._pktsize);
+	if (len != uh._pktsize) {
 		uwsgi_error("read()");
 		free(buffer);
 		UWSGI_GET_GIL
@@ -2356,7 +2356,7 @@ PyObject *py_uwsgi_parse_file(PyObject * self, PyObject * args) {
 	UWSGI_GET_GIL
 
 	ptrbuf = buffer;
-	bufferend = ptrbuf + uh.pktsize;
+	bufferend = ptrbuf + uh._pktsize;
 
 	if (!uh.modifier1 || uh.modifier1 == UWSGI_MODIFIER_SPOOL_REQUEST) {
 		zero = PyDict_New();
diff --git a/plugins/python/wsgi_handlers.c b/plugins/python/wsgi_handlers.c
index 94a398a1..c9bb2db4 100644
--- a/plugins/python/wsgi_handlers.c
+++ b/plugins/python/wsgi_handlers.c
@@ -326,7 +326,7 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 	}
 
 	/* Standard WSGI request */
-	if (!wsgi_req->uh->pktsize) {
+	if (!wsgi_req->len) {
 		uwsgi_log( "Empty python request. skip.\n");
 		return -1;
 	}
diff --git a/plugins/rack/rack_plugin.c b/plugins/rack/rack_plugin.c
index bab2e2a0..2719db7d 100644
--- a/plugins/rack/rack_plugin.c
+++ b/plugins/rack/rack_plugin.c
@@ -814,7 +814,7 @@ int uwsgi_rack_request(struct wsgi_request *wsgi_req) {
 	}
 
 	/* Standard RACK request */
-        if (!wsgi_req->uh->pktsize) {
+        if (!wsgi_req->len) {
                 uwsgi_log("Empty RACK request. skip.\n");
                 return -1;
         }
diff --git a/plugins/rados/rados.c b/plugins/rados/rados.c
index de6fdfe8..37881bad 100644
--- a/plugins/rados/rados.c
+++ b/plugins/rados/rados.c
@@ -529,7 +529,7 @@ static void uwsgi_rados_setup() {
 
 static int uwsgi_rados_request(struct wsgi_request *wsgi_req) {
 	char filename[PATH_MAX+1];
-	if (!wsgi_req->uh->pktsize) {
+	if (!wsgi_req->len) {
 		uwsgi_log( "Empty request. skip.\n");
 		return -1;
 	}
diff --git a/plugins/router_uwsgi/router_uwsgi.c b/plugins/router_uwsgi/router_uwsgi.c
index 9fca0311..7387c3e6 100644
--- a/plugins/router_uwsgi/router_uwsgi.c
+++ b/plugins/router_uwsgi/router_uwsgi.c
@@ -39,6 +39,11 @@ static int uwsgi_routing_func_uwsgi_remote(struct wsgi_request *wsgi_req, struct
 	char **subject = (char **) (((char *)(wsgi_req))+ur->subject);
         uint16_t *subject_len = (uint16_t *)  (((char *)(wsgi_req))+ur->subject_len);
 
+	// only 64k can be serialized in a uwsgi packet
+	if (wsgi_req->len > 0xffff) {
+		return UWSGI_ROUTE_BREAK;
+	}
+
         struct uwsgi_buffer *ub_addr = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, addr, strlen(addr));
         if (!ub_addr) return UWSGI_ROUTE_BREAK;
 
@@ -52,10 +57,11 @@ static int uwsgi_routing_func_uwsgi_remote(struct wsgi_request *wsgi_req, struct
 
 	size_t remains = wsgi_req->post_cl - wsgi_req->proto_parser_remains;
 
-	struct uwsgi_buffer *ub = uwsgi_buffer_new(4 + wsgi_req->uh->pktsize + wsgi_req->proto_parser_remains);
-	uh->pktsize = wsgi_req->uh->pktsize;
+
+	struct uwsgi_buffer *ub = uwsgi_buffer_new(4 + wsgi_req->len + wsgi_req->proto_parser_remains);
+	uh->_pktsize = wsgi_req->len;
 	if (uwsgi_buffer_append(ub, (char *) uh, 4)) goto end;
-	if (uwsgi_buffer_append(ub, wsgi_req->buffer, wsgi_req->uh->pktsize)) goto end;
+	if (uwsgi_buffer_append(ub, wsgi_req->buffer, wsgi_req->len)) goto end;
 	if (wsgi_req->proto_parser_remains > 0) {
                 if (uwsgi_buffer_append(ub, wsgi_req->proto_parser_remains_buf, wsgi_req->proto_parser_remains)) {
 			goto end;
diff --git a/plugins/rpc/rpc_plugin.c b/plugins/rpc/rpc_plugin.c
index ed8a0f2d..b8a14a21 100644
--- a/plugins/rpc/rpc_plugin.c
+++ b/plugins/rpc/rpc_plugin.c
@@ -142,7 +142,7 @@ static int uwsgi_rpc_request(struct wsgi_request *wsgi_req) {
 	size_t content_len = 0;
 
 	/* Standard RPC request */
-        if (!wsgi_req->uh->pktsize) {
+        if (!wsgi_req->len) {
                 uwsgi_log("Empty RPC request. skip.\n");
                 return -1;
         }
@@ -226,7 +226,7 @@ static int uwsgi_rpc_request(struct wsgi_request *wsgi_req) {
 	}
 #endif
 
-	if (uwsgi_parse_array(wsgi_req->buffer, wsgi_req->uh->pktsize, argv, argvs, &argc)) {
+	if (uwsgi_parse_array(wsgi_req->buffer, wsgi_req->uh->_pktsize, argv, argvs, &argc)) {
                 uwsgi_log("Invalid RPC request. skip.\n");
                 return -1;
 	}
@@ -247,7 +247,7 @@ static int uwsgi_rpc_request(struct wsgi_request *wsgi_req) {
 				return -1;	
 			}
 			// fix uwsgi header
-			wsgi_req->uh->pktsize = ub->pos;
+			wsgi_req->uh->_pktsize = ub->pos;
 			if (uwsgi_response_write_body_do(wsgi_req, (char *) wsgi_req->uh, 4)) {
 				uwsgi_buffer_destroy(ub);
 				free(response_buf);	
@@ -261,7 +261,7 @@ static int uwsgi_rpc_request(struct wsgi_request *wsgi_req) {
 			uwsgi_buffer_destroy(ub);
 		}
 		else {
-			wsgi_req->uh->pktsize = content_len;
+			wsgi_req->uh->_pktsize = content_len;
 			if (uwsgi_response_write_body_do(wsgi_req, (char *) wsgi_req->uh, 4)) {
 				free(response_buf);	
 				return -1;
diff --git a/plugins/signal/signal_plugin.c b/plugins/signal/signal_plugin.c
index 15a7ae59..a22a855e 100644
--- a/plugins/signal/signal_plugin.c
+++ b/plugins/signal/signal_plugin.c
@@ -13,7 +13,7 @@ int uwsgi_request_signal(struct wsgi_request *wsgi_req) {
 	}
 
         uh.modifier1 = 255;
-       	uh.pktsize = 0;
+       	uh._pktsize = 0;
        	uh.modifier2 = ret_status;
 	
 	if (uwsgi_response_write_body_do(wsgi_req, (char *) &uh, 4)) {
diff --git a/plugins/spooler/spooler_plugin.c b/plugins/spooler/spooler_plugin.c
index 3caa2aac..3ec95760 100644
--- a/plugins/spooler/spooler_plugin.c
+++ b/plugins/spooler/spooler_plugin.c
@@ -17,15 +17,15 @@ int uwsgi_request_spooler(struct wsgi_request *wsgi_req) {
         if (uwsgi.spoolers == NULL) {
                 uwsgi_log("the spooler is inactive !!!...skip\n");
 		uh.modifier1 = 255;
-		uh.pktsize = 0;
+		uh._pktsize = 0;
 		uh.modifier2 = 0;
 		uwsgi_response_write_body_do(wsgi_req, (char *) &uh, 4);
                 return -1;
         }
 
-        char *filename = uwsgi_spool_request(NULL, wsgi_req->buffer, wsgi_req->uh->pktsize, NULL, 0);
+        char *filename = uwsgi_spool_request(NULL, wsgi_req->buffer, wsgi_req->uh->_pktsize, NULL, 0);
         uh.modifier1 = 255;
-        uh.pktsize = 0;
+        uh._pktsize = 0;
         if (filename) {
                 uh.modifier2 = 1;
 		if (uwsgi_response_write_body_do(wsgi_req, (char *) &uh, 4)) {
diff --git a/plugins/v8/v8_jsgi.cc b/plugins/v8/v8_jsgi.cc
index dd9ce9be..491f06cd 100644
--- a/plugins/v8/v8_jsgi.cc
+++ b/plugins/v8/v8_jsgi.cc
@@ -62,7 +62,7 @@ extern "C" int uwsgi_v8_request(struct wsgi_request *wsgi_req) {
 	v8::Handle<v8::Function> forEach;
 
 	/* Standard JSGI 3.0 request */
-        if (!wsgi_req->uh->pktsize) {
+        if (!wsgi_req->len) {
                 uwsgi_log( "Empty JSGI request. skip.\n");
                 return -1;
         }
diff --git a/proto/base.c b/proto/base.c
index 0702aaac..d48e7c9d 100644
--- a/proto/base.c
+++ b/proto/base.c
@@ -9,11 +9,11 @@ int uwsgi_proto_raw_parser(struct wsgi_request *wsgi_req) {
 	return UWSGI_OK;
 }
 
-uint16_t proto_base_add_uwsgi_header(struct wsgi_request *wsgi_req, char *key, uint16_t keylen, char *val, uint16_t vallen) {
+uint64_t proto_base_add_uwsgi_header(struct wsgi_request *wsgi_req, char *key, uint16_t keylen, char *val, uint16_t vallen) {
 
 
 	int i;
-	char *buffer = wsgi_req->buffer + wsgi_req->uh->pktsize;
+	char *buffer = wsgi_req->buffer + wsgi_req->len;
 	char *watermark = wsgi_req->buffer + uwsgi.buffer_size;
 	char *ptr = buffer;
 
@@ -64,10 +64,10 @@ uint16_t proto_base_add_uwsgi_header(struct wsgi_request *wsgi_req, char *key, u
 
 
 
-uint16_t proto_base_add_uwsgi_var(struct wsgi_request * wsgi_req, char *key, uint16_t keylen, char *val, uint16_t vallen) {
+uint64_t proto_base_add_uwsgi_var(struct wsgi_request * wsgi_req, char *key, uint16_t keylen, char *val, uint16_t vallen) {
 
 
-	char *buffer = wsgi_req->buffer + wsgi_req->uh->pktsize;
+	char *buffer = wsgi_req->buffer + wsgi_req->len;
 	char *watermark = wsgi_req->buffer + uwsgi.buffer_size;
 	char *ptr = buffer;
 
diff --git a/proto/fastcgi.c b/proto/fastcgi.c
index 647b98c2..2a0b246c 100644
--- a/proto/fastcgi.c
+++ b/proto/fastcgi.c
@@ -60,7 +60,7 @@ int fastcgi_to_uwsgi(struct wsgi_request *wsgi_req, char *buf, size_t len) {
 		uint16_t pktsize = proto_base_add_uwsgi_var(wsgi_req, buf + j, keylen, buf + j + keylen, vallen);
 		if (pktsize == 0)
 			return -1;
-		wsgi_req->uh->pktsize += pktsize;
+		wsgi_req->len += pktsize;
 		// -1 here as the for() will increment j again
 		j += (keylen + vallen) - 1;
 	}
diff --git a/proto/http.c b/proto/http.c
index 349185b4..373e8785 100644
--- a/proto/http.c
+++ b/proto/http.c
@@ -38,9 +38,9 @@ static char * http_header_to_cgi(char *hh, size_t hhlen, size_t *keylen, size_t
 	return val;
 }
 
-static uint16_t http_add_uwsgi_header(struct wsgi_request *wsgi_req, char *hh, size_t hhlen, char *hv, size_t hvlen, int has_prefix) {
+static uint64_t http_add_uwsgi_header(struct wsgi_request *wsgi_req, char *hh, size_t hhlen, char *hv, size_t hvlen, int has_prefix) {
 
-	char *buffer = wsgi_req->buffer + wsgi_req->uh->pktsize;
+	char *buffer = wsgi_req->buffer + wsgi_req->len;
 	char *watermark = wsgi_req->buffer + uwsgi.buffer_size;
 	char *ptr = buffer;
 	size_t keylen = hhlen;
@@ -48,11 +48,16 @@ static uint16_t http_add_uwsgi_header(struct wsgi_request *wsgi_req, char *hh, s
 	if (has_prefix) keylen += 5;
 
 	if (buffer + keylen + hvlen + 2 + 2 >= watermark) {
-		if (has_prefix) {
-			uwsgi_log("[WARNING] unable to add HTTP_%.*s=%.*s to uwsgi packet, consider increasing buffer size\n", keylen, hh, hvlen, hv);
+		if (keylen <= 0xff && hvlen <= 0xff) {
+			if (has_prefix) {
+				uwsgi_log("[WARNING] unable to add HTTP_%.*s=%.*s to uwsgi packet, consider increasing buffer size\n", keylen, hh, hvlen, hv);
+			}
+			else {
+				uwsgi_log("[WARNING] unable to add %.*s=%.*s to uwsgi packet, consider increasing buffer size\n", keylen, hh, hvlen, hv);
+			}
 		}
 		else {
-			uwsgi_log("[WARNING] unable to add %.*s=%.*s to uwsgi packet, consider increasing buffer size\n", keylen, hh, hvlen, hv);
+			uwsgi_log("[WARNING] unable to build uwsgi packet from http request, consider increasing buffer size\n");
 		}
 		return 0;
 	}
@@ -194,7 +199,7 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 	// REQUEST_METHOD 
 	while (ptr < watermark) {
 		if (*ptr == ' ') {
-			wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_METHOD", 14, base, ptr - base);
+			wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_METHOD", 14, base, ptr - base);
 			ptr++;
 			break;
 		}
@@ -206,10 +211,11 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 	while (ptr < watermark) {
 		if (*ptr == '?' && !query_string) {
 			if (watermark + (ptr - base) < (char *)(wsgi_req->proto_parser_buf + uwsgi.buffer_size)) {
+				if (ptr - base > 0xffff) return -1;
 				uint16_t path_info_len = ptr - base;
 				char *path_info = uwsgi_malloc(path_info_len);
 				http_url_decode(base, &path_info_len, path_info);
-				wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "PATH_INFO", 9, path_info, path_info_len);
+				wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "PATH_INFO", 9, path_info, path_info_len);
 				free(path_info);
 			}
 			else {
@@ -219,24 +225,25 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 			query_string = ptr + 1;
 		}
 		else if (*ptr == ' ') {
-			wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_URI", 11, base, ptr - base);
+			wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_URI", 11, base, ptr - base);
 			
 			if (!query_string) {
 				if (watermark + (ptr - base) < (char *)(wsgi_req->proto_parser_buf + uwsgi.buffer_size)) {
+					if (ptr - base > 0xffff) return -1;
                                 	uint16_t path_info_len = ptr - base;
 					char *path_info = uwsgi_malloc(path_info_len);
                                 	http_url_decode(base, &path_info_len, path_info);
-                                	wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "PATH_INFO", 9, path_info, path_info_len);
+                                	wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "PATH_INFO", 9, path_info, path_info_len);
 					free(path_info);
                         	}
 				else {
 					uwsgi_log("not enough space in wsgi_req http proto_parser_buf to decode PATH_INFO, consider tuning it with --buffer-size\n");
 					return -1;
 				}
-				wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "QUERY_STRING", 12, "", 0);
+				wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "QUERY_STRING", 12, "", 0);
 			}
 			else {
-				wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "QUERY_STRING", 12, query_string, ptr - query_string);
+				wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "QUERY_STRING", 12, query_string, ptr - query_string);
 			}
 			ptr++;
 			break;
@@ -252,7 +259,8 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 				return -1 ;
 			if (*(ptr + 1) != '\n')
 				return -1;
-			wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PROTOCOL", 15, base, ptr - base);
+			if (ptr - base > 0xffff) return -1;
+			wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PROTOCOL", 15, base, ptr - base);
 			ptr += 2;
 			break;
 		}
@@ -261,42 +269,42 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 
 	// SCRIPT_NAME
 	if (!uwsgi.manage_script_name) {
-		wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "SCRIPT_NAME", 11, "", 0);
+		wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "SCRIPT_NAME", 11, "", 0);
 	}
 	
 
 	// SERVER_NAME
-	wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_NAME", 11, uwsgi.hostname, uwsgi.hostname_len);
+	wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "SERVER_NAME", 11, uwsgi.hostname, uwsgi.hostname_len);
 
 	// SERVER_PORT / SERVER_ADDR
 	if (proxy_dst) {
-		wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_ADDR", 11, proxy_dst, proxy_dst_len);
+		wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "SERVER_ADDR", 11, proxy_dst, proxy_dst_len);
                 if (proxy_dst_port) {
-                        wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, proxy_dst_port, proxy_dst_port_len);
+                        wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, proxy_dst_port, proxy_dst_port_len);
                 }
 	}
 	else {
 		char *server_port = strchr(wsgi_req->socket->name, ':');
 		if (server_port) {
-			wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, server_port+1, strlen(server_port+1));
+			wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, server_port+1, strlen(server_port+1));
 		}
 		else {
-			wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, "80", 2);
+			wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, "80", 2);
 		}
 	}
 
 	// REMOTE_ADDR
 	if (proxy_src) {
-		wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "REMOTE_ADDR", 11, proxy_src, proxy_src_len);
+		wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "REMOTE_ADDR", 11, proxy_src, proxy_src_len);
 		if (proxy_src_port) {
-			wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "REMOTE_PORT", 11, proxy_src_port, proxy_src_port_len);
+			wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "REMOTE_PORT", 11, proxy_src_port, proxy_src_port_len);
 		}
 	}
 	else {
 		// TODO add ipv6 support
 		memset(ip, 0, INET_ADDRSTRLEN+1);
 		if (inet_ntop(AF_INET, (void *) &http_sin->sin_addr.s_addr, ip, INET_ADDRSTRLEN)) {
-			wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "REMOTE_ADDR", 11, ip, strlen(ip));
+			wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "REMOTE_ADDR", 11, ip, strlen(ip));
 		}
 		else {
 			uwsgi_error("inet_ntop()");
@@ -305,7 +313,7 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 	}
 
 	if (wsgi_req->https_len > 0) {
-		wsgi_req->uh->pktsize += proto_base_add_uwsgi_var(wsgi_req, "HTTPS", 5, wsgi_req->https, wsgi_req->https_len);
+		wsgi_req->len += proto_base_add_uwsgi_var(wsgi_req, "HTTPS", 5, wsgi_req->https, wsgi_req->https_len);
 	}
 
 	//HEADERS
@@ -330,6 +338,7 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 			int has_prefix = 0;
 			// last line, do not waste time
 			if (ptr - base == 0) break;
+			if (ptr - base > 0xffff) return -1;
 			char *value = http_header_to_cgi(base, ptr - base, &key_len, &value_len, &has_prefix);
 			if (!value) {
 				uwsgi_log_verbose("invalid HTTP request\n");
@@ -363,10 +372,10 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 	int broken = 0;
 	while(usl) {
 		if (!broken) {
-			uint16_t old_pktsize = wsgi_req->uh->pktsize;
-			wsgi_req->uh->pktsize += http_add_uwsgi_header(wsgi_req, usl->value, usl->len, usl->custom_ptr, (size_t) usl->custom, usl->custom2 & 0x02);
+			uint64_t old_len = wsgi_req->len;
+			wsgi_req->len += http_add_uwsgi_header(wsgi_req, usl->value, usl->len, usl->custom_ptr, (size_t) usl->custom, usl->custom2 & 0x02);
 			// if the packet remains unchanged, the buffer is full, mark the request as broken
-			if (old_pktsize == wsgi_req->uh->pktsize) {
+			if (old_len == wsgi_req->len) {
 				broken = 1;
 			}
 		}
diff --git a/proto/puwsgi.c b/proto/puwsgi.c
index 72840bea..0a9fb081 100644
--- a/proto/puwsgi.c
+++ b/proto/puwsgi.c
@@ -22,10 +22,11 @@ int uwsgi_proto_puwsgi_parser(struct wsgi_request *wsgi_req) {
 			wsgi_req->proto_parser_pos += len;
 			if (wsgi_req->proto_parser_pos == 4) {
 #ifdef __BIG_ENDIAN__
-                        	wsgi_req->uh->pktsize = uwsgi_swap16(wsgi_req->uh->pktsize);
+                        	wsgi_req->len = uwsgi_swap16(wsgi_req->len);
 #endif
-				if (wsgi_req->uh->pktsize > uwsgi.buffer_size) {
-                                	uwsgi_log("invalid request block size: %u (max %u)...skip\n", wsgi_req->uh->pktsize, uwsgi.buffer_size);
+				wsgi_req->len = wsgi_req->len;
+				if (wsgi_req->len > uwsgi.buffer_size) {
+                                	uwsgi_log("invalid request block size: %u (max %u)...skip\n", wsgi_req->len, uwsgi.buffer_size);
 					wsgi_req->write_errors++;		
                                 	return -1;
                         	}
@@ -34,10 +35,10 @@ int uwsgi_proto_puwsgi_parser(struct wsgi_request *wsgi_req) {
 		}
 		goto negative;
 	}
-	len = read(wsgi_req->fd, ptr + wsgi_req->proto_parser_pos, wsgi_req->uh->pktsize - (wsgi_req->proto_parser_pos-4));
+	len = read(wsgi_req->fd, ptr + wsgi_req->proto_parser_pos, wsgi_req->len - (wsgi_req->proto_parser_pos-4));
 	if (len > 0) {
 		wsgi_req->proto_parser_pos += len;
-		if ((wsgi_req->proto_parser_pos-4) == wsgi_req->uh->pktsize) {
+		if ((wsgi_req->proto_parser_pos-4) == wsgi_req->len) {
 			return UWSGI_OK;	
 		}
 		return UWSGI_AGAIN;
@@ -64,7 +65,7 @@ close the connection on errors, otherwise force edge triggering
 */
 void uwsgi_proto_puwsgi_close(struct wsgi_request *wsgi_req) {
 	// check for errors or incomplete packets
-	if (wsgi_req->write_errors || (size_t) (wsgi_req->uh->pktsize + 4) != wsgi_req->proto_parser_pos) {
+	if (wsgi_req->write_errors || (size_t) (wsgi_req->len + 4) != wsgi_req->proto_parser_pos) {
 		close(wsgi_req->fd);
 		wsgi_req->socket->retry[wsgi_req->async_id] = 0;
 		wsgi_req->socket->fd_threads[wsgi_req->async_id] = -1;
diff --git a/proto/scgi.c b/proto/scgi.c
index a5afec4a..707fe3e5 100644
--- a/proto/scgi.c
+++ b/proto/scgi.c
@@ -43,7 +43,7 @@ keyval:
 				vallen = (buf+i) - value;
 				uint16_t pktsize = proto_base_add_uwsgi_var(wsgi_req, key, keylen, value, vallen);
                 		if (pktsize == 0) return -1;
-                		wsgi_req->uh->pktsize += pktsize;
+                		wsgi_req->len += pktsize;
 				key = NULL;
 				value = NULL;
 				keylen = 0;
diff --git a/proto/uwsgi.c b/proto/uwsgi.c
index 07f3aaa1..e07f7a09 100644
--- a/proto/uwsgi.c
+++ b/proto/uwsgi.c
@@ -11,18 +11,19 @@ static int uwsgi_proto_uwsgi_parser(struct wsgi_request *wsgi_req) {
 		wsgi_req->proto_parser_pos += len;
 		if (wsgi_req->proto_parser_pos >= 4) {
 #ifdef __BIG_ENDIAN__
-			wsgi_req->uh->pktsize = uwsgi_swap16(wsgi_req->uh->pktsize);
+			wsgi_req->uh->_pktsize = uwsgi_swap16(wsgi_req->uh->_pktsize);
 #endif
-			if ((wsgi_req->proto_parser_pos - 4) == wsgi_req->uh->pktsize) {
+			wsgi_req->len = wsgi_req->uh->_pktsize;
+			if ((wsgi_req->proto_parser_pos - 4) == wsgi_req->uh->_pktsize) {
 				return UWSGI_OK;
 			}
-			if ((wsgi_req->proto_parser_pos - 4) > wsgi_req->uh->pktsize) {
-				wsgi_req->proto_parser_remains = wsgi_req->proto_parser_pos - (4 + wsgi_req->uh->pktsize);
-				wsgi_req->proto_parser_remains_buf = wsgi_req->buffer + wsgi_req->uh->pktsize;
+			if ((wsgi_req->proto_parser_pos - 4) > wsgi_req->uh->_pktsize) {
+				wsgi_req->proto_parser_remains = wsgi_req->proto_parser_pos - (4 + wsgi_req->uh->_pktsize);
+				wsgi_req->proto_parser_remains_buf = wsgi_req->buffer + wsgi_req->uh->_pktsize;
 				return UWSGI_OK;
 			}
-			if (wsgi_req->uh->pktsize > uwsgi.buffer_size) {
-				uwsgi_log("invalid request block size: %u (max %u)...skip\n", wsgi_req->uh->pktsize, uwsgi.buffer_size);
+			if (wsgi_req->uh->_pktsize > uwsgi.buffer_size) {
+				uwsgi_log("invalid request block size: %u (max %u)...skip\n", wsgi_req->uh->_pktsize, uwsgi.buffer_size);
 				return -1;
 			}
 		}
@@ -52,18 +53,18 @@ retry:
                 wsgi_req->proto_parser_pos += len;
                 if (wsgi_req->proto_parser_pos >= 4) {
 #ifdef __BIG_ENDIAN__
-                        wsgi_req->uh->pktsize = uwsgi_swap16(wsgi_req->uh->pktsize);
+                        wsgi_req->uh->_pktsize = uwsgi_swap16(wsgi_req->uh->_pktsize);
 #endif
-                        if ((wsgi_req->proto_parser_pos - 4) == wsgi_req->uh->pktsize) {
+                        if ((wsgi_req->proto_parser_pos - 4) == wsgi_req->uh->_pktsize) {
                                 return UWSGI_OK;
                         }
-                        if ((wsgi_req->proto_parser_pos - 4) > wsgi_req->uh->pktsize) {
-                                wsgi_req->proto_parser_remains = wsgi_req->proto_parser_pos - (4 + wsgi_req->uh->pktsize);
-                                wsgi_req->proto_parser_remains_buf = wsgi_req->buffer + wsgi_req->uh->pktsize;
+                        if ((wsgi_req->proto_parser_pos - 4) > wsgi_req->uh->_pktsize) {
+                                wsgi_req->proto_parser_remains = wsgi_req->proto_parser_pos - (4 + wsgi_req->uh->_pktsize);
+                                wsgi_req->proto_parser_remains_buf = wsgi_req->buffer + wsgi_req->uh->_pktsize;
                                 return UWSGI_OK;
                         }
-                        if (wsgi_req->uh->pktsize > uwsgi.buffer_size) {
-                                uwsgi_log("invalid request block size: %u (max %u)...skip\n", wsgi_req->uh->pktsize, uwsgi.buffer_size);
+                        if (wsgi_req->uh->_pktsize > uwsgi.buffer_size) {
+                                uwsgi_log("invalid request block size: %u (max %u)...skip\n", wsgi_req->uh->_pktsize, uwsgi.buffer_size);
                                 return -1;
                         }
                 }
@@ -144,18 +145,18 @@ int uwsgi_proto_uwsgi_parser_unix(struct wsgi_request *wsgi_req) {
 			wsgi_req->proto_parser_status = PROTO_STATUS_RECV_VARS;
 			wsgi_req->proto_parser_pos = 0;
 #ifdef __BIG_ENDIAN__
-			wsgi_req->uh->pktsize = uwsgi_swap16(wsgi_req->uh->pktsize);
+			wsgi_req->uh->_pktsize = uwsgi_swap16(wsgi_req->uh->_pktsize);
 #endif
 
 #ifdef UWSGI_DEBUG
-			uwsgi_debug("uwsgi payload size: %d (0x%X) modifier1: %d modifier2: %d\n", wsgi_req->uh.pktsize, wsgi_req->uh.pktsize, wsgi_req->uh.modifier1, wsgi_req->uh.modifier2);
+			uwsgi_debug("uwsgi payload size: %d (0x%X) modifier1: %d modifier2: %d\n", wsgi_req->uh._pktsize, wsgi_req->uh._pktsize, wsgi_req->uh.modifier1, wsgi_req->uh.modifier2);
 #endif
 
-			if (wsgi_req->uh->pktsize > uwsgi.buffer_size) {
+			if (wsgi_req->uh->_pktsize > uwsgi.buffer_size) {
 				return -1;
 			}
 
-			if (!wsgi_req->uh->pktsize)
+			if (!wsgi_req->uh->_pktsize)
 				return UWSGI_OK;
 
 		}
@@ -163,7 +164,7 @@ int uwsgi_proto_uwsgi_parser_unix(struct wsgi_request *wsgi_req) {
 	}
 
 	else if (wsgi_req->proto_parser_status == PROTO_STATUS_RECV_VARS) {
-		len = read(wsgi_req->fd, wsgi_req->buffer + wsgi_req->proto_parser_pos, wsgi_req->uh->pktsize - wsgi_req->proto_parser_pos);
+		len = read(wsgi_req->fd, wsgi_req->buffer + wsgi_req->proto_parser_pos, wsgi_req->uh->_pktsize - wsgi_req->proto_parser_pos);
 		if (len <= 0) {
 			uwsgi_error("read()");
 			return -1;
@@ -171,7 +172,7 @@ int uwsgi_proto_uwsgi_parser_unix(struct wsgi_request *wsgi_req) {
 		wsgi_req->proto_parser_pos += len;
 
 		// body ready ?
-		if (wsgi_req->proto_parser_pos >= wsgi_req->uh->pktsize) {
+		if (wsgi_req->proto_parser_pos >= wsgi_req->uh->_pktsize) {
 
 			// older OSX versions make mess with CMSG_FIRSTHDR
 #ifdef __APPLE__
diff --git a/uwsgi.h b/uwsgi.h
index e01e2319..38abcecc 100644
--- a/uwsgi.h
+++ b/uwsgi.h
@@ -1281,7 +1281,7 @@ struct uwsgi_alarm_log {
 
 struct __attribute__ ((packed)) uwsgi_header {
 	uint8_t modifier1;
-	uint16_t pktsize;
+	uint16_t _pktsize;
 	uint8_t modifier2;
 };
 
@@ -1582,6 +1582,9 @@ struct wsgi_request {
 	int do_not_account_avg_rt;
 	// used for protocol parsers requiring EOF signaling
 	int proto_parser_eof;
+
+	// uWSGI 2.1
+	uint64_t len;
 };
 
 
@@ -2371,7 +2374,8 @@ struct uwsgi_server {
 
 	int udp_fd;
 
-	uint16_t buffer_size;
+	// removed in 2.1, here for ABI compatibility
+	uint16_t __buffer_size;
 	int signal_bufsize;
 
 	// post buffering
@@ -2763,6 +2767,7 @@ struct uwsgi_server {
 	struct uwsgi_string_list *hook_as_on_config_vassal;
 	int async_warn_if_queue_full;
 	char *zeus;
+	uint64_t buffer_size;
 };
 
 struct uwsgi_rpc {
@@ -3451,8 +3456,8 @@ void uwsgi_proto_base_close(struct wsgi_request *);
 int uwsgi_proto_ssl_accept(struct wsgi_request *, int);
 void uwsgi_proto_ssl_close(struct wsgi_request *);
 #endif
-uint16_t proto_base_add_uwsgi_header(struct wsgi_request *, char *, uint16_t, char *, uint16_t);
-uint16_t proto_base_add_uwsgi_var(struct wsgi_request *, char *, uint16_t, char *, uint16_t);
+uint64_t proto_base_add_uwsgi_header(struct wsgi_request *, char *, uint16_t, char *, uint16_t);
+uint64_t proto_base_add_uwsgi_var(struct wsgi_request *, char *, uint16_t, char *, uint16_t);
 
 // protocols
 void uwsgi_proto_uwsgi_setup(struct uwsgi_socket *);