diff --git a/libwebsockets.c b/libwebsockets.c
index 6f2e03b..5b2628d 100644
--- a/libwebsockets.c
+++ b/libwebsockets.c
@@ -23,6 +23,30 @@
 #define LWS_ADDITIONAL_HDR_ALLOC 64
 
 
+/*
+ * Chrome (v0)
+ * 
+ * GET / HTTP/1.1
+ * Upgrade: WebSocket
+ * Connection: Upgrade
+ * Host: 127.0.0.1:7681
+ * Origin: null
+ * Sec-WebSocket-Key1: +46 3      1 75 7Y 60
+ * Sec-WebSocket-Key2: m^+J358s0 6N 6e0 Q1 0  ~4~
+ *
+ * Firefox (v76)
+ *
+ * GET / HTTP/1.1
+ * Upgrade: WebSocket
+ * Host: 127.0.0.1:7681
+ * Connection: Upgrade
+ * Sec-WebSocket-Key1: EC."/$14 7 687YG+gZ 44d 16
+ * Origin: file://
+ * Sec-WebSocket-Key2: 2  /  9 0. 4 B8 77|ov968
+ *
+ */
+
+
 enum lws_connection_states {
 	WSI_STATE_CLOSED,
 	WSI_STATE_HANDSHAKE_RX,
@@ -50,6 +74,15 @@
 	WSI_PARSING_COMPLETE
 };
 
+enum lws_rx_parse_state {
+	LWS_RXPS_NEW,
+	
+	LWS_RXPS_SEEN_76_FF,
+	LWS_RXPS_PULLING_76_LENGTH,
+	
+	LWS_RXPS_PAYLOAD_UNTIL_LENGTH_EXHAUSTED
+};
+
 
 struct lws_tokens {
 	char * token;
@@ -64,7 +97,7 @@
 
 struct libwebsocket {
 	int (*callback)(struct libwebsocket *,
-				     enum libwebsocket_callback_reasons reason);
+		enum libwebsocket_callback_reasons reason, void *, size_t);
 
 	enum lws_connection_states state;
 
@@ -76,6 +109,9 @@
 	int ietf_spec_revision;
 	
 	int sock;
+
+	enum lws_rx_parse_state lws_rx_parse_state;
+	size_t rx_packet_length;
 };
 
 
@@ -91,7 +127,8 @@
 	{ "\x0d\x0a", 2 },
 };
 
-int libwebsocket_create_server(int port, int (*callback)(struct libwebsocket *, enum libwebsocket_callback_reasons))
+
+int libwebsocket_create_server(int port, int (*callback)(struct libwebsocket *, enum libwebsocket_callback_reasons, void *, size_t))
 {
 	int n;
 	int sockfd, newsockfd;
@@ -112,7 +149,8 @@
 	}
 	
 	wsi->callback = callback;
-	wsi->ietf_spec_revision = 0;
+//	wsi->ietf_spec_revision = 0;
+ 	wsi->ietf_spec_revision = 76;
  
 	/* sit there listening for connects, accept and spawn session servers */
  
@@ -187,7 +225,7 @@
 	wsi->state = WSI_STATE_DEAD_SOCKET;
 
 	if (wsi->callback)
-		wsi->callback(wsi, LWS_CALLBACK_CLOSED);
+		wsi->callback(wsi, LWS_CALLBACK_CLOSED, NULL, 0);
 
 	for (n = 0; n < WSI_TOKEN_COUNT; n++)
 		if (wsi->utf8_token[n].token)
@@ -226,13 +264,14 @@
 		}
 
 		/* allocate appropriate memory */
-		if (wsi->utf8_token[wsi->parser_state].token_len == wsi->current_alloc_len - 1) {
+		if (wsi->utf8_token[wsi->parser_state].token_len ==
+						   wsi->current_alloc_len - 1) {
 			/* need to extend */
 			wsi->current_alloc_len += LWS_ADDITIONAL_HDR_ALLOC;
 			if (wsi->current_alloc_len >= LWS_MAX_HEADER_LEN) {
 				/* it's waaay to much payload, fail it */
 				strcpy(wsi->utf8_token[wsi->parser_state].token,
-				    "!!! Length exceeded maximum supported !!!");
+				   "!!! Length exceeded maximum supported !!!");
 				wsi->parser_state = WSI_TOKEN_SKIPPING;
 				break;
 			}
@@ -349,6 +388,76 @@
 	return 0;
 }
 
