Merge pull request #212 from cloudwu/dev

release 0.9.2
Merge branch 'dev' of github.com:cloudwu/skynet into dev
2026-07-22 11:03:12 +00:00 · 2014-12-08 10:57:23 +08:00 · 2014-12-08 10:53:53 +08:00 · 2014-12-08 10:53:14 +08:00 · 2014-12-05 12:07:19 +08:00 · 2014-12-04 20:10:24 +08:00
30 changed files with 1387 additions and 775 deletions
--- a/3rd/lua-mysqlaux/lua_mysqlaux.c
+++ b/3rd/lua-mysqlaux/lua_mysqlaux.c
@@ -1,372 +0,0 @@
-//
-//  lua_mysqlaux.c
-//
-//  Created by changfeng on 6/17/14.
-//  Copyright (c) 2014 changfeng. All rights reserved.
-//
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <lua.h>
-#include <lauxlib.h>
-
-#define SHA1SIZE       20
-#define ROTL(bits,word) (((word) << (bits)) | ((word) >> (32-(bits))))
-typedef unsigned int uint32_t;
-
-struct sha
-{
-    uint32_t digest[5];
-    uint32_t w[80];
-    uint32_t a,b,c,d,e,f;
-    int err;
-};
-
-
-static uint32_t padded_length_in_bits(uint32_t len)
-{
-    if(len%64 == 56)
-    {
-        len++;
-    }
-    while((len%64)!=56)
-    {
-        len++;
-    }
-    return len*8;
-}
-
-
-static int calculate_sha1(struct sha *sha1, const unsigned char *text, uint32_t length)
-{
-    unsigned int i,j;
-    unsigned char *buffer=NULL, *pbuffer=NULL;
-    uint32_t bits=0;
-    uint32_t temp=0,k=0;
-    uint32_t lb = length*8;
-    
-    if (!sha1)
-    {
-        return 0;
-    }
-    // initialize the default digest values
-    sha1->digest[0] = 0x67452301;
-    sha1->digest[1] = 0xEFCDAB89;
-    sha1->digest[2] = 0x98BADCFE;
-    sha1->digest[3] = 0x10325476;
-    sha1->digest[4] = 0xC3D2E1F0;
-    sha1->a=sha1->b=sha1->c=sha1->d=sha1->e=sha1->f=0;
-    if (!text || !length)
-    {
-        return 0;
-    }
-    
-    bits = padded_length_in_bits(length);
-    buffer = (unsigned char *) malloc((bits/8)+8);
-    memset(buffer,0,(bits/8)+8);
-    if(buffer == NULL)
-    {
-    	return 1;
-    }
-    pbuffer = buffer;
-    memcpy(buffer, text, length);
-    
-    
-    //add 1 on the last of the message..
-    *(buffer+length) = 0x80;
-    for(i=length+1; i<(bits/8); i++)
-    {
-        *(buffer+i) = 0x00;
-    }
-    
-    *(buffer +(bits/8)+4+0) = (lb>>24) & 0xFF;
-    *(buffer +(bits/8)+4+1) = (lb>>16) & 0xFF;
-    *(buffer +(bits/8)+4+2) = (lb>>8) & 0xFF;
-    *(buffer +(bits/8)+4+3) = (lb>>0) & 0xFF;
-    
-    
-    //main loop
-    for(i=0; i<((bits+64)/512); i++)
-    {
-        //first empty the block for each pass..
-        for(j=0; j<80; j++)
-        {
-            sha1->w[j] = 0x00;
-        }
-        
-        
-        //fill the first 16 words with the characters read directly from the buffer.
-        for(j=0; j<16; j++)
-        {
-            sha1->w[j] =buffer[j*4+0];
-            sha1->w[j] = sha1->w[j]<<8;
-            sha1->w[j] |= buffer[j*4+1];
-            sha1->w[j] = sha1->w[j]<<8;
-            sha1->w[j] |= buffer[j*4+2];
-            sha1->w[j] = sha1->w[j]<<8;
-            sha1->w[j] |= buffer[j*4+3];
-        }
-        
-        //fill the rest 64 words using the formula
-        for(j=16; j<80; j++)
-        {
-            sha1->w[j] = (ROTL(1,(sha1->w[j-3] ^ sha1->w[j-8] ^ sha1->w[j-14] ^ sha1->w[j-16])));
-        }
-        
-        
-        //initialize hash for this chunck reading that has been stored in the structure digest
-        sha1->a = sha1->digest[0];
-        sha1->b = sha1->digest[1];
-        sha1->c = sha1->digest[2];
-        sha1->d = sha1->digest[3];
-        sha1->e = sha1->digest[4];
-        
-		//for all the 80 32bit blocks calculate f and use k accordingly per specification.
-        for(j=0; j<80; j++)
-        {
-            if((j>=0) && (j<20))
-            {
-                sha1->f = ((sha1->b)&(sha1->c)) | ((~(sha1->b))&(sha1->d));
-                k = 0x5A827999;
-                
-            }
-            else if((j>=20) && (j<40))
-            {
-                sha1->f = (sha1->b)^(sha1->c)^(sha1->d);
-                k = 0x6ED9EBA1;
-            }
-            else if((j>=40) && (j<60))
-            {
-                sha1->f = ((sha1->b)&(sha1->c)) | ((sha1->b)&(sha1->d)) | ((sha1->c)&(sha1->d));
-                k = 0x8F1BBCDC;
-            }
-            else if((j>=60) && (j<80))
-            {
-                sha1->f = (sha1->b)^(sha1->c)^(sha1->d);
-                k = 0xCA62C1D6;
-            }
-            
-            temp = ROTL(5,(sha1->a)) + (sha1->f) + (sha1->e) + k + sha1->w[j];
-            sha1->e = (sha1->d);
-            sha1->d = (sha1->c);
-            sha1->c = ROTL(30,(sha1->b));
-            sha1->b = (sha1->a);
-            sha1->a = temp;
-            
-            //reset temp to 0 to be in safe side only, not mandatory.
-            temp =0x00;
-            
-            
-        }
-        
-        // append to total hash.
-        sha1->digest[0] += sha1->a;
-        sha1->digest[1] += sha1->b;
-        sha1->digest[2] += sha1->c;
-        sha1->digest[3] += sha1->d;
-        sha1->digest[4] += sha1->e;
-        
-        
-		//since we used 512bit size block per each pass, let us update the buffer pointer accordingly.
-        buffer = buffer+64;
-        
-    }
-    free(pbuffer);
-    return 0;
-}
-
-static void int2ch4(int intVal,unsigned char *result)
-{
-    result[0]= (unsigned char)((intVal>>24) & 0x000000ff);
-    result[1]= (unsigned char)((intVal>>16) & 0x000000ff);
-    result[2]= (unsigned char)((intVal>> 8) & 0x000000ff);
-    result[3]= (unsigned char)((intVal>> 0) & 0x000000ff);
-}
-
-
-static int sha1_bin (lua_State *L) {
-    const void * msg = NULL;
-    size_t len =0;
-
-    if( lua_gettop(L) != 1 ){
-        return 0;
-    }	
-    if( lua_isnil(L,1) ) {
-        msg = NULL;
-        len =0;
-    }else{
-        msg=luaL_checklstring(L,1,&len);
-    }
-    struct sha tmpsha;
-    calculate_sha1( &tmpsha, msg, (uint32_t)len);
-    unsigned char tmpret[SHA1SIZE+8];
-    memset(tmpret,0,SHA1SIZE+8);
-    int i=0;
-    for ( i=0; i<5; i++)
-    {
-        int2ch4(tmpsha.digest[i], tmpret+i*4);
-    }
-    
-    lua_pushlstring(L, (char *)tmpret, SHA1SIZE);
-    return 1;
-}
-
-static unsigned int num_escape_sql_str(unsigned char *dst, unsigned char *src, size_t size)
-{
-    unsigned int n =0;
-    while (size) {
-        /* the highest bit of all the UTF-8 chars
-         * is always 1 */
-        if ((*src & 0x80) == 0) {
-            switch (*src) {
-                case '\0':
-                case '\b':
-                case '\n':
-                case '\r':
-                case '\t':
-                case 26:  /* \z */
-                case '\\':
-                case '\'':
-                case '"':
-                    n++;
-                    break;
-                default:
-                    break;
-            }
-        }
-        src++;
-        size--;
-    }
-    return n;
-}
-static unsigned char*
-escape_sql_str(unsigned char *dst, unsigned char *src, size_t size)
-{
-    
-      while (size) {
-        if ((*src & 0x80) == 0) {
-            switch (*src) {
-                case '\0':
-                    *dst++ = '\\';
-                    *dst++ = '0';
-                    break;
-                    
-                case '\b':
-                    *dst++ = '\\';
-                    *dst++ = 'b';
-                    break;
-                    
-                case '\n':
-                    *dst++ = '\\';
-                    *dst++ = 'n';
-                    break;
-                    
-                case '\r':
-                    *dst++ = '\\';
-                    *dst++ = 'r';
-                    break;
-                    
-                case '\t':
-                    *dst++ = '\\';
-                    *dst++ = 't';
-                    break;
-                    
-                case 26:
-                    *dst++ = '\\';
-                    *dst++ = 'z';
-                    break;
-                    
-                case '\\':
-                    *dst++ = '\\';
-                    *dst++ = '\\';
-                    break;
-                    
-                case '\'':
-                    *dst++ = '\\';
-                    *dst++ = '\'';
-                    break;
-                    
-                case '"':
-                    *dst++ = '\\';
-                    *dst++ = '"';
-                    break;
-                    
-                default:
-                    *dst++ = *src;
-                    break;
-            }
-        } else {
-            *dst++ = *src;
-        }
-        src++;
-        size--;
-    } /* while (size) */
-    
-    return  dst;
-}
-
-
-
-
-static int
-quote_sql_str(lua_State *L)
-{
-    size_t                   len, dlen, escape;
-    unsigned char                  *p;
-    unsigned char                  *src, *dst;
-    
-    if (lua_gettop(L) != 1) {
-        return luaL_error(L, "expecting one argument");
-    }
-    
-    src = (unsigned char *) luaL_checklstring(L, 1, &len);
-    
-    if (len == 0) {
-        dst = (unsigned char *) "''";
-        dlen = sizeof("''") - 1;
-        lua_pushlstring(L, (char *) dst, dlen);
-        return 1;
-    }
-    
-    escape = num_escape_sql_str(NULL, src, len);
-    
-    dlen = sizeof("''") - 1 + len + escape;
-    p = lua_newuserdata(L, dlen);
-    
-    dst = p;
-    
-    *p++ = '\'';
-    
-    if (escape == 0) {
-        memcpy(p, src, len);
-        p+=len;
-    } else {
-        p = (unsigned char *) escape_sql_str(p, src, len);
-    }
-    
-    *p++ = '\'';
-    
-    if (p != dst + dlen) {
-        return luaL_error(L, "quote sql string error");
-    }
-    
-    lua_pushlstring(L, (char *) dst, p - dst);
-    
-    return 1;
-}
-
-
-static struct luaL_Reg mysqlauxlib[] = {
-    {"sha1_bin", sha1_bin},
-    {"quote_sql_str",quote_sql_str},
-    {NULL, NULL}
-};
-
-
-int luaopen_mysqlaux_c (lua_State *L) {
-    lua_newtable(L);
-    luaL_setfuncs(L, mysqlauxlib, 0);
-    return 1;
-}
-
--- a/3rd/lua/lgc.c
+++ b/3rd/lua/lgc.c
@@ -403,7 +403,7 @@ static int traverseephemeron (global_State *g, Table *h) {
      reallymarkobject(g, gcvalue(gval(n)));  /* mark it now */
    }
  }
-  if (prop)
+  if (g->gcstate != GCSatomic || prop)
    linktable(h, &g->ephemeron);  /* have to propagate again */
  else if (hasclears)  /* does table have white keys? */
    linktable(h, &g->allweak);  /* may have to clean white keys */
--- a/HISTORY.md
+++ b/HISTORY.md
@@ -1,3 +1,27 @@
+v0.9.2 (2014-12-8)
+-----------
+* Simplify the message queue
+* Add create_index in mongo driver
+* Fix a bug in big-endian architecture (sproto)
+
+v0.9.0 / v0.9.1 (2014-11-17)
+-----------
+* Add UDP support
+* Add IPv6 support
+* socket send package can define a release method
+* dispatch read before write in epoll
+* remove snax queue mode
+* Fix a bug in big-endian architecture
+
+v0.8.1 (2014-11-3)
+-----------
+* Send to an invalid remote service will raise an error
+* Bugifx: socket open address string
+* Remove sha1 from mysqlaux
+* merge lua and sproto bugfix , use crypt lib instead
+* Fix a memory leak in socket
+* minor bugfix in http module
+
 v0.8.0 (2014-10-27)
 -----------
 * Add mysql client driver
--- a/2
+++ b/2
@@ -123,7 +123,7 @@ $(LUA_CLIB_PATH)/sproto.so : lualib-src/sproto/sproto.c lualib-src/sproto/lsprot
 $(LUA_CLIB_PATH)/lpeg.so : 3rd/lpeg/lpcap.c 3rd/lpeg/lpcode.c 3rd/lpeg/lpprint.c 3rd/lpeg/lptree.c 3rd/lpeg/lpvm.c | $(LUA_CLIB_PATH)
 	$(CC) $(CFLAGS) $(SHARED) -I3rd/lpeg $^ -o $@ 

-$(LUA_CLIB_PATH)/mysqlaux.so : 3rd/lua-mysqlaux/lua_mysqlaux.c | $(LUA_CLIB_PATH)
+$(LUA_CLIB_PATH)/mysqlaux.so : lualib-src/lua_mysqlaux.c | $(LUA_CLIB_PATH)
 	$(CC) $(CFLAGS) $(SHARED) $^ -o $@	

 clean :