+static int libwebsocket_rx_sm(struct libwebsocket *wsi, unsigned char c)
+{
+	int n;
+	unsigned char buf[2];
+
+	switch (wsi->lws_rx_parse_state) {
+	case LWS_RXPS_NEW:
+	
+		switch (wsi->ietf_spec_revision) {
+		/* Firefox 4.0b6 likes this as of 30 Oct */
+		case 76:
+			if (c == 0xff)
+				wsi->lws_rx_parse_state = LWS_RXPS_SEEN_76_FF;
+			break;
+		case 0:
+			break;
+		}
+		break;
+	case LWS_RXPS_SEEN_76_FF:
+		if (c != 0) {
+			break;
+		}
+
+		fprintf(stderr, "Seen that client is requesting a v76 close, sending ack\n");
+		buf[0] = 0xff;
+		buf[1] = 0;
+		n = write(wsi->sock, buf, 2);
+		if (n < 0) {
+			fprintf(stderr, "ERROR writing to socket");
+			return -1;
+		}
+		fprintf(stderr, "  v76 close ack sent, server closing socket\n");
+		/* returning < 0 will get it closed in parent */
+		return -1;
+
+	case LWS_RXPS_PULLING_76_LENGTH:
+		break;
+	case LWS_RXPS_PAYLOAD_UNTIL_LENGTH_EXHAUSTED:
+		break;
+	}
+
+	return 0;
+}
+
+static int libwebsocket_interpret_incoming_packet(struct libwebsocket *wsi,
+						 unsigned char *buf, size_t len)
+{
+	int n;
+
+	fprintf(stderr, "received %d byte packet\n", (int)len);
+	for (n = 0; n < len; n++)
+		fprintf(stderr, "%02X ", buf[n]);
+	fprintf(stderr, "\n");
+
+	/* let the rx protocol state machine have as much as it needs */
+	
+	n = 0;
+	while (wsi->lws_rx_parse_state !=
+			     LWS_RXPS_PAYLOAD_UNTIL_LENGTH_EXHAUSTED && n < len)
+		if (libwebsocket_rx_sm(wsi, buf[n++]) < 0)
+			return -1;
+		
+	if (n != len) {
+		if (wsi->callback)
+			wsi->callback(wsi, LWS_CALLBACK_RECEIVE, &buf[n], len - n);
+	}
+	
+	return -0;
+}
+
 
 /*
  * We have to take care about parsing because the headers may be split
@@ -372,8 +481,7 @@
 		/* fallthru */
 	case WSI_STATE_HANDSHAKE_RX:
 	
-		fprintf(stderr, "issuing %ld bytes to parser\n", len);
-	
+		fprintf(stderr, "issuing %d bytes to parser\n", (int)len);
 	
 		fwrite(buf, 1, len, stderr);
 		for (n = 0; n< len; n++)
@@ -402,6 +510,8 @@
 		
 		/* create the response packet */
 		
+		/* make a buffer big enough for everything */
+		
 		response = malloc(256 +
 			wsi->utf8_token[WSI_TOKEN_UPGRADE].token_len +
 			wsi->utf8_token[WSI_TOKEN_CONNECTION].token_len +
@@ -409,13 +519,16 @@
 			wsi->utf8_token[WSI_TOKEN_ORIGIN].token_len +
 			wsi->utf8_token[WSI_TOKEN_GET_URI].token_len +
 			wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len);
-		
-		
-		fprintf(stderr, "'%s;\n", wsi->utf8_token[WSI_TOKEN_HOST].token);
+		if (!response) {
+			fprintf(stderr, "Out of memory for response buffer\n");
+			goto bail;
+		}
 		
 		p = response;
-		strcpy(p,   "HTTP/1.1 101 WebSocket Protocol Handshake\x0d\x0aUpgrade: WebSocket\x0d\x0a");
-		p += strlen("HTTP/1.1 101 WebSocket Protocol Handshake\x0d\x0aUpgrade: WebSocket\x0d\x0a");
+		strcpy(p,   "HTTP/1.1 101 WebSocket Protocol Handshake\x0d\x0a"
+						  "Upgrade: WebSocket\x0d\x0a");
+		p += strlen("HTTP/1.1 101 WebSocket Protocol Handshake\x0d\x0a"
+						  "Upgrade: WebSocket\x0d\x0a");
 		strcpy(p,   "Connection: Upgrade\x0d\x0aSec-WebSocket-Origin: ");
 		p += strlen("Connection: Upgrade\x0d\x0aSec-WebSocket-Origin: ");
 		strcpy(p, wsi->utf8_token[WSI_TOKEN_ORIGIN].token);
@@ -442,7 +555,6 @@
 		
 		if (interpret_key(wsi->utf8_token[WSI_TOKEN_KEY1].token, &key1))
 			goto bail;
-
 		if (interpret_key(wsi->utf8_token[WSI_TOKEN_KEY2].token, &key2))
 			goto bail;
 			
@@ -469,10 +581,10 @@
 		md5(sum, 16, (unsigned char *)p);
 		p += 16;
 
-		/* it's complete, go ahead and send it */
+		/* it's complete: go ahead and send it */
 		
 		fprintf(stderr, "issuing response packet %d len\n",
-							  (int)(p - response));
+							   (int)(p - response));
 		fwrite(response, 1,  p - response, stderr);
 			
 		n = write(wsi->sock, response, p - response);
@@ -480,18 +592,22 @@
 			fprintf(stderr, "ERROR writing to socket");
 			goto bail;
 		}
+		
+		/* alright clean up and set ourselves into established state */
 
 		free(response);
 		wsi->state = WSI_STATE_ESTABLISHED;
+		wsi->lws_rx_parse_state = LWS_RXPS_NEW;
 		
 		/* notify user code that we're ready to roll */
 				
 		if (wsi->callback)
-			wsi->callback(wsi, LWS_CALLBACK_ESTABLISHED);
+			wsi->callback(wsi, LWS_CALLBACK_ESTABLISHED, NULL, 0);
 		break;
 
 	case WSI_STATE_ESTABLISHED:
-		fprintf(stderr, "received %ld byte packet\n", len);
+		if (libwebsocket_interpret_incoming_packet(wsi, buf, len) < 0)
+			goto bail;
 		break;
 	default:
 		break;
@@ -504,68 +620,127 @@
 	return -1;
 }
 