--- a/examples/simpleweb.lua
+++ b/examples/simpleweb.lua
@@ -66,6 +66,7 @@ skynet.start(function()
 	end
 	local balance = 1
 	local id = socket.listen("0.0.0.0", 8001)
+	skynet.error("Listen web port 8001")
 	socket.start(id , function(id, addr)
 		skynet.error(string.format("%s connected, pass it to agent :%08x", addr, agent[balance]))
 		skynet.send(agent[balance], "lua", id)
--- a/lualib-src/lua-netpack.c
+++ b/lualib-src/lua-netpack.c
@@ -240,19 +240,12 @@ filter_data_(lua_State *L, int fd, uint8_t * buffer, int size) {
 		buffer += need;
 		size -= need;
 		if (size == 0) {
-			if (q == NULL || q->head == q->tail ) {
-				lua_pushvalue(L, lua_upvalueindex(TYPE_DATA));
-				lua_pushinteger(L, fd);
-				lua_pushlightuserdata(L, uc->pack.buffer);
-				lua_pushinteger(L, uc->pack.size);
-				skynet_free(uc);
-				return 5;
-			}
-			else{
-				push_data(L, fd, uc->pack.buffer, uc->pack.size, 0);
-				skynet_free(uc);
-				return 1;
-			}
+			lua_pushvalue(L, lua_upvalueindex(TYPE_DATA));
+			lua_pushinteger(L, fd);
+			lua_pushlightuserdata(L, uc->pack.buffer);
+			lua_pushinteger(L, uc->pack.size);
+			skynet_free(uc);
+			return 5;
 		}
 		// more data
 		push_data(L, fd, uc->pack.buffer, uc->pack.size, 0);
@@ -281,21 +274,13 @@ filter_data_(lua_State *L, int fd, uint8_t * buffer, int size) {
 		}
 		if (size == pack_size) {
 			// just one package
-			if ( q == NULL || q->head == q->tail) {
-				lua_pushvalue(L, lua_upvalueindex(TYPE_DATA));
-				lua_pushinteger(L, fd);
-				void * result = skynet_malloc(pack_size);
-				memcpy(result, buffer, size);
-				lua_pushlightuserdata(L, result);
-				lua_pushinteger(L, size);
-				return 5;
-			}
-			else{
-				push_data(L, fd, buffer, pack_size, 1);
-				buffer += pack_size;
-				size -= pack_size;
-				return 1;
-			}
+			lua_pushvalue(L, lua_upvalueindex(TYPE_DATA));
+			lua_pushinteger(L, fd);
+			void * result = skynet_malloc(pack_size);
+			memcpy(result, buffer, size);
+			lua_pushlightuserdata(L, result);
+			lua_pushinteger(L, size);
+			return 5;
 		}
 		// more data
 		push_data(L, fd, buffer, pack_size, 1);
@@ -317,9 +302,9 @@ filter_data(lua_State *L, int fd, uint8_t * buffer, int size) {
 }

 static void
-pushstring(lua_State *L, const char * msg) {
+pushstring(lua_State *L, const char * msg, int size) {
 	if (msg) {
-		lua_pushstring(L, msg);
+		lua_pushlstring(L, msg, size);
 	} else {
 		lua_pushliteral(L, "");
 	}
@@ -365,12 +350,12 @@ lfilter(lua_State *L) {
 		lua_pushvalue(L, lua_upvalueindex(TYPE_OPEN));
 		// ignore listen id (message->id);
 		lua_pushinteger(L, message->ud);
-		pushstring(L, buffer);
+		pushstring(L, buffer, size);
 		return 4;
 	case SKYNET_SOCKET_TYPE_ERROR:
 		lua_pushvalue(L, lua_upvalueindex(TYPE_ERROR));
 		lua_pushinteger(L, message->id);
-		pushstring(L, buffer);
+		pushstring(L, buffer, size);
 		return 4;
 	default:
 		// never get here
--- a/lualib-src/lua-seri.c
+++ b/lualib-src/lua-seri.c
@@ -179,7 +179,7 @@ wb_string(struct write_block *wb, const char *str, int len) {
 			wb_push(wb, str, len);
 		}
 	} else {
-		int n;
+		uint8_t n;
 		if (len < 0x10000) {
 			n = COMBINE_TYPE(TYPE_LONG_STRING, 2);
 			wb_push(wb, &n, 1);
--- a/lualib-src/lua-socket.c
+++ b/lualib-src/lua-socket.c
@@ -9,6 +9,9 @@
 #include <lua.h>
 #include <lauxlib.h>

+#include <sys/socket.h>
+#include <arpa/inet.h>
+
 #include "skynet_socket.h"

 #define BACKLOG 32
@@ -80,6 +83,15 @@ lnewbuffer(lua_State *L) {
 	int size

 	return size
+
+	Comment: The table pool record all the buffers chunk, 
+	and the first index [1] is a lightuserdata : free_node. We can always use this pointer for struct buffer_node .
+	The following ([2] ...)  userdatas in table pool is the buffer chunk (for struct buffer_node), 
+	we never free them until the VM closed. The size of first chunk ([2]) is 8 struct buffer_node,
+	and the second size is 16 ... The largest size of chunk is LARGE_PAGE_NODE (4096)
+
+	lpushbbuffer will get a free struct buffer_node from table pool, and then put the msg/size in it.
+	lpopbuffer return the struct buffer_node back to table pool (By calling return_free_node).
 */
 static int
 lpushbuffer(lua_State *L) {
@@ -372,28 +384,64 @@ lunpack(lua_State *L) {
 	} else {
 		lua_pushlightuserdata(L, message->buffer);
 	}
+	if (message->type == SKYNET_SOCKET_TYPE_UDP) {
+		int addrsz = 0;
+		const char * addrstring = skynet_socket_udp_address(message, &addrsz);
+		if (addrstring) {
+			lua_pushlstring(L, addrstring, addrsz);
+			return 5;
+		}
+	}
 	return 4;
 }

+static const char *
+address_port(lua_State *L, char *tmp, const char * addr, int port_index, int *port) {
+	const char * host;
+	if (lua_isnoneornil(L,port_index)) {
+		host = strchr(addr, '[');
+		if (host) {
+			// is ipv6
+			++host;
+			const char * sep = strchr(addr,']');
+			if (sep == NULL) {
+				luaL_error(L, "Invalid address %s.",addr);
+			}
+			memcpy(tmp, host, sep-host);
+			tmp[sep-host] = '\0';
+			host = tmp;
+			sep = strchr(sep + 1, ':');
+			if (sep == NULL) {
+				luaL_error(L, "Invalid address %s.",addr);
+			}
+			*port = strtoul(sep+1,NULL,10);
+		} else {
+			// is ipv4
+			const char * sep = strchr(addr,':');
+			if (sep == NULL) {
+				luaL_error(L, "Invalid address %s.",addr);
+			}
+			memcpy(tmp, addr, sep-addr);
+			tmp[sep-addr] = '\0';
+			host = tmp;
+			*port = strtoul(sep+1,NULL,10);
+		}
+	} else {
+		host = addr;
+		*port = luaL_optinteger(L,port_index, 0);
+	}
+	return host;
+}
+
 static int
 lconnect(lua_State *L) {
 	size_t sz = 0;
 	const char * addr = luaL_checklstring(L,1,&sz);
 	char tmp[sz];
-	int port;
-	const char * host;
-	if (lua_isnoneornil(L,2)) {
-		const char * sep = strchr(addr,':');
-		if (sep == NULL) {
-			return luaL_error(L, "Connect to invalid address %s.",addr);
-		}
-		memcpy(tmp, addr, sep-addr);
-		tmp[sep-addr] = '\0';
-		host = tmp;
-		port = strtoul(sep+1,NULL,10);
-	} else {
-		host = addr;
-		port = luaL_checkinteger(L,2);
+	int port = 0;
+	const char * host = address_port(L, tmp, addr, 2, &port);
+	if (port == 0) {
+		return luaL_error(L, "Invalid port");
 	}
 	struct skynet_context * ctx = lua_touserdata(L, lua_upvalueindex(1));
 	int id = skynet_socket_connect(ctx, host, port);
@@ -426,14 +474,14 @@ llisten(lua_State *L) {
 }

 static void *
-get_buffer(lua_State *L, int *sz) {
+get_buffer(lua_State *L, int index, int *sz) {
 	void *buffer;
-	if (lua_isuserdata(L,2)) {
-		buffer = lua_touserdata(L,2);
-		*sz = luaL_checkinteger(L,3);
+	if (lua_isuserdata(L,index)) {
+		buffer = lua_touserdata(L,index);
+		*sz = luaL_checkinteger(L,index+1);
 	} else {
 		size_t len = 0;
-		const char * str =  luaL_checklstring(L, 2, &len);
+		const char * str =  luaL_checklstring(L, index, &len);
 		buffer = skynet_malloc(len);
 		memcpy(buffer, str, len);
 		*sz = (int)len;
@@ -446,7 +494,7 @@ lsend(lua_State *L) {
 	struct skynet_context * ctx = lua_touserdata(L, lua_upvalueindex(1));
 	int id = luaL_checkinteger(L, 1);
 	int sz = 0;
-	void *buffer = get_buffer(L, &sz);
+	void *buffer = get_buffer(L, 2, &sz);
 	int err = skynet_socket_send(ctx, id, buffer, sz);
 	lua_pushboolean(L, !err);
 	return 1;
@@ -457,7 +505,7 @@ lsendlow(lua_State *L) {
 	struct skynet_context * ctx = lua_touserdata(L, lua_upvalueindex(1));
 	int id = luaL_checkinteger(L, 1);
 	int sz = 0;
-	void *buffer = get_buffer(L, &sz);
+	void *buffer = get_buffer(L, 2, &sz);
 	skynet_socket_send_lowpriority(ctx, id, buffer, sz);
 	return 0;
 }
@@ -486,6 +534,90 @@ lnodelay(lua_State *L) {
 	skynet_socket_nodelay(ctx,id);
 	return 0;
 }
+/*
+int skynet_socket_udp(struct skynet_context *ctx, const char * addr, int port);
+int skynet_socket_udp_connect(struct skynet_context *ctx, int id, const char * addr, int port);
+int skynet_socket_udp_send(struct skynet_context *ctx, int id, const char * address, const void *buffer, int sz);
+const char * skynet_socket_udp_address(struct skynet_context *ctx, struct skynet_socket_message *, int *addrsz);
+*/
+
+static int
+ludp(lua_State *L) {
+	struct skynet_context * ctx = lua_touserdata(L, lua_upvalueindex(1));
+	size_t sz = 0;
+	const char * addr = lua_tolstring(L,1,&sz);
+	char tmp[sz];
+	int port = 0;
+	const char * host = NULL;
+	if (addr) {
+		host = address_port(L, tmp, addr, 2, &port);
+	}
+
+	int id = skynet_socket_udp(ctx, host, port);
+	if (id < 0) {
+		return luaL_error(L, "udp init failed");
+	}
+	lua_pushinteger(L, id);
+	return 1;
+}
+
+static int
+ludp_connect(lua_State *L) {
+	struct skynet_context * ctx = lua_touserdata(L, lua_upvalueindex(1));
+	int id = luaL_checkinteger(L, 1);
+	size_t sz = 0;
+	const char * addr = luaL_checklstring(L,2,&sz);
+	char tmp[sz];
+	int port = 0;
+	const char * host = NULL;
+	if (addr) {
+		host = address_port(L, tmp, addr, 3, &port);
+	}
+
+	if (skynet_socket_udp_connect(ctx, id, host, port)) {
+		return luaL_error(L, "udp connect failed");
+	}
+
+	return 0;
+}
+
+static int
+ludp_send(lua_State *L) {
+	struct skynet_context * ctx = lua_touserdata(L, lua_upvalueindex(1));
+	int id = luaL_checkinteger(L, 1);
+	const char * address = luaL_checkstring(L, 2);
+	int sz = 0;
+	void *buffer = get_buffer(L, 3, &sz);
+	int err = skynet_socket_udp_send(ctx, id, address, buffer, sz);
+
+	lua_pushboolean(L, !err);
+
+	return 1;
+}
+
+static int
+ludp_address(lua_State *L) {
+	size_t sz = 0;
+	const uint8_t * addr = (const uint8_t *)luaL_checklstring(L, 1, &sz);
+	int port = addr[1] * 256 + addr[2];
+	const void * src = addr+3;
+	char tmp[256];
+	int family;
+	if (sz == 1+2+4) {
+		family = AF_INET;
+	} else {
+		if (sz != 1+2+16) {
+			return luaL_error(L, "Invalid udp address");
+		}
+		family = AF_INET6;
+	}
+	if (inet_ntop(family, src, tmp, sizeof(tmp)) == NULL) {
+		return luaL_error(L, "Invalid udp address");
+	}
+	lua_pushstring(L, tmp);
+	lua_pushinteger(L, port);
+	return 2;
+}

 int
 luaopen_socketdriver(lua_State *L) {
@@ -514,6 +646,10 @@ luaopen_socketdriver(lua_State *L) {
 		{ "bind", lbind },
 		{ "start", lstart },
 		{ "nodelay", lnodelay },
+		{ "udp", ludp },
+		{ "udp_connect", ludp_connect },
+		{ "udp_send", ludp_send },
+		{ "udp_address", ludp_address },
 		{ NULL, NULL },
 	};
 	lua_getfield(L, LUA_REGISTRYINDEX, "skynet_context");
--- a/lualib-src/lua_mysqlaux.c
+++ b/lualib-src/lua_mysqlaux.c
@@ -0,0 +1,170 @@
+//
+//  lua_mysqlaux.c
+//
+//  Created by changfeng on 6/17/14.
+//  Copyright (c) 2014 changfeng. All rights reserved.
+//
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <lua.h>
+#include <lauxlib.h>
+
+static unsigned int num_escape_sql_str(unsigned char *dst, unsigned char *src, size_t size)
+{
+    unsigned int n =0;
+    while (size) {
+        /* the highest bit of all the UTF-8 chars
+         * is always 1 */
+        if ((*src & 0x80) == 0) {
+            switch (*src) {
+                case '\0':
+                case '\b':
+                case '\n':
+                case '\r':
+                case '\t':
+                case 26:  /* \Z */
+                case '\\':
+                case '\'':
+                case '"':
+                    n++;
+                    break;
+                default:
+                    break;
+            }
+        }
+        src++;
+        size--;
+    }
+    return n;
+}
+static unsigned char*
+escape_sql_str(unsigned char *dst, unsigned char *src, size_t size)
+{
+    
+      while (size) {
+        if ((*src & 0x80) == 0) {
+            switch (*src) {
+                case '\0':
+                    *dst++ = '\\';
+                    *dst++ = '0';
+                    break;
+                    
+                case '\b':
+                    *dst++ = '\\';
+                    *dst++ = 'b';
+                    break;
+                    
+                case '\n':
+                    *dst++ = '\\';
+                    *dst++ = 'n';
+                    break;
+                    
+                case '\r':
+                    *dst++ = '\\';
+                    *dst++ = 'r';
+                    break;
+                    
+                case '\t':
+                    *dst++ = '\\';
+                    *dst++ = 't';
+                    break;
+                    
+                case 26:
+                    *dst++ = '\\';
+                    *dst++ = 'Z';
+                    break;
+                    
+                case '\\':
+                    *dst++ = '\\';
+                    *dst++ = '\\';
+                    break;
+                    
+                case '\'':
+                    *dst++ = '\\';
+                    *dst++ = '\'';
+                    break;
+                    
+                case '"':
+                    *dst++ = '\\';
+                    *dst++ = '"';
+                    break;
+                    
+                default:
+                    *dst++ = *src;
+                    break;
+            }
+        } else {
+            *dst++ = *src;
+        }
+        src++;
+        size--;
+    } /* while (size) */
+    
+    return  dst;
+}
+
+
+
+
+static int
+quote_sql_str(lua_State *L)
+{
+    size_t                   len, dlen, escape;
+    unsigned char                  *p;
+    unsigned char                  *src, *dst;
+    
+    if (lua_gettop(L) != 1) {
+        return luaL_error(L, "expecting one argument");
+    }
+    
+    src = (unsigned char *) luaL_checklstring(L, 1, &len);
+    
+    if (len == 0) {
+        dst = (unsigned char *) "''";
+        dlen = sizeof("''") - 1;
+        lua_pushlstring(L, (char *) dst, dlen);
+        return 1;
+    }
+    
+    escape = num_escape_sql_str(NULL, src, len);
+    
+    dlen = sizeof("''") - 1 + len + escape;
+    p = lua_newuserdata(L, dlen);
+    
+    dst = p;
+    
+    *p++ = '\'';
+    
+    if (escape == 0) {
+        memcpy(p, src, len);
+        p+=len;
+    } else {
+        p = (unsigned char *) escape_sql_str(p, src, len);
+    }
+    
+    *p++ = '\'';
+    
+    if (p != dst + dlen) {
+        return luaL_error(L, "quote sql string error");
+    }
+    
+    lua_pushlstring(L, (char *) dst, p - dst);
+    
+    return 1;
+}
+
+
+static struct luaL_Reg mysqlauxlib[] = {
+    {"quote_sql_str",quote_sql_str},
+    {NULL, NULL}
+};
+
+
+int luaopen_mysqlaux_c (lua_State *L) {
+    lua_newtable(L);
+    luaL_setfuncs(L, mysqlauxlib, 0);
+    return 1;
+}
+
--- a/lualib-src/sproto/lsproto.c
+++ b/lualib-src/sproto/lsproto.c
@@ -19,17 +19,17 @@
 */
 LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
 #ifdef luaL_checkversion
-  luaL_checkversion(L);
+	luaL_checkversion(L);
 #endif
-  luaL_checkstack(L, nup, "too many upvalues");
-  for (; l->name != NULL; l++) {  /* fill the table with given functions */
-    int i;
-    for (i = 0; i < nup; i++)  /* copy upvalues to the top */
-      lua_pushvalue(L, -nup);
-    lua_pushcclosure(L, l->func, nup);  /* closure with those upvalues */
-    lua_setfield(L, -(nup + 2), l->name);
-  }
-  lua_pop(L, nup);  /* remove upvalues */
+	luaL_checkstack(L, nup, "too many upvalues");
+	for (; l->name != NULL; l++) {  /* fill the table with given functions */
+		int i;
+		for (i = 0; i < nup; i++)  /* copy upvalues to the top */
+			lua_pushvalue(L, -nup);
+		lua_pushcclosure(L, l->func, nup);  /* closure with those upvalues */
+		lua_setfield(L, -(nup + 2), l->name);
+	}
+	lua_pop(L, nup);  /* remove upvalues */
 }

 #define luaL_newlibtable(L,l) \
@@ -62,18 +62,20 @@ ldeleteproto(lua_State *L) {

 static int
 lquerytype(lua_State *L) {
+	const char * type_name;
 	struct sproto *sp = lua_touserdata(L,1);
+	struct sproto_type *st;
 	if (sp == NULL) {
 		return luaL_argerror(L, 1, "Need a sproto object");
 	}
-	const char * typename = luaL_checkstring(L,2);
-	struct sproto_type *st = sproto_type(sp, typename);
+	type_name = luaL_checkstring(L,2);
+	st = sproto_type(sp, type_name);
 	if (st) {
 		lua_pushlightuserdata(L, st);
 		return 1;
 	}

-	return luaL_error(L, "type %s not found", typename);
+	return luaL_error(L, "type %s not found", type_name);
 }

 struct encode_ud {
@@ -85,7 +87,7 @@ struct encode_ud {
 	int deep;
 };

-static int 
+static int
 encode(void *ud, const char *tagname, int type, int index, struct sproto_type *st, void *value, int length) {
 	struct encode_ud *self = ud;
 	lua_State *L = self->L;
@@ -119,9 +121,10 @@ encode(void *ud, const char *tagname, int type, int index, struct sproto_type *s
 	switch (type) {
 	case SPROTO_TINTEGER: {
 		lua_Integer v = luaL_checkinteger(L, -1);
+		lua_Integer vh;
 		lua_pop(L,1);
 		// notice: in lua 5.2, lua_Integer maybe 52bit
-		lua_Integer vh = v >> 31;
+		vh = v >> 31;
 		if (vh == 0 || vh == -1) {
 			*(uint32_t *)value = (uint32_t)v;
 			return 4;
@@ -148,13 +151,14 @@ encode(void *ud, const char *tagname, int type, int index, struct sproto_type *s
 	}
 	case SPROTO_TSTRUCT: {
 		struct encode_ud sub;
+		int r;
 		sub.L = L;
 		sub.st = st;
 		sub.tbl_index = lua_gettop(L);
 		sub.array_tag = NULL;
 		sub.array_index = 0;
 		sub.deep = self->deep + 1;
-		int r = sproto_encode(st, value, length, encode, &sub);
+		r = sproto_encode(st, value, length, encode, &sub);
 		lua_pop(L,1);
 		return r;
 	}
@@ -165,6 +169,7 @@ encode(void *ud, const char *tagname, int type, int index, struct sproto_type *s

 static void *
 expand_buffer(lua_State *L, int osz, int nsz) {
+	void *output;
 	do {
 		osz *= 2;
 	} while (osz < nsz);
@@ -172,7 +177,7 @@ expand_buffer(lua_State *L, int osz, int nsz) {
 		luaL_error(L, "object is too large (>%d)", ENCODE_MAXSIZE);
 		return NULL;
 	}
-	void *output = lua_newuserdata(L, osz);
+	output = lua_newuserdata(L, osz);
 	lua_replace(L, lua_upvalueindex(1));
 	lua_pushinteger(L, osz);
 	lua_replace(L, lua_upvalueindex(2));
@@ -184,10 +189,11 @@ expand_buffer(lua_State *L, int osz, int nsz) {
 	lightuserdata sproto_type
 	table source

-	return string 
+	return string
 */
 static int
 lencode(lua_State *L) {
+	struct encode_ud self;
 	void * buffer = lua_touserdata(L, lua_upvalueindex(1));
 	int sz = lua_tointeger(L, lua_upvalueindex(2));

@@ -197,7 +203,6 @@ lencode(lua_State *L) {
 	}
 	luaL_checktype(L, 2, LUA_TTABLE);
 	luaL_checkstack(L, ENCODE_DEEPLEVEL + 8, NULL);
-	struct encode_ud self;
 	self.L = L;
 	self.st = st;
 	self.tbl_index = 2;
@@ -224,7 +229,7 @@ struct decode_ud {
 	int deep;
 };

-static int 
+static int
 decode(void *ud, const char *tagname, int type, int index, struct sproto_type *st, void *value, int length) {
 	struct decode_ud * self = ud;
 	lua_State *L = self->L;
@@ -247,12 +252,12 @@ decode(void *ud, const char *tagname, int type, int index, struct sproto_type *s
 	switch (type) {
 	case SPROTO_TINTEGER: {
 		// notice: in lua 5.2, 52bit integer support (not 64)
-		lua_Integer v = *(lua_Integer *)value;
+		lua_Integer v = *(uint64_t*)value;
 		lua_pushinteger(L, v);
 		break;
 	}
 	case SPROTO_TBOOLEAN: {
-		int v = *(lua_Integer*)value;
+		int v = *(uint64_t*)value;
 		lua_pushboolean(L,v);
 		break;
 	}
@@ -261,15 +266,16 @@ decode(void *ud, const char *tagname, int type, int index, struct sproto_type *s
 		break;
 	}
 	case SPROTO_TSTRUCT: {
-		lua_newtable(L);
 		struct decode_ud sub;
+		int r;
+		lua_newtable(L);
 		sub.L = L;
 		sub.result_index = lua_gettop(L);
 		sub.deep = self->deep + 1;
 		sub.array_index = 0;
 		sub.array_tag = NULL;

-		int r = sproto_decode(st, value, length, decode, &sub);
+		r = sproto_decode(st, value, length, decode, &sub);
 		if (r < 0 || r != length)
 			return r;
 		lua_settop(L, sub.result_index);
@@ -312,22 +318,25 @@ getbuffer(lua_State *L, int index, size_t *sz) {
 static int
 ldecode(lua_State *L) {
 	struct sproto_type * st = lua_touserdata(L, 1);
+	const void * buffer;
+	struct decode_ud self;
+	size_t sz;
+	int r;
 	if (st == NULL) {
 		return luaL_argerror(L, 1, "Need a sproto_type object");
 	}
-	size_t sz=0;
-	const void * buffer = getbuffer(L, 2, &sz);
+	sz = 0;
+	buffer = getbuffer(L, 2, &sz);
 	if (!lua_istable(L, -1)) {
 		lua_newtable(L);
 	}
 	luaL_checkstack(L, ENCODE_DEEPLEVEL*2 + 8, NULL);
-	struct decode_ud self;
 	self.L = L;
 	self.result_index = lua_gettop(L);
 	self.array_index = 0;
 	self.array_tag = NULL;
 	self.deep = 0;
-	int r = sproto_decode(st, buffer, (int)sz, decode, &self);
+	r = sproto_decode(st, buffer, (int)sz, decode, &self);
 	if (r < 0) {
 		return luaL_error(L, "decode error");
 	}
@@ -359,11 +368,12 @@ lpack(lua_State *L) {
 	// the worst-case space overhead of packing is 2 bytes per 2 KiB of input (256 words = 2KiB).
 	size_t maxsz = (sz + 2047) / 2048 * 2 + sz;
 	void * output = lua_touserdata(L, lua_upvalueindex(1));
+	int bytes;
 	int osz = lua_tointeger(L, lua_upvalueindex(2));
 	if (osz < maxsz) {
 		output = expand_buffer(L, osz, maxsz);
 	}
-	int bytes = sproto_pack(buffer, sz, output, maxsz);
+	bytes = sproto_pack(buffer, sz, output, maxsz);
 	if (bytes > maxsz) {
 		return luaL_error(L, "packing error, return size = %d", bytes);
 	}
@@ -402,14 +412,18 @@ pushfunction_withbuffer(lua_State *L, const char * name, lua_CFunction func) {
 static int
 lprotocol(lua_State *L) {
 	struct sproto * sp = lua_touserdata(L, 1);
+	struct sproto_type * request;
+	struct sproto_type * response;
+	int t;
+	int tag;
 	if (sp == NULL) {
 		return luaL_argerror(L, 1, "Need a sproto_type object");
 	}
-	int t = lua_type(L,2);
-	int tag;
+	t = lua_type(L,2);
 	if (t == LUA_TNUMBER) {
+		const char * name;
 		tag = lua_tointeger(L, 2);
-		const char * name = sproto_protoname(sp, tag);
+		name = sproto_protoname(sp, tag);
 		if (name == NULL)
 			return 0;
 		lua_pushstring(L, name);
@@ -420,13 +434,13 @@ lprotocol(lua_State *L) {
 			return 0;
 		lua_pushinteger(L, tag);
 	}
-	struct sproto_type * request = sproto_protoquery(sp, tag, SPROTO_REQUEST);
+	request = sproto_protoquery(sp, tag, SPROTO_REQUEST);
 	if (request == NULL) {
 		lua_pushnil(L);
 	} else {
 		lua_pushlightuserdata(L, request);
 	}
-	struct sproto_type * response = sproto_protoquery(sp, tag, SPROTO_RESPONSE);
+	response = sproto_protoquery(sp, tag, SPROTO_RESPONSE);
 	if (response == NULL) {
 		lua_pushnil(L);
 	} else {
--- a/lualib-src/sproto/sproto.c
+++ b/lualib-src/sproto/sproto.c
@@ -119,8 +119,8 @@ todword(const uint8_t *p) {
 static int
 count_array(const uint8_t * stream) {
 	uint32_t length = todword(stream);
-	stream += SIZEOF_LENGTH;
 	int n = 0;
+	stream += SIZEOF_LENGTH;
 	while (length > 0) {
 		uint32_t nsz;
 		if (length < SIZEOF_LENGTH)
@@ -180,6 +180,10 @@ static const uint8_t *
 import_field(struct sproto *s, struct field *f, const uint8_t * stream) {
 	uint32_t sz;
 	const uint8_t * result;
+	int fn;
+	int i;
+	int array = 0;
+	int tag = -1;
 	f->tag = -1;
 	f->type = -1;
 	f->name = NULL;
@@ -188,13 +192,10 @@ import_field(struct sproto *s, struct field *f, const uint8_t * stream) {
 	sz = todword(stream);
 	stream += SIZEOF_LENGTH;
 	result = stream + sz;
-	int fn = struct_field(stream, sz);
+	fn = struct_field(stream, sz);
 	if (fn < 0)
 		return NULL;
 	stream += SIZEOF_HEADER;
-	int i;
-	int array = 0;
-	int tag = -1;
 	for (i=0;i<fn;i++) {
 		int value;
 		++tag;
@@ -203,7 +204,7 @@ import_field(struct sproto *s, struct field *f, const uint8_t * stream) {
 			tag+= value/2;
 			continue;
 		}
-		if (tag == 0) {	// name
+		if (tag == 0) { // name
 			if (value != 0)
 				return NULL;
 			f->name = import_string(s, stream + fn * SIZEOF_FIELD);
@@ -213,12 +214,12 @@ import_field(struct sproto *s, struct field *f, const uint8_t * stream) {
 			return NULL;
 		value = value/2 - 1;
 		switch(tag) {
-		case 1:	// buildin
+		case 1: // buildin
 			if (value >= SPROTO_TSTRUCT)
 				return NULL;	// invalid buildin type
 			f->type = value;
 			break;
-		case 2:	// type index
+		case 2: // type index
 			if (value >= s->type_n)
 				return NULL;	// invalid type index
 			if (f->type >= 0)
@@ -226,10 +227,10 @@ import_field(struct sproto *s, struct field *f, const uint8_t * stream) {
 			f->type = SPROTO_TSTRUCT;
 			f->st = &s->type[value];
 			break;
-		case 3:	// tag
+		case 3: // tag
 			f->tag = value;
 			break;
-		case 4:	// array
+		case 4: // array
 			if (value)
 				array = SPROTO_TARRAY;
 			break;
@@ -248,10 +249,10 @@ import_field(struct sproto *s, struct field *f, const uint8_t * stream) {
 .type {
 	.field {
 		name 0 : string
-		buildin	1 :	integer
+		buildin 1 : integer
 		type 2 : integer
-		tag	3 :	integer
-		array 4	: boolean
+		tag 3 : integer
+		array 4 : boolean
 	}
 	name 0 : string
 	fields 1 : *field
@@ -259,11 +260,16 @@ import_field(struct sproto *s, struct field *f, const uint8_t * stream) {
 */
 static const uint8_t *
 import_type(struct sproto *s, struct sproto_type *t, const uint8_t * stream) {
+	const uint8_t * result;
 	uint32_t sz = todword(stream);
 	int i;
+	int fn;
+	int n;
+	int maxn;
+	int last;
 	stream += SIZEOF_LENGTH;
-	const uint8_t * result = stream + sz;
-	int fn = struct_field(stream, sz);
+	result = stream + sz;
+	fn = struct_field(stream, sz);
 	if (fn <= 0 || fn > 2)
 		return NULL;
 	for (i=0;i<fn*SIZEOF_FIELD;i+=SIZEOF_FIELD) {
@@ -279,20 +285,21 @@ import_type(struct sproto *s, struct sproto_type *t, const uint8_t * stream) {
 		return result;
 	}
 	stream += todword(stream)+SIZEOF_LENGTH;	// second data
-	int n = count_array(stream);
+	n = count_array(stream);
 	if (n<0)
 		return NULL;
 	stream += SIZEOF_LENGTH;
-	int maxn = n;
-	int last = -1;
+	maxn = n;
+	last = -1;
 	t->n = n;
 	t->f = pool_alloc(&s->memory, sizeof(struct field) * n);
 	for (i=0;i<n;i++) {
+		int tag;
 		struct field *f = &t->f[i];
 		stream = import_field(s, f, stream);
 		if (stream == NULL)
 			return NULL;
-		int tag = f->tag;
+		tag = f->tag;
 		if (tag < last)
 			return NULL;	// tag must in ascending order
 		if (tag > last+1) {
@@ -312,24 +319,27 @@ import_type(struct sproto *s, struct sproto_type *t, const uint8_t * stream) {
 /*
 .protocol {
 	name 0 : string
-	tag	1 :	integer
-	request	2 :	integer
+	tag 1 : integer
+	request 2 : integer
 	response 3 : integer
 }
 */
 static const uint8_t *
 import_protocol(struct sproto *s, struct protocol *p, const uint8_t * stream) {
+	const uint8_t * result;
 	uint32_t sz = todword(stream);
+	int fn;
+	int i;
+	int tag;
 	stream += SIZEOF_LENGTH;
-	const uint8_t * result = stream + sz;
-	int fn = struct_field(stream, sz);
+	result = stream + sz;
+	fn = struct_field(stream, sz);
 	stream += SIZEOF_HEADER;
 	p->name = NULL;
 	p->tag = -1;
 	p->p[SPROTO_REQUEST] = NULL;
 	p->p[SPROTO_RESPONSE] = NULL;
-	int i;
-	int tag = 0;
+	tag = 0;
 	for (i=0;i<fn;i++,tag++) {
 		int value = toword(stream + SIZEOF_FIELD * i);
 		if (value & 1) {
@@ -338,24 +348,24 @@ import_protocol(struct sproto *s, struct protocol *p, const uint8_t * stream) {
 		}
 		value = value/2 - 1;
 		switch (i) {
-		case 0:	// name
+		case 0: // name
 			if (value != -1) {
 				return NULL;
 			}
 			p->name = import_string(s, stream + SIZEOF_FIELD *fn);
 			break;
-		case 1:	// tag
+		case 1: // tag
 			if (value < 0) {
 				return NULL;
 			}
 			p->tag = value;
 			break;
-		case 2:	// request
+		case 2: // request
 			if (value < 0 || value>=s->type_n)
 				return NULL;
 			p->p[SPROTO_REQUEST] = &s->type[value];
 			break;
-		case 3:	// response
+		case 3: // response
 			if (value < 0 || value>=s->type_n)
 				return NULL;
 			p->p[SPROTO_RESPONSE] = &s->type[value];
@@ -374,22 +384,23 @@ import_protocol(struct sproto *s, struct protocol *p, const uint8_t * stream) {

 static struct sproto *
 create_from_bundle(struct sproto *s, const uint8_t * stream, size_t sz) {
+	const uint8_t * content;
+	const uint8_t * typedata = NULL;
+	const uint8_t * protocoldata = NULL;
 	int fn = struct_field(stream, sz);
+	int i;
 	if (fn < 0)
 		return NULL;

 	stream += SIZEOF_HEADER;
+	content = stream + fn*SIZEOF_FIELD;

-	const uint8_t * content = stream + fn*SIZEOF_FIELD;
-	const uint8_t * typedata = NULL;
-	const uint8_t * protocoldata = NULL;
-
-	int i;
 	for (i=0;i<fn;i++) {
 		int value = toword(stream + i*SIZEOF_FIELD);
+		int n;
 		if (value != 0)
 			return NULL;
-		int n = count_array(content);
+		n = count_array(content);
 		if (n<0)
 			return NULL;
 		if (i == 0) {
@@ -423,8 +434,9 @@ create_from_bundle(struct sproto *s, const uint8_t * stream, size_t sz) {
 struct sproto *
 sproto_create(const void * proto, size_t sz) {
 	struct pool mem;
+	struct sproto * s;
 	pool_init(&mem);
-	struct sproto * s = pool_alloc(&mem, sizeof(*s));
+	s = pool_alloc(&mem, sizeof(*s));
 	if (s == NULL)
 		return NULL;
 	memset(s, 0, sizeof(*s));
@@ -445,34 +457,35 @@ sproto_release(struct sproto * s) {

 void
 sproto_dump(struct sproto *s) {
+	int i,j;
 	static const char * buildin[] = {
 		"integer",
 		"boolean",
 		"string",
 	};
 	printf("=== %d types ===\n", s->type_n);
-	int i,j;
 	for (i=0;i<s->type_n;i++) {
 		struct sproto_type *t = &s->type[i];
 		printf("%s\n", t->name);
 		for (j=0;j<t->n;j++) {
 			char array[2] = { 0, 0 };
-			const char * typename = NULL;
+			const char * type_name = NULL;
 			struct field *f = &t->f[j];
 			if (f->type & SPROTO_TARRAY) {
 				array[0] = '*';
 			} else {
 				array[0] = 0;
 			}
-			int t = f->type & ~SPROTO_TARRAY;
-			if (t == SPROTO_TSTRUCT) {
-				typename = f->st->name;
-			} else {
-				assert(t<SPROTO_TSTRUCT);
-				typename = buildin[t];
+			{
+				int t = f->type & ~SPROTO_TARRAY;
+				if (t == SPROTO_TSTRUCT) {
+					type_name = f->st->name;
+				} else {
+					assert(t<SPROTO_TSTRUCT);
+					type_name = buildin[t];
+				}
 			}
-
-			printf("\t%s (%d) %s%s\n", f->name, f->tag, array, typename);
+			printf("\t%s (%d) %s%s\n", f->name, f->tag, array, type_name);
 		}
 	}
 	printf("=== %d protocol ===\n", s->protocol_n);
@@ -487,7 +500,7 @@ sproto_dump(struct sproto *s) {
 }

 // query
-int 
+int
 sproto_prototag(struct sproto *sp, const char * name) {
 	int i;
 	for (i=0;i<sp->protocol_n;i++) {
@@ -516,19 +529,20 @@ query_proto(struct sproto *sp, int tag) {
 	return NULL;
 }

-struct sproto_type * 
+struct sproto_type *
 sproto_protoquery(struct sproto *sp, int proto, int what) {
+	struct protocol * p;
 	if (what <0 || what >1) {
 		return NULL;
 	}
-	struct protocol * p = query_proto(sp, proto);
+	p = query_proto(sp, proto);
 	if (p) {
 		return p->p[what];
 	}
 	return NULL;
 }

-const char * 
+const char *
 sproto_protoname(struct sproto *sp, int proto) {
 	struct protocol * p = query_proto(sp, proto);
 	if (p) {
@@ -537,7 +551,7 @@ sproto_protoname(struct sproto *sp, int proto) {
 	return NULL;
 }

-struct sproto_type * 
+struct sproto_type *
 sproto_type(struct sproto *sp, const char * type_name) {
 	int i;
 	for (i=0;i<sp->type_n;i++) {
@@ -555,13 +569,15 @@ sproto_name(struct sproto_type * st) {

 static struct field *
 findtag(struct sproto_type *st, int tag) {
+	int begin, end;
 	if (st->base >=0 ) {
 		tag -= st->base;
 		if (tag < 0 || tag >= st->n)
 			return NULL;
 		return &st->f[tag];
 	}
-	int begin = 0, end = st->n;
+	begin = 0;
+	end = st->n;
 	while (begin < end) {
 		int mid = (begin+end)/2;
 		struct field *f = &st->f[mid];
@@ -580,7 +596,7 @@ findtag(struct sproto_type *st, int tag) {

 // encode & decode
 // sproto_callback(void *ud, int tag, int type, struct sproto_type *, void *value, int length)
-//		return size, -1 means error
+//	  return size, -1 means error

 static inline int
 fill_size(uint8_t * data, int sz) {
@@ -623,18 +639,20 @@ encode_uint64(uint64_t v, uint8_t * data, int size) {

 static int
 encode_string(sproto_callback cb, void *ud, struct field *f, uint8_t *data, int size) {
+	int sz;
 	if (size < SIZEOF_LENGTH)
 		return -1;
-	int sz = cb(ud, f->name, SPROTO_TSTRING, 0, NULL, data+SIZEOF_LENGTH, size-SIZEOF_LENGTH);
+	sz = cb(ud, f->name, SPROTO_TSTRING, 0, NULL, data+SIZEOF_LENGTH, size-SIZEOF_LENGTH);
 	return fill_size(data, sz);
 }

 static int
 encode_struct(sproto_callback cb, void *ud, struct field *f, uint8_t *data, int size) {
+	int sz;
 	if (size < SIZEOF_LENGTH) {
 		return -1;
 	}
-	int sz = cb(ud, f->name, SPROTO_TSTRUCT, 0, f->st, data+SIZEOF_LENGTH, size-SIZEOF_LENGTH);
+	sz = cb(ud, f->name, SPROTO_TSTRUCT, 0, f->st, data+SIZEOF_LENGTH, size-SIZEOF_LENGTH);
 	return fill_size(data, sz);
 }

@@ -656,18 +674,21 @@ uint32_to_uint64(int negative, uint8_t *buffer) {
 static uint8_t *
 encode_integer_array(sproto_callback cb, void *ud, struct field *f, uint8_t *buffer, int size) {
 	uint8_t * header = buffer;
+	int intlen;
+	int index;
 	if (size < 1)
 		return NULL;
 	buffer++;
 	size--;
-	int intlen = sizeof(uint32_t);
-	int index = 1;
+	intlen = sizeof(uint32_t);
+	index = 1;
 	for (;;) {
+		int sz;
 		union {
 			uint64_t u64;
 			uint32_t u32;
 		} u;
-		int sz = cb(ud, f->name, SPROTO_TINTEGER, index, f->st, &u, sizeof(u));
+		sz = cb(ud, f->name, SPROTO_TINTEGER, index, f->st, &u, sizeof(u));
 		if (sz < 0)
 			return NULL;
 		if (sz == 0)
@@ -685,24 +706,26 @@ encode_integer_array(sproto_callback cb, void *ud, struct field *f, uint8_t *buf
 				uint32_to_uint64(v & 0x80000000, buffer);
 			}
 		} else {
+			uint64_t v;
 			if (sz != sizeof(uint64_t))
 				return NULL;
 			if (intlen == sizeof(uint32_t)) {
+				int i;
 				// rearrange
 				size -= (index-1) * sizeof(uint32_t);
 				if (size < sizeof(uint64_t))
 					return NULL;
 				buffer += (index-1) * sizeof(uint32_t);
-				int i;
 				for (i=index-2;i>=0;i--) {
+					int negative;
 					memcpy(header+1+i*sizeof(uint64_t), header+1+i*sizeof(uint32_t), sizeof(uint32_t));
-					int negative = header[1+i*sizeof(uint64_t)+3] & 0x80;
+					negative = header[1+i*sizeof(uint64_t)+3] & 0x80;
 					uint32_to_uint64(negative, header+1+i*sizeof(uint64_t));
 				}
 				intlen = sizeof(uint64_t);
 			}

-			uint64_t v = u.u64;
+			v = u.u64;
 			buffer[0] = v & 0xff;
 			buffer[1] = (v >> 8) & 0xff;
 			buffer[2] = (v >> 16) & 0xff;
@@ -727,12 +750,16 @@ encode_integer_array(sproto_callback cb, void *ud, struct field *f, uint8_t *buf

 static int
 encode_array(sproto_callback cb, void *ud, struct field *f, uint8_t *data, int size) {
+	uint8_t * buffer;
+	int index;
+	int type;
+	int sz;
 	if (size < SIZEOF_LENGTH)
 		return -1;
 	size -= SIZEOF_LENGTH;
-	int index = 1;
-	uint8_t * buffer = data + SIZEOF_LENGTH;
-	int type = f->type & ~SPROTO_TARRAY;
+	index = 1;
+	buffer = data + SIZEOF_LENGTH;
+	type = f->type & ~SPROTO_TARRAY;
 	switch (type) {
 	case SPROTO_TINTEGER:
 		buffer = encode_integer_array(cb,ud,f,buffer,size);
@@ -757,10 +784,11 @@ encode_array(sproto_callback cb, void *ud, struct field *f, uint8_t *data, int s
 		break;
 	default:
 		for (;;) {
+			int sz;
 			if (size < SIZEOF_LENGTH)
 				return -1;
 			size -= SIZEOF_LENGTH;
-			int sz = cb(ud, f->name, type, index, f->st, buffer+SIZEOF_LENGTH, size);
+			sz = cb(ud, f->name, type, index, f->st, buffer+SIZEOF_LENGTH, size);
 			if (sz < 0)
 				return -1;
 			if (sz == 0)
@@ -772,24 +800,27 @@ encode_array(sproto_callback cb, void *ud, struct field *f, uint8_t *data, int s
 		}
 		break;
 	}
-	int sz = buffer - (data + SIZEOF_LENGTH);
+	sz = buffer - (data + SIZEOF_LENGTH);
 	if (sz == 0)
 		return 0;
 	return fill_size(data, sz);
 }

-int 
+int
 sproto_encode(struct sproto_type *st, void * buffer, int size, sproto_callback cb, void *ud) {
 	uint8_t * header = buffer;
 	uint8_t * data;
 	int header_sz = SIZEOF_HEADER + st->maxn * SIZEOF_FIELD;
+	int i;
+	int index;
+	int lasttag;
+	int datasz;
 	if (size < header_sz)
 		return -1;
 	data = header + header_sz;
 	size -= header_sz;
-	int i;
-	int index = 0;
-	int lasttag = -1;
+	index = 0;
+	lasttag = -1;
 	for (i=0;i<st->n;i++) {
 		struct field *f = &st->f[i];
 		int type = f->type;
@@ -799,7 +830,7 @@ sproto_encode(struct sproto_type *st, void * buffer, int size, sproto_callback c
 			sz = encode_array(cb,ud, f, data, size);
 		} else {
 			switch(type) {
-			case SPROTO_TINTEGER: 
+			case SPROTO_TINTEGER:
 			case SPROTO_TBOOLEAN: {
 				union {
 					uint64_t u64;
@@ -813,7 +844,7 @@ sproto_encode(struct sproto_type *st, void * buffer, int size, sproto_callback c
 				if (sz == sizeof(uint32_t)) {
 					if (u.u32 < 0x7fff) {
 						value = (u.u32+1) * 2;
-						sz = 2;	// sz can be any number > 0
+						sz = 2; // sz can be any number > 0
 					} else {
 						sz = encode_integer(u.u32, data, size);
 					}
@@ -837,12 +868,14 @@ sproto_encode(struct sproto_type *st, void * buffer, int size, sproto_callback c
 		if (sz < 0)
 			return -1;
 		if (sz > 0) {
+			uint8_t * record;
+			int tag;
 			if (value == 0) {
 				data += sz;
 				size -= sz;
 			}
-			uint8_t * record = header+SIZEOF_HEADER+SIZEOF_FIELD*index;
-			int tag = f->tag - lasttag - 1;
+			record = header+SIZEOF_HEADER+SIZEOF_FIELD*index;
+			tag = f->tag - lasttag - 1;
 			if (tag > 0) {
 				// skip tag
 				tag = (tag - 1) * 2 + 1;
@@ -862,7 +895,7 @@ sproto_encode(struct sproto_type *st, void * buffer, int size, sproto_callback c
 	header[0] = index & 0xff;
 	header[1] = (index >> 8) & 0xff;

-	int datasz = data - (header + header_sz);
+	datasz = data - (header + header_sz);
 	data = header + header_sz;
 	if (index != st->maxn) {
 		memmove(header + SIZEOF_HEADER + index * SIZEOF_FIELD, data, datasz);
@@ -909,9 +942,10 @@ decode_array(sproto_callback cb, void *ud, struct field *f, uint8_t * stream) {
 	stream += SIZEOF_LENGTH;
 	switch (type) {
 	case SPROTO_TINTEGER: {
+		int len;
 		if (sz < 1)
 			return -1;
-		int len = *stream;
+		len = *stream;
 		++stream;
 		--sz;
 		if (len == sizeof(uint32_t)) {
@@ -937,7 +971,7 @@ decode_array(sproto_callback cb, void *ud, struct field *f, uint8_t * stream) {
 	}
 	case SPROTO_TBOOLEAN:
 		for (i=0;i<sz;i++) {
-			int value = stream[i];
+			uint64_t value = stream[i];
 			cb(ud, f->name, SPROTO_TBOOLEAN, i+1, NULL, &value, sizeof(value));
 		}
 		break;
@@ -956,6 +990,8 @@ sproto_decode(struct sproto_type *st, const void * data, int size, sproto_callba
 	uint8_t * stream;
 	uint8_t * datastream;
 	int fn;
+	int i;
+	int tag;
 	if (size < SIZEOF_HEADER)
 		return -1;
 	stream = (void *)data;
@@ -967,17 +1003,18 @@ sproto_decode(struct sproto_type *st, const void * data, int size, sproto_callba
 	datastream = stream + fn * SIZEOF_FIELD;
 	size -= fn * SIZEOF_FIELD ;

-	int i;
-	int tag = -1;
+	tag = -1;
 	for (i=0;i<fn;i++) {
-		++ tag;
+		uint8_t * currentdata;
+		struct field * f;
 		int value = toword(stream + i * SIZEOF_FIELD);
+		++ tag;
 		if (value & 1) {
 			tag += value/2;
 			continue;
 		}
 		value = value/2 - 1;
-		uint8_t * currentdata = datastream;
+		currentdata = datastream;
 		if (value < 0) {
 			uint32_t sz;
 			if (size < SIZEOF_LENGTH)
@@ -988,7 +1025,7 @@ sproto_decode(struct sproto_type *st, const void * data, int size, sproto_callba
 			datastream += sz+SIZEOF_LENGTH;
 			size -= sz+SIZEOF_LENGTH;
 		}
-		struct field * f= findtag(st, tag);
+		f = findtag(st, tag);
 		if (f == NULL)
 			continue;
 		if (value < 0) {
@@ -1013,7 +1050,7 @@ sproto_decode(struct sproto_type *st, const void * data, int size, sproto_callba
 					}
 					break;
 				}
-				case SPROTO_TSTRING: 
+				case SPROTO_TSTRING:
 				case SPROTO_TSTRUCT: {
 					uint32_t sz = todword(currentdata);
 					if (cb(ud, f->name, f->type, 0, f->st, currentdata+SIZEOF_LENGTH, sz))
@@ -1087,7 +1124,7 @@ write_ff(const uint8_t * src, uint8_t * des, int n) {
 	}
 }

-int 
+int
 sproto_pack(const void * srcv, int srcsz, void * bufferv, int bufsz) {
 	uint8_t tmp[8];
 	int i;
@@ -1144,7 +1181,7 @@ sproto_pack(const void * srcv, int srcsz, void * bufferv, int bufsz) {
 	return size;
 }

-int 
+int
 sproto_unpack(const void * srcv, int srcsz, void * bufferv, int bufsz) {
 	const uint8_t * src = srcv;
 	uint8_t * buffer = bufferv;
--- a/lualib/http/httpd.lua
+++ b/lualib/http/httpd.lua
@@ -83,7 +83,7 @@ local function readall(readbytes, bodylimit)
 	else
 		-- identity mode
 		if length then
-			if length > bodylimit then
+			if bodylimit and length > bodylimit then
 				return 413
 			end
 			if #body >= length then
@@ -130,6 +130,7 @@ local function writeall(writefunc, statuscode, bodyfunc, header)
 				end
 			else
 				writefunc("\r\n0\r\n\r\n")
+				break
 			end
 		end
 	else
--- a/lualib/mongo.lua
+++ b/lualib/mongo.lua
@@ -120,6 +120,8 @@ function mongo.client( conf	)
 	local obj =	{
 		host = first.host,
 		port = first.port or 27017,
+		username = first.username,
+		password = first.password,
 	}

 	obj.__id = 0
@@ -227,7 +229,11 @@ function mongo_collection:insert(doc)
 	sock:request(pack)
 end

-function mongo_collection:batch_insert(docs)
+function mongo_collection:safe_insert(doc)
+	return self.database:runCommand("insert", self.name, "documents", {bson_encode(doc)})	
+end
+
+function mongo_collection:batch_insert(docs)		
 	for	i=1,#docs do
 		if docs[i]._id == nil then
 			docs[i]._id	= bson.objectid()
@@ -276,6 +282,48 @@ function mongo_collection:find(query, selector)
 	} ,	cursor_meta)
 end

+-- collection:createIndex({username = 1}, {unique = true})
+function mongo_collection:createIndex(keys, option)
+	local name
+	for k, v in pairs(keys) do
+		assert(v == 1)
+		name = (name == nil) and k or (name .. "_" .. k)
+	end
+
+	local doc = {};
+	doc.name = name
+	doc.key = keys
+	for k, v in pairs(option) do
+		if v then
+			doc[k] = true
+		end
+	end
+	return self.database:runCommand("createIndexes", self.name, "indexes", {doc})
+end
+
+mongo_collection.ensureIndex = mongo_collection.createIndex;
+
+-- collection:findAndModify({query = {name = "userid"}, update = {["$inc"] = {nextid = 1}}, })
+-- keys, value type
+-- query, table	
+-- sort, table
+-- remove, bool 
+-- update, table 
+-- new, bool 
+-- fields, bool 
+-- upsert, boolean 
+function mongo_collection:findAndModify(doc)
+	assert(doc.query)
+	assert(doc.update or doc.remove)
+
+	local cmd = {"findAndModify", self.name};
+	for k, v in pairs(doc) do
+		table.insert(cmd, k)
+		table.insert(cmd, v)
+	end
+	return self.database:runCommand(unpack(cmd))
+end
+
 function mongo_cursor:hasNext()
 	if self.__ptr == nil then
 		if self.__document == nil then
--- a/lualib/mysql.lua
+++ b/lualib/mysql.lua
@@ -6,7 +6,7 @@
 local socketchannel = require "socketchannel"
 local bit = require "bit32"
 local mysqlaux = require "mysqlaux.c"
-
+local crypt = require "crypt"


 local sub = string.sub
@@ -20,7 +20,7 @@ local bxor = bit.bxor
 local bor = bit.bor
 local lshift = bit.lshift
 local rshift = bit.rshift
-local sha1= mysqlaux.sha1_bin
+local sha1= crypt.sha1
 local concat = table.concat
 local unpack = unpack
 local setmetatable = setmetatable
--- a/lualib/snax.lua
+++ b/lualib/snax.lua
@@ -132,6 +132,14 @@ function snax.kill(obj, ...)
 	skynet_call(obj.handle, "snax", t.system.exit, ...)
 end

+function snax.self()
+	return snax.bind(skynet.self(), SERVICE_NAME)
+end
+
+function snax.exit(...)
+	snax.kill(snax.self(), ...)
+end
+
 local function test_result(ok, ...)
 	if ok then
 		return ...
--- a/lualib/snax/gateserver.lua
+++ b/lualib/snax/gateserver.lua
@@ -53,20 +53,32 @@ function gateserver.start(handler)

 	local MSG = {}

-	function MSG.data(fd, msg, sz)
+	local function dispatch_msg(fd, msg, sz)
 		if connection[fd] then
 			handler.message(fd, msg, sz)
+		else
+			skynet.error(string.format("Drop message from fd (%d) : %s", fd, netpack.tostring(msg,sz)))
 		end
 	end

-	function MSG.more()
-		for fd, msg, sz in netpack.pop, queue do
-			if connection[fd] then
-				handler.message(fd, msg, sz)
+	MSG.data = dispatch_msg
+
+	local function dispatch_queue()
+		local fd, msg, sz = netpack.pop(queue)
+		if fd then
+			-- may dispatch even the handler.message blocked
+			-- If the handler.message never block, the queue should be empty, so only fork once and then exit.
+			skynet.fork(dispatch_queue)
+			dispatch_msg(fd, msg, sz)
+
+			for fd, msg, sz in netpack.pop, queue do
+				dispatch_msg(fd, msg, sz)
 			end
 		end
 	end

+	MSG.more = dispatch_queue
+
 	function MSG.open(fd, msg)
 		if client_number >= maxclient then
 			socketdriver.close(fd)
@@ -128,4 +140,4 @@ function gateserver.start(handler)
 	end)
 end

-return gateserver
+return gateserver
--- a/lualib/snax/loginserver.lua
+++ b/lualib/snax/loginserver.lua
@@ -90,7 +90,7 @@ local function launch_slave(auth_handler)
 	local function ret_pack(ok, err, ...)
 		if ok then
 			skynet.ret(skynet.pack(err, ...))
-		elseif err ~= socket_error then
+		else
 			error(err)
 		end
 	end
@@ -163,6 +163,7 @@ local function launch_master(conf)
 			if err ~= socket_error then
 				skynet.error(string.format("invalid client (fd = %d) error = %s", fd, err))
 			end
+			socket.start(fd)
 		end
 		socket.close(fd)
 	end)
--- a/lualib/socket.lua
+++ b/lualib/socket.lua
@@ -119,12 +119,23 @@ socket_message[5] = function(id)
 	wakeup(s)
 end

+-- SKYNET_SOCKET_TYPE_UDP = 6
+socket_message[6] = function(id, size, data, address)
+	local s = socket_pool[id]
+	if s == nil or s.callback == nil then
+		skynet.error("socket: drop udp package from " .. id)
+		driver.drop(data, size)
+		return
+	end
+	s.callback(data, size, address)
+end
+
 skynet.register_protocol {
 	name = "socket",
 	id = skynet.PTYPE_SOCKET,	-- PTYPE_SOCKET = 6
 	unpack = driver.unpack,
-	dispatch = function (_, _, t, n1, n2, data)
-		socket_message[t](n1,n2,data)
+	dispatch = function (_, _, t, ...)
+		socket_message[t](...)
 	end
 }

@@ -137,9 +148,10 @@ local function connect(id, func)
 		id = id,
 		buffer = newbuffer,
 		connected = false,
-		read_require = false,
+		read_required = false,
 		co = false,
 		callback = func,
+		protocol = "TCP",
 	}
 	socket_pool[id] = s
 	suspend(s)
@@ -354,4 +366,39 @@ function socket.limit(id, limit)
 	s.buffer_limit = limit
 end

+---------------------- UDP
+
+local udp_socket = {}
+
+local function create_udp_object(id, cb)
+	socket_pool[id] = {
+		id = id,
+		connected = true,
+		protocol = "UDP",
+		callback = cb,
+	}
+end
+
+function socket.udp(callback, host, port)
+	local id = driver.udp(host, port)
+	create_udp_object(id, callback)
+	return id
+end
+
+function socket.udp_connect(id, addr, port, callback)
+	local obj = socket_pool[id]
+	if obj then
+		assert(obj.protocol == "UDP")
+		if callback then
+			obj.callback = callback
+		end
+	else
+		create_udp_object(id, callback)
+	end
+	driver.udp_connect(id, addr, port)
+end
+
+socket.sendto = assert(driver.udp_send)
+socket.udp_address = assert(driver.udp_address)
+
 return socket
--- a/service-src/service_harbor.c
+++ b/service-src/service_harbor.c
@@ -316,6 +316,7 @@ forward_local_messsage(struct harbor *h, void *msg, int sz) {
 	destination = (destination & HANDLE_MASK) | ((uint32_t)h->id << HANDLE_REMOTE_SHIFT);

 	if (skynet_send(h->ctx, header.source, destination, type, (int)header.session, (void *)msg, sz-HEADER_COOKIE_LENGTH) < 0) {
+		skynet_send(h->ctx, destination, header.source , PTYPE_ERROR, (int)header.session, NULL, 0);
 		skynet_error(h->ctx, "Unknown destination :%x from :%x", destination, header.source);
 	}
 }
--- a/service/snaxd.lua
+++ b/service/snaxd.lua
@@ -12,10 +12,6 @@ package.path = snax_path .. "?.lua;" .. package.path
 SERVICE_NAME = snax_name
 SERVICE_PATH = snax_path

-local mode
-local thread_id
-local message_queue = {}
-local init = false
 local profile_table = {}

 local function update_stat(name, ti)
@@ -38,57 +34,6 @@ local function dispatch(f, ...)
 	return skynet.pack(f(...))
 end

-local function message_dispatch()
-	while true do
-		if #message_queue==0 then
-			thread_id = coroutine.running()
-			skynet.wait()
-		else
-			local msg = table.remove(message_queue,1)
-			local method = msg.method
-			local f = method[4]
-			if f then
-				if method[2] == "accept" then
-					-- no return
-					profile.start()
-					local ok, data = xpcall(f, traceback, table.unpack(msg))
-					local ti = profile.stop()
-					update_stat(method[3], ti)
-					if not ok then
-						print(string.format("Error on [:%x] to [:%x] %s", msg.source, skynet.self(), tostring(data)))
-					end
-				else
-					profile.start()
-					local ok, data, size = xpcall(dispatch, traceback, f, table.unpack(msg))
-					local ti = profile.stop()
-					update_stat(method[3], ti)
-					if ok then
-						-- skynet.PTYPE_RESPONSE == 1
-						c.send(msg.source, 1, msg.session, data, size)
-						if method[2] == "system" then
-							init = false
-							skynet.exit()
-							break
-						end
-					else
-						-- Can't throw error, so print it directly
-						print(string.format("Error on [:%x] to [:%x] %s", msg.source, skynet.self(), tostring(data)))
-						c.send(msg.source, skynet.PTYPE_ERROR, msg.session, "")
-					end
-				end
-			end
-		end
-	end
-end
-
-local function queue( session, source, method, ...)
-	table.insert(message_queue, {session = session, source = source, method = method, ... })
-	if thread_id then
-		skynet.wakeup(thread_id)
-		thread_id = nil
-	end
-end
-
 local function return_f(f, ...)
 	return skynet.ret(skynet.pack(f(...)))
 end
@@ -108,6 +53,7 @@ local function timing( method, ... )
 end

 skynet.start(function()
+	local init = false
 	skynet.dispatch("snax", function ( session , source , id, ...)
 		local method = func[id]

@@ -119,17 +65,12 @@ skynet.start(function()
 			elseif command == "init" then
 				assert(not init, "Already init")
 				local initfunc = method[4] or function() end
-				mode = initfunc(...)
-				if mode == "queue" then
-					skynet.fork(message_dispatch)
-				end
+				initfunc(...)
 				skynet.ret()
 				skynet.info_func(function()
 					return profile_table
 				end)
 				init = true
-			elseif mode == "queue" then
-				queue( session, source, method , ...)
 			else
 				assert(init, "Never init")
 				assert(command == "exit")
@@ -141,11 +82,7 @@ skynet.start(function()
 			end
 		else
 			assert(init, "Init first")
-			if mode == "queue" then
-				queue(session, source, method , ...)
-			else
-				timing(method, ...)
-			end
+			timing(method, ...)
 		end
 	end)
 end)
--- a/skynet-src/skynet_mq.c
+++ b/skynet-src/skynet_mq.c
@@ -32,12 +32,9 @@ struct message_queue {
 };

 struct global_queue {
-	uint32_t head;
-	uint32_t tail;
-	struct message_queue ** queue;
-	// We use a separated flag array to ensure the mq is pushed.
-	// See the comments below.
-	struct message_queue *list;
+	struct message_queue *head;
+	struct message_queue *tail;
+	int lock;
 };

 static struct global_queue *Q = NULL;
@@ -51,57 +48,32 @@ void
 skynet_globalmq_push(struct message_queue * queue) {
 	struct global_queue *q= Q;

-	uint32_t tail = GP(__sync_fetch_and_add(&q->tail,1));
-
-	// only one thread can set the slot (change q->queue[tail] from NULL to queue)
-	if (!__sync_bool_compare_and_swap(&q->queue[tail], NULL, queue)) {
-		// The queue may full seldom, save queue in list
-		assert(queue->next == NULL);
-		struct message_queue * last;
-		do {
-			last = q->list;
-			queue->next = last;
-		} while(!__sync_bool_compare_and_swap(&q->list, last, queue));
-
-		return;
+	LOCK(q)
+	assert(queue->next == NULL);
+	if(q->tail) {
+		q->tail->next = queue;
+		q->tail = queue;
+	} else {
+		q->head = q->tail = queue;
 	}
+	UNLOCK(q)
 }

 struct message_queue * 
 skynet_globalmq_pop() {
 	struct global_queue *q = Q;
-	uint32_t head =  q->head;

-	if (head == q->tail) {
-		// The queue is empty.
-		return NULL;
-	}
-
-	uint32_t head_ptr = GP(head);
-
-	struct message_queue * list = q->list;
-	if (list) {
-		// If q->list is not empty, try to load it back to the queue
-		struct message_queue *newhead = list->next;
-		if (__sync_bool_compare_and_swap(&q->list, list, newhead)) {
-			// try load list only once, if success , push it back to the queue.
-			list->next = NULL;
-			skynet_globalmq_push(list);
+	LOCK(q)
+	struct message_queue *mq = q->head;
+	if(mq) {
+		q->head = mq->next;
+		if(q->head == NULL) {
+			assert(mq == q->tail);
+			q->tail = NULL;
 		}
+		mq->next = NULL;
 	}
-
-	struct message_queue * mq = q->queue[head_ptr];
-	if (mq == NULL) {
-		// globalmq push not complete
-		return NULL;
-	}
-	if (!__sync_bool_compare_and_swap(&q->head, head, head+1)) {
-		return NULL;
-	}
-	// only one thread can get the slot (change q->queue[head_ptr] to NULL)
-	if (!__sync_bool_compare_and_swap(&q->queue[head_ptr], mq, NULL)) {
-		return NULL;
-	}
+	UNLOCK(q)

 	return mq;
 }
@@ -243,8 +215,6 @@ void
 skynet_mq_init() {
 	struct global_queue *q = skynet_malloc(sizeof(*q));
 	memset(q,0,sizeof(*q));
-	q->queue = skynet_malloc(MAX_GLOBAL_MQ * sizeof(struct message_queue *));
-	memset(q->queue, 0, sizeof(struct message_queue *) * MAX_GLOBAL_MQ);
 	Q=q;
 }

--- a/skynet-src/skynet_server.c
+++ b/skynet-src/skynet_server.c
@@ -169,7 +169,11 @@ skynet_context_new(const char * name, const char *param) {
 int
 skynet_context_newsession(struct skynet_context *ctx) {
 	// session always be a positive number
-	int session = (++ctx->session_id) & 0x7fffffff;
+	int session = ++ctx->session_id;
+	if (session <= 0) {
+		ctx->session_id = 1;
+		return 1;
+	}
 	return session;
 }

@@ -691,7 +695,7 @@ skynet_sendname(struct skynet_context * context, uint32_t source, const char * a
 			if (type & PTYPE_TAG_DONTCOPY) {
 				skynet_free(data);
 			}
-			return session;
+			return -1;
 		}
 	} else {
 		_filter_args(context, type, &session, (void **)&data, &sz);
--- a/skynet-src/skynet_socket.c
+++ b/skynet-src/skynet_socket.c
@@ -61,6 +61,7 @@ forward_message(int type, bool padding, struct socket_message * result) {
 	if (skynet_context_push((uint32_t)result->opaque, &message)) {
 		// todo: report somewhere to close socket
 		// don't call skynet_socket_close here (It will block mainloop)
+		skynet_free(sm->buffer);
 		skynet_free(sm);
 	}
 }
@@ -90,6 +91,9 @@ skynet_socket_poll() {
 	case SOCKET_ACCEPT:
 		forward_message(SKYNET_SOCKET_TYPE_ACCEPT, true, &result);
 		break;
+	case SOCKET_UDP:
+		forward_message(SKYNET_SOCKET_TYPE_UDP, false, &result);
+		break;
 	default:
 		skynet_error(NULL, "Unknown socket message type %d.",type);
 		return -1;
@@ -100,9 +104,8 @@ skynet_socket_poll() {
 	return 1;
 }

-int
-skynet_socket_send(struct skynet_context *ctx, int id, void *buffer, int sz) {
-	int64_t wsz = socket_server_send(SOCKET_SERVER, id, buffer, sz);
+static int
+check_wsz(struct skynet_context *ctx, int id, void *buffer, int64_t wsz) {
 	if (wsz < 0) {
 		skynet_free(buffer);
 		return -1;
@@ -115,6 +118,12 @@ skynet_socket_send(struct skynet_context *ctx, int id, void *buffer, int sz) {
 	return 0;
 }

+int
+skynet_socket_send(struct skynet_context *ctx, int id, void *buffer, int sz) {
+	int64_t wsz = socket_server_send(SOCKET_SERVER, id, buffer, sz);
+	return check_wsz(ctx, id, buffer, wsz);
+}
+
 void
 skynet_socket_send_lowpriority(struct skynet_context *ctx, int id, void *buffer, int sz) {
 	socket_server_send_lowpriority(SOCKET_SERVER, id, buffer, sz);
@@ -154,3 +163,33 @@ void
 skynet_socket_nodelay(struct skynet_context *ctx, int id) {
 	socket_server_nodelay(SOCKET_SERVER, id);
 }
+
+int 
+skynet_socket_udp(struct skynet_context *ctx, const char * addr, int port) {
+	uint32_t source = skynet_context_handle(ctx);
+	return socket_server_udp(SOCKET_SERVER, source, addr, port);
+}
+
+int 
+skynet_socket_udp_connect(struct skynet_context *ctx, int id, const char * addr, int port) {
+	return socket_server_udp_connect(SOCKET_SERVER, id, addr, port);
+}
+
+int 
+skynet_socket_udp_send(struct skynet_context *ctx, int id, const char * address, const void *buffer, int sz) {
+	int64_t wsz = socket_server_udp_send(SOCKET_SERVER, id, (const struct socket_udp_address *)address, buffer, sz);
+	return check_wsz(ctx, id, (void *)buffer, wsz);
+}
+
+const char *
+skynet_socket_udp_address(struct skynet_socket_message *msg, int *addrsz) {
+	if (msg->type != SKYNET_SOCKET_TYPE_UDP) {
+		return NULL;
+	}
+	struct socket_message sm;
+	sm.id = msg->id;
+	sm.opaque = 0;
+	sm.ud = msg->ud;
+	sm.data = msg->buffer;
+	return (const char *)socket_server_udp_address(SOCKET_SERVER, &sm, addrsz);
+}
--- a/skynet-src/skynet_socket.h
+++ b/skynet-src/skynet_socket.h
@@ -8,6 +8,7 @@ struct skynet_context;
 #define SKYNET_SOCKET_TYPE_CLOSE 3
 #define SKYNET_SOCKET_TYPE_ACCEPT 4
 #define SKYNET_SOCKET_TYPE_ERROR 5
+#define SKYNET_SOCKET_TYPE_UDP 6

 struct skynet_socket_message {
 	int type;
@@ -30,4 +31,9 @@ void skynet_socket_close(struct skynet_context *ctx, int id);
 void skynet_socket_start(struct skynet_context *ctx, int id);
 void skynet_socket_nodelay(struct skynet_context *ctx, int id);

+int skynet_socket_udp(struct skynet_context *ctx, const char * addr, int port);
+int skynet_socket_udp_connect(struct skynet_context *ctx, int id, const char * addr, int port);
+int skynet_socket_udp_send(struct skynet_context *ctx, int id, const char * address, const void *buffer, int sz);
+const char * skynet_socket_udp_address(struct skynet_socket_message *, int *addrsz);
+
 #endif
--- a/skynet-src/socket_server.c
+++ b/skynet-src/socket_server.c
@@ -37,27 +37,44 @@

 #define HASH_ID(id) (((unsigned)id) % MAX_SOCKET)

+#define PROTOCOL_TCP 0
+#define PROTOCOL_UDP 1
+#define PROTOCOL_UDPv6 2
+
+#define UDP_ADDRESS_SIZE 19	// ipv6 128bit + port 16bit + 1 byte type
+
+#define MAX_UDP_PACKAGE 65535
+
 struct write_buffer {
 	struct write_buffer * next;
+	void *buffer;
 	char *ptr;
 	int sz;
-	void *buffer;
+	bool userobject;
+	uint8_t udp_address[UDP_ADDRESS_SIZE];
 };

+#define SIZEOF_TCPBUFFER (offsetof(struct write_buffer, udp_address[0]))
+#define SIZEOF_UDPBUFFER (sizeof(struct write_buffer))
+
 struct wb_list {
 	struct write_buffer * head;
 	struct write_buffer * tail;
 };

 struct socket {
-	int fd;
-	int id;
-	int type;
-	int size;
-	int64_t wb_size;
 	uintptr_t opaque;
 	struct wb_list high;
 	struct wb_list low;
+	int64_t wb_size;
+	int fd;
+	int id;
+	uint16_t protocol;
+	uint16_t type;
+	union {
+		int size;
+		uint8_t udp_address[UDP_ADDRESS_SIZE];
+	} p;
 };

 struct socket_server {
@@ -68,9 +85,11 @@ struct socket_server {
 	int alloc_id;
 	int event_n;
 	int event_index;
+	struct socket_object_interface soi;
 	struct event ev[MAX_EVENT];
 	struct socket slot[MAX_SOCKET];
 	char buffer[MAX_INFO];
+	uint8_t udpbuffer[MAX_UDP_PACKAGE];
 	fd_set rfds;
 };

@@ -87,6 +106,16 @@ struct request_send {
 	char * buffer;
 };

+struct request_send_udp {
+	struct request_send send;
+	uint8_t address[UDP_ADDRESS_SIZE];
+};
+
+struct request_setudp {
+	int id;
+	uint8_t address[UDP_ADDRESS_SIZE];
+};
+
 struct request_close {
 	int id;
 	uintptr_t opaque;
@@ -116,17 +145,44 @@ struct request_setopt {
 	int value;
 };

+struct request_udp {
+	int id;
+	int fd;
+	int family;
+	uintptr_t opaque;
+};
+
+/*
+	The first byte is TYPE
+
+	S Start socket
+	B Bind socket
+	L Listen socket
+	K Close socket
+	O Connect to (Open)
+	X Exit
+	D Send package (high)
+	P Send package (low)
+	A Send UDP package
+	T Set opt
+	U Create UDP socket
+	C set udp address
+ */
+
 struct request_package {
 	uint8_t header[8];	// 6 bytes dummy
 	union {
 		char buffer[256];
 		struct request_open open;
 		struct request_send send;
+		struct request_send_udp send_udp;
 		struct request_close close;
 		struct request_listen listen;
 		struct request_bind bind;
 		struct request_start start;
 		struct request_setopt setopt;
+		struct request_udp udp;
+		struct request_setudp set_udp;
 	} u;
 	uint8_t dummy[256];
 };
@@ -137,9 +193,40 @@ union sockaddr_all {
 	struct sockaddr_in6 v6;
 };

+struct send_object {
+	void * buffer;
+	int sz;
+	void (*free_func)(void *);
+};
+
 #define MALLOC skynet_malloc
 #define FREE skynet_free

+static inline bool
+send_object_init(struct socket_server *ss, struct send_object *so, void *object, int sz) {
+	if (sz < 0) {
+		so->buffer = ss->soi.buffer(object);
+		so->sz = ss->soi.size(object);
+		so->free_func = ss->soi.free;
+		return true;
+	} else {
+		so->buffer = object;
+		so->sz = sz;
+		so->free_func = FREE;
+		return false;
+	}
+}
+
+static inline void
+write_buffer_free(struct socket_server *ss, struct write_buffer *wb) {
+	if (wb->userobject) {
+		ss->soi.free(wb->buffer);
+	} else {
+		FREE(wb->buffer);
+	}
+	FREE(wb);
+}
+
 static void
 socket_keepalive(int fd) {
 	int keepalive = 1;
@@ -213,6 +300,7 @@ socket_server_create() {
 	ss->alloc_id = 0;
 	ss->event_n = 0;
 	ss->event_index = 0;
+	memset(&ss->soi, 0, sizeof(ss->soi));
 	FD_ZERO(&ss->rfds);
 	assert(ss->recvctrl_fd < FD_SETSIZE);

@@ -220,13 +308,12 @@ socket_server_create() {
 }

 static void
-free_wb_list(struct wb_list *list) {
+free_wb_list(struct socket_server *ss, struct wb_list *list) {
 	struct write_buffer *wb = list->head;
 	while (wb) {
 		struct write_buffer *tmp = wb;
 		wb = wb->next;
-		FREE(tmp->buffer);
-		FREE(tmp);
+		write_buffer_free(ss, tmp);
 	}
 	list->head = NULL;
 	list->tail = NULL;
@@ -242,8 +329,8 @@ force_close(struct socket_server *ss, struct socket *s, struct socket_message *r
 		return;
 	}
 	assert(s->type != SOCKET_TYPE_RESERVE);
-	free_wb_list(&s->high);
-	free_wb_list(&s->low);
+	free_wb_list(ss,&s->high);
+	free_wb_list(ss,&s->low);
 	if (s->type != SOCKET_TYPE_PACCEPT && s->type != SOCKET_TYPE_PLISTEN) {
 		sp_del(ss->event_fd, s->fd);
 	}
@@ -276,7 +363,7 @@ check_wb_list(struct wb_list *s) {
 }

 static struct socket *
-new_fd(struct socket_server *ss, int id, int fd, uintptr_t opaque, bool add) {
+new_fd(struct socket_server *ss, int id, int fd, int protocol, uintptr_t opaque, bool add) {
 	struct socket * s = &ss->slot[HASH_ID(id)];
 	assert(s->type == SOCKET_TYPE_RESERVE);

@@ -289,7 +376,8 @@ new_fd(struct socket_server *ss, int id, int fd, uintptr_t opaque, bool add) {

 	s->id = id;
 	s->fd = fd;
-	s->size = MIN_READ_BUFFER;
+	s->protocol = protocol;
+	s->p.size = MIN_READ_BUFFER;
 	s->opaque = opaque;
 	s->wb_size = 0;
 	check_wb_list(&s->high);
@@ -312,7 +400,7 @@ open_socket(struct socket_server *ss, struct request_open * request, struct sock
 	struct addrinfo *ai_ptr = NULL;
 	char port[16];
 	sprintf(port, "%d", request->port);
-	memset( &ai_hints, 0, sizeof( ai_hints ) );
+	memset(&ai_hints, 0, sizeof( ai_hints ) );
 	ai_hints.ai_family = AF_UNSPEC;
 	ai_hints.ai_socktype = SOCK_STREAM;
 	ai_hints.ai_protocol = IPPROTO_TCP;
@@ -342,7 +430,7 @@ open_socket(struct socket_server *ss, struct request_open * request, struct sock
 		goto _failed;
 	}

-	ns = new_fd(ss, id, sock, request->opaque, true);
+	ns = new_fd(ss, id, sock, PROTOCOL_TCP, request->opaque, true);
 	if (ns == NULL) {
 		close(sock);
 		goto _failed;
@@ -371,7 +459,7 @@ _failed:
 }

 static int
-send_list(struct socket_server *ss, struct socket *s, struct wb_list *list, struct socket_message *result) {
+send_list_tcp(struct socket_server *ss, struct socket *s, struct wb_list *list, struct socket_message *result) {
 	while (list->head) {
 		struct write_buffer * tmp = list->head;
 		for (;;) {
@@ -395,14 +483,81 @@ send_list(struct socket_server *ss, struct socket *s, struct wb_list *list, stru
 			break;
 		}
 		list->head = tmp->next;
-		FREE(tmp->buffer);
-		FREE(tmp);
+		write_buffer_free(ss,tmp);
 	}
 	list->tail = NULL;

 	return -1;
 }

+static socklen_t
+udp_socket_address(struct socket *s, const uint8_t udp_address[UDP_ADDRESS_SIZE], union sockaddr_all *sa) {
+	int type = (uint8_t)udp_address[0];
+	if (type != s->protocol)
+		return 0;
+	uint16_t port = 0;
+	memcpy(&port, udp_address+1, sizeof(uint16_t));
+	switch (s->protocol) {
+	case PROTOCOL_UDP:
+		memset(&sa->v4, 0, sizeof(sa->v4));
+		sa->s.sa_family = AF_INET;
+		sa->v4.sin_port = port;
+		memcpy(&sa->v4.sin_addr, udp_address + 1 + sizeof(uint16_t), sizeof(sa->v4.sin_addr));	// ipv4 address is 32 bits
+		return sizeof(sa->v4);
+	case PROTOCOL_UDPv6:
+		memset(&sa->v6, 0, sizeof(sa->v6));
+		sa->s.sa_family = AF_INET6;
+		sa->v6.sin6_port = port;
+		memcpy(&sa->v6.sin6_addr, udp_address + 1 + sizeof(uint16_t), sizeof(sa->v6.sin6_addr));	// ipv4 address is 128 bits
+		return sizeof(sa->v6);
+	}
+	return 0;
+}
+
+static int
+send_list_udp(struct socket_server *ss, struct socket *s, struct wb_list *list, struct socket_message *result) {
+	while (list->head) {
+		struct write_buffer * tmp = list->head;
+		union sockaddr_all sa;
+		socklen_t sasz = udp_socket_address(s, tmp->udp_address, &sa);
+		int err = sendto(s->fd, tmp->ptr, tmp->sz, 0, &sa.s, sasz);
+		if (err < 0) {
+			switch(errno) {
+			case EINTR:
+			case EAGAIN:
+				return -1;
+			}
+			fprintf(stderr, "socket-server : udp (%d) sendto error %s.\n",s->id, strerror(errno));
+			return -1;
+/*			// ignore udp sendto error
+			
+			result->opaque = s->opaque;
+			result->id = s->id;
+			result->ud = 0;
+			result->data = NULL;
+
+			return SOCKET_ERROR;
+*/
+		}
+
+		s->wb_size -= tmp->sz;
+		list->head = tmp->next;
+		write_buffer_free(ss,tmp);
+	}
+	list->tail = NULL;
+
+	return -1;
+}
+
+static int
+send_list(struct socket_server *ss, struct socket *s, struct wb_list *list, struct socket_message *result) {
+	if (s->protocol == PROTOCOL_TCP) {
+		return send_list_tcp(ss, s, list, result);
+	} else {
+		return send_list_udp(ss, s, list, result);
+	}
+}
+
 static inline int
 list_uncomplete(struct wb_list *s) {
 	struct write_buffer *wb = s->head;
@@ -468,11 +623,13 @@ send_buffer(struct socket_server *ss, struct socket *s, struct socket_message *r
 	return -1;
 }

-static int
-append_sendbuffer_(struct wb_list *s, struct request_send * request, int n) {
-	struct write_buffer * buf = MALLOC(sizeof(*buf));
-	buf->ptr = request->buffer+n;
-	buf->sz = request->sz - n;
+static struct write_buffer *
+append_sendbuffer_(struct socket_server *ss, struct wb_list *s, struct request_send * request, int size, int n) {
+	struct write_buffer * buf = MALLOC(size);
+	struct send_object so;
+	buf->userobject = send_object_init(ss, &so, request->buffer, request->sz);
+	buf->ptr = (char*)so.buffer+n;
+	buf->sz = so.sz - n;
 	buf->buffer = request->buffer;
 	buf->next = NULL;
 	if (s->head == NULL) {
@@ -483,17 +640,27 @@ append_sendbuffer_(struct wb_list *s, struct request_send * request, int n) {
 		s->tail->next = buf;
 		s->tail = buf;
 	}
-	return buf->sz;
+	return buf;
 }

 static inline void
-append_sendbuffer(struct socket *s, struct request_send * request, int n) {
-	s->wb_size += append_sendbuffer_(&s->high, request, n);
+append_sendbuffer_udp(struct socket_server *ss, struct socket *s, int priority, struct request_send * request, const uint8_t udp_address[UDP_ADDRESS_SIZE]) {
+	struct wb_list *wl = (priority == PRIORITY_HIGH) ? &s->high : &s->low;
+	struct write_buffer *buf = append_sendbuffer_(ss, wl, request, SIZEOF_UDPBUFFER, 0);
+	memcpy(buf->udp_address, udp_address, UDP_ADDRESS_SIZE);
+	s->wb_size += buf->sz;
 }

 static inline void
-append_sendbuffer_low(struct socket *s, struct request_send * request) {
-	s->wb_size += append_sendbuffer_(&s->low, request, 0);
+append_sendbuffer(struct socket_server *ss, struct socket *s, struct request_send * request, int n) {
+	struct write_buffer *buf = append_sendbuffer_(ss, &s->high, request, SIZEOF_TCPBUFFER, n);
+	s->wb_size += buf->sz;
+}
+
+static inline void
+append_sendbuffer_low(struct socket_server *ss,struct socket *s, struct request_send * request) {
+	struct write_buffer *buf = append_sendbuffer_(ss, &s->low, request, SIZEOF_TCPBUFFER, 0);
+	s->wb_size += buf->sz;
 }

 static inline int
@@ -509,41 +676,65 @@ send_buffer_empty(struct socket *s) {
 	Else append package to high (PRIORITY_HIGH) or low (PRIORITY_LOW) list.
 */
 static int
-send_socket(struct socket_server *ss, struct request_send * request, struct socket_message *result, int priority) {
+send_socket(struct socket_server *ss, struct request_send * request, struct socket_message *result, int priority, const uint8_t *udp_address) {
 	int id = request->id;
 	struct socket * s = &ss->slot[HASH_ID(id)];
+	struct send_object so;
+	send_object_init(ss, &so, request->buffer, request->sz);
 	if (s->type == SOCKET_TYPE_INVALID || s->id != id 
 		|| s->type == SOCKET_TYPE_HALFCLOSE
 		|| s->type == SOCKET_TYPE_PACCEPT) {
-		FREE(request->buffer);
+		so.free_func(request->buffer);
 		return -1;
 	}
 	assert(s->type != SOCKET_TYPE_PLISTEN && s->type != SOCKET_TYPE_LISTEN);
 	if (send_buffer_empty(s) && s->type == SOCKET_TYPE_CONNECTED) {
-		int n = write(s->fd, request->buffer, request->sz);
-		if (n<0) {
-			switch(errno) {
-			case EINTR:
-			case EAGAIN:
-				n = 0;
-				break;
-			default:
-				fprintf(stderr, "socket-server: write to %d (fd=%d) error.",id,s->fd);
-				force_close(ss,s,result);
-				return SOCKET_CLOSE;
+		if (s->protocol == PROTOCOL_TCP) {
+			int n = write(s->fd, so.buffer, so.sz);
+			if (n<0) {
+				switch(errno) {
+				case EINTR:
+				case EAGAIN:
+					n = 0;
+					break;
+				default:
+					fprintf(stderr, "socket-server: write to %d (fd=%d) error :%s.\n",id,s->fd,strerror(errno));
+					force_close(ss,s,result);
+					return SOCKET_CLOSE;
+				}
+			}
+			if (n == so.sz) {
+				so.free_func(request->buffer);
+				return -1;
+			}
+			append_sendbuffer(ss, s, request, n);	// add to high priority list, even priority == PRIORITY_LOW
+		} else {
+			// udp
+			if (udp_address == NULL) {
+				udp_address = s->p.udp_address;
+			}
+			union sockaddr_all sa;
+			socklen_t sasz = udp_socket_address(s, udp_address, &sa);
+			int n = sendto(s->fd, so.buffer, so.sz, 0, &sa.s, sasz);
+			if (n != so.sz) {
+				append_sendbuffer_udp(ss,s,priority,request,udp_address);
+			} else {
+				so.free_func(request->buffer);
 			}
 		}
-		if (n == request->sz) {
-			FREE(request->buffer);
-			return -1;
-		}
-		append_sendbuffer(s, request, n);	// add to high priority list, even priority == PRIORITY_LOW
 		sp_write(ss->event_fd, s->fd, s, true);
 	} else {
-		if (priority == PRIORITY_LOW) {
-			append_sendbuffer_low(s, request);
+		if (s->protocol == PROTOCOL_TCP) {
+			if (priority == PRIORITY_LOW) {
+				append_sendbuffer_low(ss, s, request);
+			} else {
+				append_sendbuffer(ss, s, request, 0);
+			}
 		} else {
-			append_sendbuffer(s, request, 0);
+			if (udp_address == NULL) {
+				udp_address = s->p.udp_address;
+			}
+			append_sendbuffer_udp(ss,s,priority,request,udp_address);
 		}
 	}
 	return -1;
@@ -553,7 +744,7 @@ static int
 listen_socket(struct socket_server *ss, struct request_listen * request, struct socket_message *result) {
 	int id = request->id;
 	int listen_fd = request->fd;
-	struct socket *s = new_fd(ss, id, listen_fd, request->opaque, false);
+	struct socket *s = new_fd(ss, id, listen_fd, PROTOCOL_TCP, request->opaque, false);
 	if (s == NULL) {
 		goto _failed;
 	}
@@ -603,7 +794,7 @@ bind_socket(struct socket_server *ss, struct request_bind *request, struct socke
 	result->id = id;
 	result->opaque = request->opaque;
 	result->ud = 0;
-	struct socket *s = new_fd(ss, id, request->fd, request->opaque, true);
+	struct socket *s = new_fd(ss, id, request->fd, PROTOCOL_TCP, request->opaque, true);
 	if (s == NULL) {
 		result->data = NULL;
 		return SOCKET_ERROR;
@@ -660,7 +851,7 @@ block_readpipe(int pipefd, void *buffer, int sz) {
 		if (n<0) {
 			if (errno == EINTR)
 				continue;
-			fprintf(stderr, "socket-server : read pipe error %s.",strerror(errno));
+			fprintf(stderr, "socket-server : read pipe error %s.\n",strerror(errno));
 			return;
 		}
 		// must atomic read from a pipe
@@ -683,6 +874,49 @@ has_cmd(struct socket_server *ss) {
 	return 0;
 }

+static void
+add_udp_socket(struct socket_server *ss, struct request_udp *udp) {
+	int id = udp->id;
+	int protocol;
+	if (udp->family == AF_INET6) {
+		protocol = PROTOCOL_UDPv6;
+	} else {
+		protocol = PROTOCOL_UDP;
+	}
+	struct socket *ns = new_fd(ss, id, udp->fd, protocol, udp->opaque, true);
+	if (ns == NULL) {
+		close(udp->fd);
+		ss->slot[HASH_ID(id)].type = SOCKET_TYPE_INVALID;
+	}
+	ns->type = SOCKET_TYPE_CONNECTED;
+	memset(ns->p.udp_address, 0, sizeof(ns->p.udp_address));
+}
+
+static int
+set_udp_address(struct socket_server *ss, struct request_setudp *request, struct socket_message *result) {
+	int id = request->id;
+	struct socket *s = &ss->slot[HASH_ID(id)];
+	if (s->type == SOCKET_TYPE_INVALID || s->id !=id) {
+		return -1;
+	}
+	int type = request->address[0];
+	if (type != s->protocol) {
+		// protocol mismatch
+		result->opaque = s->opaque;
+		result->id = s->id;
+		result->ud = 0;
+		result->data = NULL;
+
+		return SOCKET_ERROR;
+	}
+	if (type == PROTOCOL_UDP) {
+		memcpy(s->p.udp_address, request->address, 1+2+4);	// 1 type, 2 port, 4 ipv4
+	} else {
+		memcpy(s->p.udp_address, request->address, 1+2+16);	// 1 type, 2 port, 16 ipv6
+	}
+	return -1;
+}
+
 // return type
 static int
 ctrl_cmd(struct socket_server *ss, struct socket_message *result) {
@@ -713,12 +947,21 @@ ctrl_cmd(struct socket_server *ss, struct socket_message *result) {
 		result->data = NULL;
 		return SOCKET_EXIT;
 	case 'D':
-		return send_socket(ss, (struct request_send *)buffer, result, PRIORITY_HIGH);
+		return send_socket(ss, (struct request_send *)buffer, result, PRIORITY_HIGH, NULL);
 	case 'P':
-		return send_socket(ss, (struct request_send *)buffer, result, PRIORITY_LOW);
+		return send_socket(ss, (struct request_send *)buffer, result, PRIORITY_LOW, NULL);
+	case 'A': {
+		struct request_send_udp * rsu = (struct request_send_udp *)buffer;
+		return send_socket(ss, &rsu->send, result, PRIORITY_HIGH, rsu->address);
+	}
+	case 'C':
+		return set_udp_address(ss, (struct request_setudp *)buffer, result);
 	case 'T':
 		setopt_socket(ss, (struct request_setopt *)buffer);
 		return -1;
+	case 'U':
+		add_udp_socket(ss, (struct request_udp *)buffer);
+		return -1;
 	default:
 		fprintf(stderr, "socket-server: Unknown ctrl %c.\n",type);
 		return -1;
@@ -729,8 +972,8 @@ ctrl_cmd(struct socket_server *ss, struct socket_message *result) {

 // return -1 (ignore) when error
 static int
-forward_message(struct socket_server *ss, struct socket *s, struct socket_message * result) {
-	int sz = s->size;
+forward_message_tcp(struct socket_server *ss, struct socket *s, struct socket_message * result) {
+	int sz = s->p.size;
 	char * buffer = MALLOC(sz);
 	int n = (int)read(s->fd, buffer, sz);
 	if (n<0) {
@@ -761,9 +1004,9 @@ forward_message(struct socket_server *ss, struct socket *s, struct socket_messag
 	}

 	if (n == sz) {
-		s->size *= 2;
+		s->p.size *= 2;
 	} else if (sz > MIN_READ_BUFFER && n*2 < sz) {
-		s->size /= 2;
+		s->p.size /= 2;
 	}

 	result->opaque = s->opaque;
@@ -773,6 +1016,63 @@ forward_message(struct socket_server *ss, struct socket *s, struct socket_messag
 	return SOCKET_DATA;
 }

+static int
+gen_udp_address(int protocol, union sockaddr_all *sa, uint8_t * udp_address) {
+	int addrsz = 1;
+	udp_address[0] = (uint8_t)protocol;
+	if (protocol == PROTOCOL_UDP) {
+		memcpy(udp_address+addrsz, &sa->v4.sin_port, sizeof(sa->v4.sin_port));
+		addrsz += sizeof(sa->v4.sin_port);
+		memcpy(udp_address+addrsz, &sa->v4.sin_addr, sizeof(sa->v4.sin_addr));
+		addrsz += sizeof(sa->v4.sin_addr);
+	} else {
+		memcpy(udp_address+addrsz, &sa->v6.sin6_port, sizeof(sa->v6.sin6_port));
+		addrsz += sizeof(sa->v6.sin6_port);
+		memcpy(udp_address+addrsz, &sa->v6.sin6_addr, sizeof(sa->v6.sin6_addr));
+		addrsz += sizeof(sa->v6.sin6_addr);
+	}
+	return addrsz;
+}
+
+static int
+forward_message_udp(struct socket_server *ss, struct socket *s, struct socket_message * result) {
+	union sockaddr_all sa;
+	socklen_t slen = sizeof(sa);
+	int n = recvfrom(s->fd, ss->udpbuffer,MAX_UDP_PACKAGE,0,&sa.s,&slen);
+	if (n<0) {
+		switch(errno) {
+		case EINTR:
+		case EAGAIN:
+			break;
+		default:
+			// close when error
+			force_close(ss, s, result);
+			return SOCKET_ERROR;
+		}
+		return -1;
+	}
+	uint8_t * data;
+	if (slen == sizeof(sa.v4)) {
+		if (s->protocol != PROTOCOL_UDP)
+			return -1;
+		data = MALLOC(n + 1 + 2 + 4);
+		gen_udp_address(PROTOCOL_UDP, &sa, data + n);
+	} else {
+		if (s->protocol != PROTOCOL_UDPv6)
+			return -1;
+		data = MALLOC(n + 1 + 2 + 16);
+		gen_udp_address(PROTOCOL_UDPv6, &sa, data + n);
+	}
+	memcpy(data, ss->udpbuffer, n);
+
+	result->opaque = s->opaque;
+	result->id = s->id;
+	result->ud = n;
+	result->data = (char *)data;
+
+	return SOCKET_UDP;
+}
+
 static int
 report_connect(struct socket_server *ss, struct socket *s, struct socket_message *result) {
 	int error;
@@ -819,7 +1119,7 @@ report_accept(struct socket_server *ss, struct socket *s, struct socket_message
 	}
 	socket_keepalive(client_fd);
 	sp_nonblocking(client_fd);
-	struct socket *ns = new_fd(ss, id, client_fd, s->opaque, false);
+	struct socket *ns = new_fd(ss, id, client_fd, PROTOCOL_TCP, s->opaque, false);
 	if (ns == NULL) {
 		close(client_fd);
 		return 0;
@@ -904,15 +1204,30 @@ socket_server_poll(struct socket_server *ss, struct socket_message * result, int
 			fprintf(stderr, "socket-server: invalid socket\n");
 			break;
 		default:
-			if (e->write) {
-				int type = send_buffer(ss, s, result);
+			if (e->read) {
+				int type;
+				if (s->protocol == PROTOCOL_TCP) {
+					type = forward_message_tcp(ss, s, result);
+				} else {
+					type = forward_message_udp(ss, s, result);
+					if (type == SOCKET_UDP) {
+						// try read again
+						--ss->event_index;
+						return SOCKET_UDP;
+					}
+				}
+				if (e->write) {
+					// Try to dispatch write message next step if write flag set.
+					e->read = false;
+					--ss->event_index;
+				}
 				if (type == -1)
 					break;
 				clear_closed_event(ss, result, type);
 				return type;
 			}
-			if (e->read) {
-				int type = forward_message(ss, s, result);
+			if (e->write) {
+				int type = send_buffer(ss, s, result);
 				if (type == -1)
 					break;
 				clear_closed_event(ss, result, type);
@@ -945,9 +1260,11 @@ open_request(struct socket_server *ss, struct request_package *req, uintptr_t op
 	int len = strlen(addr);
 	if (len + sizeof(req->u.open) > 256) {
 		fprintf(stderr, "socket-server : Invalid addr %s.\n",addr);
-		return 0;
+		return -1;
 	}
 	int id = reserve_id(ss);
+	if (id < 0)
+		return -1;
 	req->u.open.opaque = opaque;
 	req->u.open.id = id;
 	req->u.open.port = port;
@@ -961,6 +1278,8 @@ int
 socket_server_connect(struct socket_server *ss, uintptr_t opaque, const char * addr, int port) {
 	struct request_package request;
 	int len = open_request(ss, &request, opaque, addr, port);
+	if (len < 0)
+		return -1;
 	send_request(ss, &request, 'O', sizeof(request.u.open) + len);
 	return request.u.open.id;
 }
@@ -1011,38 +1330,67 @@ socket_server_close(struct socket_server *ss, uintptr_t opaque, int id) {
 	send_request(ss, &request, 'K', sizeof(request.u.close));
 }

+// return -1 means failed
+// or return AF_INET or AF_INET6
+static int
+do_bind(const char *host, int port, int protocol, int *family) {
+	int fd;
+	int status;
+	int reuse = 1;
+	struct addrinfo ai_hints;
+	struct addrinfo *ai_list = NULL;
+	char portstr[16];
+	if (host == NULL || host[0] == 0) {
+		host = "0.0.0.0";	// INADDR_ANY
+	}
+	sprintf(portstr, "%d", port);
+	memset( &ai_hints, 0, sizeof( ai_hints ) );
+	ai_hints.ai_family = AF_UNSPEC;
+	if (protocol == IPPROTO_TCP) {
+		ai_hints.ai_socktype = SOCK_STREAM;
+	} else {
+		assert(protocol == IPPROTO_UDP);
+		ai_hints.ai_socktype = SOCK_DGRAM;
+	}
+	ai_hints.ai_protocol = protocol;
+
+	status = getaddrinfo( host, portstr, &ai_hints, &ai_list );
+	if ( status != 0 ) {
+		return -1;
+	}
+	*family = ai_list->ai_family;
+	fd = socket(*family, ai_list->ai_socktype, 0);
+	if (fd < 0) {
+		goto _failed_fd;
+	}
+	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void *)&reuse, sizeof(int))==-1) {
+		goto _failed;
+	}
+	status = bind(fd, (struct sockaddr *)ai_list->ai_addr, ai_list->ai_addrlen);
+	if (status != 0)
+		goto _failed;
+
+	freeaddrinfo( ai_list );
+	return fd;
+_failed:
+	close(fd);
+_failed_fd:
+	freeaddrinfo( ai_list );
+	return -1;
+}
+
 static int
 do_listen(const char * host, int port, int backlog) {
-	// only support ipv4
-	// todo: support ipv6 by getaddrinfo
-	uint32_t addr = INADDR_ANY;
-	if (host[0]) {
-		addr=inet_addr(host);
-	}
-	int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
+	int family = 0;
+	int listen_fd = do_bind(host, port, IPPROTO_TCP, &family);
 	if (listen_fd < 0) {
 		return -1;
 	}
-	int reuse = 1;
-	if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, (void *)&reuse, sizeof(int))==-1) {
-		goto _failed;
-	}
-
-	struct sockaddr_in my_addr;
-	memset(&my_addr, 0, sizeof(struct sockaddr_in));
-	my_addr.sin_family = AF_INET;
-	my_addr.sin_port = htons(port);
-	my_addr.sin_addr.s_addr = addr;
-	if (bind(listen_fd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) {
-		goto _failed;
-	}
 	if (listen(listen_fd, backlog) == -1) {
-		goto _failed;
+		close(listen_fd);
+		return -1;
 	}
 	return listen_fd;
-_failed:
-	close(listen_fd);
-	return -1;
 }

 int 
@@ -1053,6 +1401,10 @@ socket_server_listen(struct socket_server *ss, uintptr_t opaque, const char * ad
 	}
 	struct request_package request;
 	int id = reserve_id(ss);
+	if (id < 0) {
+		close(fd);
+		return id;
+	}
 	request.u.listen.opaque = opaque;
 	request.u.listen.id = id;
 	request.u.listen.fd = fd;
@@ -1064,6 +1416,8 @@ int
 socket_server_bind(struct socket_server *ss, uintptr_t opaque, int fd) {
 	struct request_package request;
 	int id = reserve_id(ss);
+	if (id < 0)
+		return -1;
 	request.u.bind.opaque = opaque;
 	request.u.bind.id = id;
 	request.u.bind.fd = fd;
@@ -1087,3 +1441,130 @@ socket_server_nodelay(struct socket_server *ss, int id) {
 	request.u.setopt.value = 1;
 	send_request(ss, &request, 'T', sizeof(request.u.setopt));
 }
+
+void 
+socket_server_userobject(struct socket_server *ss, struct socket_object_interface *soi) {
+	ss->soi = *soi;
+}
+
+// UDP
+
+int 
+socket_server_udp(struct socket_server *ss, uintptr_t opaque, const char * addr, int port) {
+	int fd;
+	int family;
+	if (port != 0 || addr != NULL) {
+		// bind
+		fd = do_bind(addr, port, IPPROTO_UDP, &family);
+		if (fd < 0) {
+			return -1;
+		}
+	} else {
+		family = AF_INET;
+		fd = socket(family, SOCK_DGRAM, 0);
+		if (fd < 0) {
+			return -1;
+		}
+	}
+	sp_nonblocking(fd);
+
+	int id = reserve_id(ss);
+	if (id < 0) {
+		close(fd);
+		return -1;
+	}
+	struct request_package request;
+	request.u.udp.id = id;
+	request.u.udp.fd = fd;
+	request.u.udp.opaque = opaque;
+	request.u.udp.family = family;
+
+	send_request(ss, &request, 'U', sizeof(request.u.udp));	
+	return id;
+}
+
+int64_t 
+socket_server_udp_send(struct socket_server *ss, int id, const struct socket_udp_address *addr, const void *buffer, int sz) {
+	struct socket * s = &ss->slot[HASH_ID(id)];
+	if (s->id != id || s->type == SOCKET_TYPE_INVALID) {
+		return -1;
+	}
+
+	struct request_package request;
+	request.u.send_udp.send.id = id;
+	request.u.send_udp.send.sz = sz;
+	request.u.send_udp.send.buffer = (char *)buffer;
+
+	const uint8_t *udp_address = (const uint8_t *)addr;
+	int addrsz;
+	switch (udp_address[0]) {
+	case PROTOCOL_UDP:
+		addrsz = 1+2+4;		// 1 type, 2 port, 4 ipv4
+		break;
+	case PROTOCOL_UDPv6:
+		addrsz = 1+2+16;	// 1 type, 2 port, 16 ipv6
+		break;
+	default:
+		return -1;
+	}
+
+	memcpy(request.u.send_udp.address, udp_address, addrsz);	
+
+	send_request(ss, &request, 'A', sizeof(request.u.send_udp.send)+addrsz);
+	return s->wb_size;
+}
+
+int
+socket_server_udp_connect(struct socket_server *ss, int id, const char * addr, int port) {
+	int status;
+	struct addrinfo ai_hints;
+	struct addrinfo *ai_list = NULL;
+	char portstr[16];
+	sprintf(portstr, "%d", port);
+	memset( &ai_hints, 0, sizeof( ai_hints ) );
+	ai_hints.ai_family = AF_UNSPEC;
+	ai_hints.ai_socktype = SOCK_DGRAM;
+	ai_hints.ai_protocol = IPPROTO_UDP;
+
+	status = getaddrinfo(addr, portstr, &ai_hints, &ai_list );
+	if ( status != 0 ) {
+		return -1;
+	}
+	struct request_package request;
+	request.u.set_udp.id = id;
+	int protocol;
+
+	if (ai_list->ai_family == AF_INET) {
+		protocol = PROTOCOL_UDP;
+	} else if (ai_list->ai_family == AF_INET6) {
+		protocol = PROTOCOL_UDPv6;
+	} else {
+		freeaddrinfo( ai_list );
+		return -1;
+	}
+
+	int addrsz = gen_udp_address(protocol, (union sockaddr_all *)ai_list->ai_addr, request.u.set_udp.address);
+
+	freeaddrinfo( ai_list );
+
+	send_request(ss, &request, 'C', sizeof(request.u.set_udp) - sizeof(request.u.set_udp.address) +addrsz);
+
+	return 0;
+}
+
+const struct socket_udp_address *
+socket_server_udp_address(struct socket_server *ss, struct socket_message *msg, int *addrsz) {
+	uint8_t * address = (uint8_t *)(msg->data + msg->ud);
+	int type = address[0];
+	switch(type) {
+	case PROTOCOL_UDP:
+		*addrsz = 1+2+4;
+		break;
+	case PROTOCOL_UDPv6:
+		*addrsz = 1+2+16;
+		break;
+	default:
+		return NULL;
+	}
+	return (const struct socket_udp_address *)address;
+}
--- a/skynet-src/socket_server.h
+++ b/skynet-src/socket_server.h
@@ -9,6 +9,7 @@
 #define SOCKET_ACCEPT 3
 #define SOCKET_ERROR 4
 #define SOCKET_EXIT 5
+#define SOCKET_UDP 6

 struct socket_server;

@@ -36,6 +37,29 @@ int socket_server_listen(struct socket_server *, uintptr_t opaque, const char *
 int socket_server_connect(struct socket_server *, uintptr_t opaque, const char * addr, int port);
 int socket_server_bind(struct socket_server *, uintptr_t opaque, int fd);

+// for tcp
 void socket_server_nodelay(struct socket_server *, int id);

+struct socket_udp_address;
+
+// create an udp socket handle, attach opaque with it . udp socket don't need call socket_server_start to recv message
+// if port != 0, bind the socket . if addr == NULL, bind ipv4 0.0.0.0 . If you want to use ipv6, addr can be "::" and port 0.
+int socket_server_udp(struct socket_server *, uintptr_t opaque, const char * addr, int port);
+// set default dest address, return 0 when success
+int socket_server_udp_connect(struct socket_server *, int id, const char * addr, int port);
+// If the socket_udp_address is NULL, use last call socket_server_udp_connect address instead
+// You can also use socket_server_send 
+int64_t socket_server_udp_send(struct socket_server *, int id, const struct socket_udp_address *, const void *buffer, int sz);
+// extract the address of the message, struct socket_message * should be SOCKET_UDP
+const struct socket_udp_address * socket_server_udp_address(struct socket_server *, struct socket_message *, int *addrsz);
+
+struct socket_object_interface {
+	void * (*buffer)(void *);
+	int (*size)(void *);
+	void (*free)(void *);
+};
+
+// if you send package sz == -1, use soi.
+void socket_server_userobject(struct socket_server *, struct socket_object_interface *soi);
+
 #endif
--- a/test/pingserver.lua
+++ b/test/pingserver.lua
@@ -1,5 +1,6 @@
 local skynet = require "skynet"
 local queue = require "skynet.queue"
+local snax = require "snax"

 local i = 0
 local hello = "hello"
@@ -32,6 +33,10 @@ function accept.hello()
 	end)
 end

+function accept.exit(...)
+	snax.exit(...)
+end
+
 function response.error()
 	error "throw an error"
 end
@@ -40,9 +45,6 @@ function init( ... )
 	print ("ping server start:", ...)
 	-- init queue
 	lock = queue()
-
-- You can return "queue" for queue service mode
--	return "queue"
 end

 function exit(...)
--- a/test/testdeadloop.lua
+++ b/test/testdeadloop.lua
@@ -0,0 +1,10 @@
+local skynet = require "skynet"
+local function dead_loop()
+    while true do
+        skynet.sleep(0)
+    end
+end
+
+skynet.start(function()
+    skynet.fork(dead_loop)
+end)
--- a/test/testping.lua
+++ b/test/testping.lua
@@ -2,7 +2,7 @@ local skynet = require "skynet"
 local snax = require "snax"

 skynet.start(function()
-	local ps = snax.uniqueservice ("pingserver", "hello world")
+	local ps = snax.newservice ("pingserver", "hello world")
 	print(ps.req.ping("foobar"))
 	print(ps.post.hello())
 	print(pcall(ps.req.error))
@@ -31,6 +31,6 @@ end
 		print(string.format("%s\tcount:%d time:%f", name, v.count, v.time))
 	end

-	print(snax.kill(ps,"exit"))
+	print(ps.post.exit("exit")) -- == snax.kill(ps, "exit")
 	skynet.exit()
 end)
--- a/test/testudp.lua
+++ b/test/testudp.lua
@@ -0,0 +1,26 @@
+local skynet = require "skynet"
+local socket = require "socket"
+
+local function server()
+	local host
+	host = socket.udp(function(data, sz, from)
+		local str = skynet.tostring(data,sz)	-- skynet.tostring should call only once, because it will free the pointer data
+		print("server recv", str, socket.udp_address(from))
+		socket.sendto(host, from, "OK " .. str)
+	end , "127.0.0.1", 8765)	-- bind an address
+end
+
+local function client()
+	local c = socket.udp(function(data, sz, from)
+		print("client recv", skynet.tostring(data,sz), socket.udp_address(from))
+	end)
+	socket.udp_connect(c, "127.0.0.1", 8765)
+	for i=1,20 do
+		socket.write(c, "hello " .. i)	-- write to the address by udp_connect binding
+	end
+end
+
+skynet.start(function()
+	skynet.fork(server)
+	skynet.fork(client)
+end)
Author	SHA1	Message	Date
云风	f15cd1d458	Merge pull request #212 from cloudwu/dev release 0.9.2	2014-12-08 10:57:23 +08:00
Cloud Wu	24a2df9383	Merge branch 'dev' of github.com:cloudwu/skynet into dev	2014-12-08 10:53:53 +08:00
Cloud Wu	176e4df90c	ready for v0.9.2	2014-12-08 10:53:14 +08:00
云风	babd730d07	Merge pull request #210 from dpull/dev 扩展mongodb库功能	2014-12-05 12:07:19 +08:00
dpull	fe9640e2dd	1、mongo_collection:createIndex 创建索引 2、mongo_collection:safe_insert 可以判断返回值的insert 3、mongo_collection:findAndModify 查询并修改	2014-12-04 20:10:24 +08:00
云风	906008f667	Merge pull request #208 from xjdrew/bugfix-mq 使用spinlock，避免cas不能充分调度testdeadloop这样的用例	2014-12-04 16:31:19 +08:00
xjdrew	2da2f121c8	delete unneccessary comment	2014-12-04 16:16:17 +08:00
xjdrew	a0d2c7172c	使用spinlock，避免cas不能充分调度testdeadloop这样的用例	2014-12-04 15:50:19 +08:00
云风	463a789898	Merge pull request #207 from lmess/master Update mongo.lua	2014-12-03 16:11:29 +08:00
lmess	175529b114	Update mongo.lua mongo auth config	2014-12-03 15:31:32 +08:00
Cloud Wu	6f6039c136	include sys/socket.h for freebsd	2014-12-03 11:06:09 +08:00
Cloud Wu	2b13eb250d	update sproto for big-endian	2014-11-26 21:18:49 +08:00
Cloud Wu	84cb4bb4c1	use explicit conversion	2014-11-25 16:04:26 +08:00
云风	784fb9fee7	Merge pull request #204 from cloudwu/dev Dev	2014-11-20 11:38:21 +08:00
Cloud Wu	ff6c92b975	add comment	2014-11-20 11:33:16 +08:00
Cloud Wu	64801972e7	Merge branch 'dev'	2014-11-20 11:22:58 +08:00
Cloud Wu	ee61e60631	ready for 0.9.0	2014-11-17 14:55:21 +08:00
云风	c8c95f1690	Merge pull request #203 from cloudwu/dev Ready for 0.9.0	2014-11-17 14:52:16 +08:00
Cloud Wu	50344af335	Merge branch 'udp' into dev	2014-11-17 14:47:11 +08:00
Cloud Wu	3be0f50722	use snax.newservice would be better	2014-11-15 21:33:25 +08:00
Cloud Wu	6ee014dd99	bugfix: init should be out	2014-11-15 21:28:03 +08:00
云风	2a4bee5bdd	Merge pull request #202 from niuys/patch-1 ecsape char '\Z' wrong	2014-11-14 20:06:44 +08:00
snail	4f21696387	ecsape char '\Z' wrong In mysql-connector, it's '\Z', not '\z'.Now, this bug will change oringinal data	2014-11-14 18:11:01 +08:00
Cloud Wu	ae041c97b3	bugfix: use ai_list instead of ai_hints	2014-11-14 16:27:26 +08:00
Cloud Wu	6df72e5842	remove snax queue mode	2014-11-14 16:13:48 +08:00
Cloud Wu	b9e06dc065	add snax.self and snax.exit	2014-11-14 15:11:05 +08:00
Cloud Wu	b3cf1bc625	remove unused code	2014-11-13 12:14:02 +08:00
Cloud Wu	20b181c56d	If recv one udp message, try read next immediately rather than until next epoll_wait	2014-11-13 11:44:46 +08:00
Cloud Wu	8e4a175155	use fork to dispatch more socket message	2014-11-13 11:23:15 +08:00
Cloud Wu	cfe9506a5a	add UDP support, and TCP listen support ipv6 now	2014-11-12 23:00:44 +08:00
Cloud Wu	fa78623b1c	support user defined send object	2014-11-11 13:54:43 +08:00
Cloud Wu	e06a9e3701	dispatch read before write, and try to dispath both	2014-11-11 11:33:57 +08:00
Cloud Wu	c87dea3d9b	fix issue #200	2014-11-10 20:58:10 +08:00
Cloud Wu	929ce385a3	fprintf need cr	2014-11-10 10:53:29 +08:00
Cloud Wu	765749f608	accept may not start fd, so it can't close at last	2014-11-04 18:25:15 +08:00
Cloud Wu	5fad5d63ae	socket close fd when auth failed	2014-11-04 18:12:25 +08:00
Cloud Wu	af10c59eaf	release v0.8.1	2014-11-03 15:18:00 +08:00
云风	a77b71530d	Merge pull request #195 from cloudwu/dev release 0.8.1	2014-11-03 15:13:55 +08:00
Cloud Wu	803a79059a	update sproto lib	2014-10-31 16:49:54 +08:00
Cloud Wu	6c9ad16077	bugfix: socket open address, and httpd bodylimit	2014-10-29 16:51:39 +08:00
Cloud Wu	2ab689f7c1	remove sha1 from lua_mysqlaux, use lua-crypt instead	2014-10-29 11:18:47 +08:00
Cloud Wu	f8a50929a8	bugfix: break when write all	2014-10-29 11:04:35 +08:00
Cloud Wu	af3ca3bb2f	merge lua bugfix, read http://www.lua.org/bugs.html	2014-10-28 19:40:27 +08:00
Cloud Wu	aaf8617dd5	skynet_free(NULL) is ok	2014-10-28 17:14:30 +08:00
Cloud Wu	1d3e393fd4	Merge branch 'czlc-master' into dev	2014-10-28 17:13:35 +08:00
Cloud Wu	c3df405e33	Merge branch 'master' of github.com:czlc/skynet-1 into czlc-master	2014-10-28 17:12:16 +08:00
Cloud Wu	b1ef8a33d9	harbor can post error message back when the destination is not exist	2014-10-28 17:00:24 +08:00
Cloud Wu	954625a530	fix issue #190	2014-10-28 16:48:35 +08:00
czlc	9850ca1b94	free buffer	2014-10-28 16:43:29 +08:00
Cloud Wu	01e1a6aafa	fix issue #189	2014-10-28 16:04:01 +08:00