-int libwebsocket_write(struct libwebsocket * wsi, void *buf, size_t len)
+
+/*
+ * notice, we will use up to LWS_SEND_BUFFER_PRE_PADDING bytes BEFORE the
+ * buffer pointer given and LWS_SEND_BUFFER_POST_PADDING bytes AFTER
+ * buf + len !!!  Caller must allocate and offset pointer accordingly!
+ * 
+ * This lets us send packets in one write() action including the protocol
+ * pre- and post- data without copying the payload around.
+ */
+
+int libwebsocket_write(struct libwebsocket * wsi, unsigned char *buf,
+						      size_t len, int is_binary)
 {
 	int n;
-	unsigned char hdr[9];
+	int pre = 0;
+	int post = 0;
+	unsigned int shift = 7;
 	
 	if (wsi->state != WSI_STATE_ESTABLISHED)
 		return -1;
 
 	switch (wsi->ietf_spec_revision) {
-	/* chrome */
-	case 0:
-		hdr[0] = 0xff;
-		hdr[1] = len >> 56;
-		hdr[2] = len >> 48;
-		hdr[3] = len >> 40;
-		hdr[4] = len >> 32;
-		hdr[5] = len >> 24;
-		hdr[6] = len >> 16;
-		hdr[7] = len >> 8;
-		hdr[8] = len;
-
-		n = write(wsi->sock, hdr, sizeof hdr);
-		if (n < 0) {
-			fprintf(stderr, "ERROR writing to socket");
-			return -1;
+	/* Firefox 4.0b6 likes this as of 30 Oct */
+	case 76:
+		if (is_binary) {
+			/* in binary mode we send 7-bit used length blocks */
+			pre = 1;
+			while (len & (127 << shift)) {
+				pre++;
+				shift += 7;
+			}
+			n = 0;
+			shift -= 7;
+			while (shift >= 0) {
+				if (shift)
+					buf[0 - pre + n] =
+						  ((len >> shift) & 127) | 0x80;
+				else
+					buf[0 - pre + n] =
+						  ((len >> shift) & 127);
+				n++;
+				shift -= 7;
+			}
+			break;
 		}
+
+		/* frame type = text, length-free spam mode */
+
+		buf[-1] = 0;
+		buf[len] = 0xff; /* EOT marker */
+		pre = 1;
+		post = 1;
 		break;
+
+	/* chrome likes this as of 30 Oct */
+	case 0:
+		buf[-9] = 0xff;
+#if defined __LP64__
+			buf[-8] = len >> 56;
+			buf[-7] = len >> 48;
+			buf[-6] = len >> 40;
+			buf[-5] = len >> 32;
+#else
+			buf[-8] = 0;
+			buf[-7] = 0;
+			buf[-6] = 0;
+			buf[-5] = 0;
+#endif
+		buf[-4] = len >> 24;
+		buf[-3] = len >> 16;
+		buf[-2] = len >> 8;
+		buf[-1] = len;
+		pre = 9;
+		break;
+		
 	/* just an unimplemented spec right now apparently */
 	case 2:
-		n = 0;
+		n = 4; /* text */
+		if (is_binary)
+			n = 5; /* binary */
 		if (len < 126) {
-			hdr[n++] = 0x04;
-			hdr[n++] = len;
+			buf[-2] = n;
+			buf[-1] = len;
+			pre = 2;
 		} else {
 			if (len < 65536) {
-				hdr[n++] = 0x04; /* text frame */
-				hdr[n++] = 126;
-				hdr[n++] = len >> 8;
-				hdr[n++] = len;
+				buf[-4] = n;
+				buf[-3] = 126;
+				buf[-2] = len >> 8;
+				buf[-1] = len;
+				pre = 4;
 			} else {
-				hdr[n++] = 0x04;
-				hdr[n++] = 127;
-				hdr[n++] = len >> 24;
-				hdr[n++] = len >> 16;
-				hdr[n++] = len >> 8;
-				hdr[n++] = len;
+				buf[-10] = n;
+				buf[-9] = 127;
+#if defined __LP64__
+					buf[-8] = (len >> 56) & 0x7f;
+					buf[-7] = len >> 48;
+					buf[-6] = len >> 40;
+					buf[-5] = len >> 32;
+#else
+					buf[-8] = 0;
+					buf[-7] = 0;
+					buf[-6] = 0;
+					buf[-5] = 0;
+#endif
+				buf[-4] = len >> 24;
+				buf[-3] = len >> 16;
+				buf[-2] = len >> 8;
+				buf[-1] = len;
+				pre = 10;
 			}
 		}
-		n = write(wsi->sock, hdr, n);
-		if (n < 0) {
-			fprintf(stderr, "ERROR writing to socket");
-			return -1;
-		}
 		break;
 	}
 
-	n = write(wsi->sock, buf, len);
+	n = write(wsi->sock, buf - pre, len + pre + post);
 	if (n < 0) {
 		fprintf(stderr, "ERROR writing to socket");
 		return -1;
 	}
-	
+
 	fprintf(stderr, "written %d bytes to websocket\n", (int)len);
 	
 	return 0;
@@ -616,7 +791,7 @@
 			continue;
 		
 		if (wsi->callback)
-			wsi->callback(wsi, LWS_CALLBACK_SEND);
+			wsi->callback(wsi, LWS_CALLBACK_SEND, NULL, 0);
 	}
 }
 
diff --git a/libwebsockets.h b/libwebsockets.h
index 870b7fe..b23f588 100644
--- a/libwebsockets.h
+++ b/libwebsockets.h
@@ -10,6 +10,30 @@
 
 extern int libwebsocket_create_server(int port,
 		  int (*callback)(struct libwebsocket *,
-					   enum libwebsocket_callback_reasons));
+					   enum libwebsocket_callback_reasons, void *, size_t));
 
-extern int libwebsocket_write(struct libwebsocket *, void *buf, size_t len);
+/*
+ * IMPORTANT NOTICE!
+ * 
+ * The send buffer has to have LWS_SEND_BUFFER_PRE_PADDING bytes valid BEFORE
+ * buf, and LWS_SEND_BUFFER_POST_PADDING bytes valid AFTER (buf + len).
+ * 
+ * This allows us to add protocol info before and after the data, and send as
+ * one packet on the network without payload copying, for maximum efficiency.
+ * 
+ * So for example you need this kind of code to use libwebsocket_write with a
+ * 128-byte payload 
+ * 
+ * char buf[LWS_SEND_BUFFER_PRE_PADDING + 128 + LWS_SEND_BUFFER_POST_PADDING];
+ * 
+ * // fill your part of the buffer... for example here it's all zeros
+ * memset(&buf[LWS_SEND_BUFFER_PRE_PADDING], 0, 128);
+ * 
+ * libwebsocket_write(wsi, &buf[LWS_SEND_BUFFER_PRE_PADDING], 128);
+ * 
+ */
+
+#define LWS_SEND_BUFFER_PRE_PADDING 12
+#define LWS_SEND_BUFFER_POST_PADDING 1
+
+extern int libwebsocket_write(struct libwebsocket *, unsigned char *buf, size_t len, int is_binary);
diff --git a/test-server.c b/test-server.c
index 0056e80..4f13664 100644
--- a/test-server.c
+++ b/test-server.c
@@ -6,11 +6,11 @@
 
 #define PORT 7681
 
-int websocket_callback(struct libwebsocket * wsi,
-				      enum libwebsocket_callback_reasons reason)
+static int websocket_callback(struct libwebsocket * wsi,
+	       enum libwebsocket_callback_reasons reason, void *in, size_t len)
 {
 	int n;
-	char buf[256];
+	char buf[LWS_SEND_BUFFER_PRE_PADDING + 256 + LWS_SEND_BUFFER_POST_PADDING];
 	static int bump;
 	
 	switch (reason) {
@@ -24,8 +24,8 @@
 
 	case LWS_CALLBACK_SEND:	
 		sleep(1);
-		n = sprintf(buf, "%d\n", bump++);
-		n = libwebsocket_write(wsi, buf, n);
+		n = sprintf(&buf[LWS_SEND_BUFFER_PRE_PADDING], "%d\n", bump++);
+		n = libwebsocket_write(wsi, (unsigned char *)&buf[LWS_SEND_BUFFER_PRE_PADDING], n, 0);
 		if (n < 0) {
 			fprintf(stderr, "ERROR writing to socket");
 			exit(1);
@@ -33,6 +33,7 @@
 		break;
 
 	case LWS_CALLBACK_RECEIVE:
+		fprintf(stderr, "Received %d bytes payload\n", (int)len);
 		break;
 	}
 	return 0;
diff --git a/test.html b/test.html
index 5d8b46f..59ad43f 100644
--- a/test.html
+++ b/test.html
@@ -15,7 +15,7 @@
 //        alert('<p class="event">Socket Status: '+socket.readyState);  
   
         socket.onopen = function(){  
-             alert('<p class="event">Socket Status: '+socket.readyState+' (open)');  
+ //            alert('<p class="event">Socket Status: '+socket.readyState+' (open)');  
         }  
   
         socket.onmessage = got_packet;
@@ -28,8 +28,8 @@
           }
 	
 function got_packet(msg){
-//	alert('got packet' + msg);
 
+//	alert('got packet' + msg.data);
 	document.write(msg.data + "\n");
 	
 }