more type check

release alpha 3

3rd/lua/lua.h

@@ -458,6 +458,11 @@ struct lua_Debug {
 
 /* }====================================================================== */
 
+/* Add by skynet */
+
+extern lua_State * skynet_sig_L;
+LUA_API void (lua_checksig_)(lua_State *L);
+#define lua_checksig(L) if (skynet_sig_L) { lua_checksig_(L); }
 
 /******************************************************************************
 * Copyright (C) 1994-2015 Lua.org, PUC-Rio.

3rd/lua/lualib.h

@@ -44,6 +44,8 @@ LUAMOD_API int (luaopen_debug) (lua_State *L);
 #define LUA_LOADLIBNAME	"package"
 LUAMOD_API int (luaopen_package) (lua_State *L);
 
+#define LUA_CACHELIB
+LUAMOD_API int (luaopen_cache) (lua_State *L);
 
 /* open all previous libraries */
 LUALIB_API void (luaL_openlibs) (lua_State *L);

3rd/lua/lvm.c

@@ -43,6 +43,17 @@
 /* limit for table tag-method chains (to avoid loops) */
 #define MAXTAGLOOP	2000
 
+/* Add by skynet */
+lua_State * skynet_sig_L = NULL;
+
+LUA_API void 
+lua_checksig_(lua_State *L) {
+  if (skynet_sig_L == G(L)->mainthread) {
+    skynet_sig_L = NULL;
+    lua_pushnil(L);
+    lua_error(L);
+  }
+}
 
 /*
 ** Similar to 'tonumber', but does not attempt to convert strings and
@@ -935,6 +946,7 @@ void luaV_execute (lua_State *L) {
         vmbreak;
       }
       vmcase(OP_JMP) {
+        lua_checksig(L);
         dojump(ci, i, 0);
         vmbreak;
       }
@@ -987,6 +999,7 @@ void luaV_execute (lua_State *L) {
       vmcase(OP_CALL) {
         int b = GETARG_B(i);
         int nresults = GETARG_C(i) - 1;
+        lua_checksig(L);
         if (b != 0) L->top = ra+b;  /* else previous instruction set top */
         if (luaD_precall(L, ra, nresults)) {  /* C function? */
           if (nresults >= 0) L->top = ci->top;  /* adjust results */
@@ -1001,6 +1014,7 @@ void luaV_execute (lua_State *L) {
       }
       vmcase(OP_TAILCALL) {
         int b = GETARG_B(i);
+        lua_checksig(L);
         if (b != 0) L->top = ra+b;  /* else previous instruction set top */
         lua_assert(GETARG_C(i) - 1 == LUA_MULTRET);
         if (luaD_precall(L, ra, LUA_MULTRET))  /* C function? */
@@ -1111,6 +1125,7 @@ void luaV_execute (lua_State *L) {
       }
       vmcase(OP_TFORLOOP) {
         l_tforloop:
+        lua_checksig(L);
         if (!ttisnil(ra + 1)) {  /* continue loop? */
           setobjs2s(L, ra, ra + 1);  /* save control variable */
            ci->u.l.savedpc += GETARG_sBx(i);  /* jump back */

HISTORY.md

@@ -1,3 +1,15 @@
+v1.0.0-alpha3 (2015-3-30)
+-----------
+* Update sproto (bugfix)
+* Add async dns query
+* improve httpc
+
+v1.0.0-alpha2 (2015-3-16)
+-----------
+* Update examples client to lua 5.3
+* Patch lua 5.3 to interrupt the dead loop (for debug)
+* Update sproto (fix some bugs and support unordered map)
+
 v1.0.0-alpha (2015-3-9)
 -----------
 * Update lua from 5.2 to 5.3

examples/login/client.lua

@@ -2,7 +2,10 @@ package.cpath = "luaclib/?.so"
 
 local socket = require "clientsocket"
 local crypt = require "crypt"
-local bit32 = require "bit32"
+
+if _VERSION ~= "Lua 5.3" then
+	error "Use lua 5.3"
+end
 
 local fd = assert(socket.connect("127.0.0.1", 8001))
 
@@ -93,26 +96,14 @@ print("login ok, subid=", subid)
 
 local function send_request(v, session)
 	local size = #v + 4
-	local package = string.char(bit32.extract(size,8,8))..
-		string.char(bit32.extract(size,0,8))..
-		v..
-		string.char(bit32.extract(session,24,8))..
-		string.char(bit32.extract(session,16,8))..
-		string.char(bit32.extract(session,8,8))..
-		string.char(bit32.extract(session,0,8))
-
+	local package = string.pack(">I2", size)..v..string.pack(">I4", session)
 	socket.send(fd, package)
 	return v, session
 end
 
 local function recv_response(v)
-	local content = v:sub(1,-6)
-	local ok = v:sub(-5,-5):byte()
-	local session = 0
-	for i=-4,-1 do
-		local c = v:byte(i)
-		session = session + bit32.lshift(c,(-1-i) * 8)
-	end
+	local size = #v - 5
+	local content, ok, session = string.unpack("c"..tostring(size).."B>I4", v)
 	return ok ~=0 , content, session
 end
 
@@ -132,11 +123,7 @@ end
 local readpackage = unpack_f(unpack_package)
 
 local function send_package(fd, pack)
-	local size = #pack
-	local package = string.char(bit32.extract(size,8,8))..
-		string.char(bit32.extract(size,0,8))..
-		pack
-
+	local package = string.pack(">s2", pack)
 	socket.send(fd, package)
 end
 

examples/login/logind.lua

@@ -54,9 +54,9 @@ function CMD.logout(uid, subid)
 	end
 end
 
-function server.command_handler(command, source, ...)
+function server.command_handler(command, ...)
 	local f = assert(CMD[command])
-	return f(source, ...)
+	return f(...)
 end
 
 login(server)

lualib-src/sproto/README.md

@@ -140,11 +140,11 @@ The schema text is like this:
 }
 
 .AddressBook {
-    person 0 : *Person
+    person 0 : *Person(id)	# (id) is optional, means Person.id is main index.
 }
 
 foobar 1 {	# define a new protocol (for RPC used) with tag 1
-    request person	# Associate the type person with foobar.request
+    request Person	# Associate the type Person with foobar.request
     response {	# define the foobar.response type
         ok 0 : boolean
     }
@@ -161,6 +161,7 @@ A schema text can be self-described by the sproto schema language.
         type 1 : string
         id 2 : integer
         array 3 : boolean
+        key 4 : integer	# optional tag for map
     }
     name 0 : string
     fields 1 : *field
@@ -183,10 +184,12 @@ Types
 =======
 
 * **string** : binary string
-* **integer** : integer, the max length of a integer is signed 64bit.
+* **integer** : integer, the max length of an integer is signed 64bit.
 * **boolean** : true or false
 
-You can add * before the typename to declare an array.
+You can add * before the typename to declare an array. 
+
+You can also specify a main index, the array whould be encode as an unordered map.
 
 User defined type can be any name in alphanumeric characters except the build-in typenames, and nested types are supported.
 
@@ -319,7 +322,19 @@ struct sproto_type * sproto_type(struct sproto *, const char * typename);
 Query the type object from a sproto object:
 
 ```C
-typedef int (*sproto_callback)(void *ud, const char *tagname, int type, int index, struct sproto_type *, void *value, int length);
+struct sproto_arg {
+	void *ud;
+	const char *tagname;
+	int tagid;
+	int type;
+	struct sproto_type *subtype;
+	void *value;
+	int length;
+	int index;	// array base 1
+	int mainindex;	// for map
+};
+
+typedef int (*sproto_callback)(const struct sproto_arg *args);
 
 int sproto_decode(struct sproto_type *, const void * data, int size, sproto_callback cb, void *ud);
 int sproto_encode(struct sproto_type *, void * buffer, int size, sproto_callback cb, void *ud);
@@ -334,13 +349,9 @@ int sproto_unpack(const void * src, int srcsz, void * buffer, int bufsz);
 
 pack and unpack the message with the 0 packing algorithm.
 
-JIT
+Other Implementions and bindings
 =====
-You may also interest in https://github.com/lvzixun/sproto-JIT
-
-C# version
-=====
-https://github.com/lvzixun/sproto-Csharp
+See Wiki https://github.com/cloudwu/sproto/wiki
 
 Question?
 ==========

lualib-src/sproto/lsproto.c

@@ -9,7 +9,6 @@
 #define MAX_GLOBALSPROTO 16
 #define ENCODE_BUFFERSIZE 2050
 
-//#define ENCODE_BUFFERSIZE 2050
 #define ENCODE_MAXSIZE 0x1000000
 #define ENCODE_DEEPLEVEL 64
 
@@ -40,6 +39,13 @@ LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
 #define luaL_newlib(L,l)  (luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
 #endif
 
+#if LUA_VERSION_NUM < 503
+
+// lua_isinteger is lua 5.3 api
+#define lua_isinteger lua_isnumber
+
+#endif
+
 static int
 lnewproto(lua_State *L) {
 	size_t sz = 0;
@@ -94,18 +100,20 @@ struct encode_ud {
 	const char * array_tag;
 	int array_index;
 	int deep;
+	int iter_index;
 };
 
 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;
+encode(const struct sproto_arg *args) {
+	struct encode_ud *self = args->ud;
 	lua_State *L = self->L;
 	if (self->deep >= ENCODE_DEEPLEVEL)
 		return luaL_error(L, "The table is too deep");
-	if (index > 0) {
-		if (tagname != self->array_tag) {
-			self->array_tag = tagname;
-			lua_getfield(L, self->tbl_index, tagname);
+	if (args->index > 0) {
+		if (args->tagname != self->array_tag) {
+			// a new array
+			self->array_tag = args->tagname;
+			lua_getfield(L, self->tbl_index, args->tagname);
 			if (lua_isnil(L, -1)) {
 				if (self->array_index) {
 					lua_replace(L, self->array_index);
@@ -113,66 +121,108 @@ encode(void *ud, const char *tagname, int type, int index, struct sproto_type *s
 				self->array_index = 0;
 				return 0;
 			}
+			if (!lua_istable(L, -1)) {
+				return luaL_error(L, ".*%s(%d) should be a table (Is a %s)",
+					args->tagname, args->index, lua_typename(L, lua_type(L, -1)));
+			}
 			if (self->array_index) {
 				lua_replace(L, self->array_index);
 			} else {
 				self->array_index = lua_gettop(L);
 			}
 		}
-		lua_rawgeti(L, self->array_index, index);
+		if (args->mainindex >= 0) {
+			// use lua_next to iterate the table
+			// todo: check the key is equal to mainindex value
+
+			lua_pushvalue(L,self->iter_index);
+			if (!lua_next(L, self->array_index)) {
+				// iterate end
+				lua_pushnil(L);
+				lua_replace(L, self->iter_index);
+				return 0;
+			}
+			lua_insert(L, -2);
+			lua_replace(L, self->iter_index);
+		} else {
+			lua_rawgeti(L, self->array_index, args->index);
+		}
 	} else {
-		lua_getfield(L, self->tbl_index, tagname);
+		lua_getfield(L, self->tbl_index, args->tagname);
 	}
 	if (lua_isnil(L, -1)) {
 		lua_pop(L,1);
 		return 0;
 	}
-	switch (type) {
+	switch (args->type) {
 	case SPROTO_TINTEGER: {
-		lua_Integer v = luaL_checkinteger(L, -1);
+		lua_Integer v;
 		lua_Integer vh;
+		if (!lua_isinteger(L, -1)) {
+			return luaL_error(L, ".%s[%d] is not an integer (Is a %s)", 
+				args->tagname, args->index, lua_typename(L, lua_type(L, -1)));
+		} else {
+			v = lua_tointeger(L, -1);
+		}
 		lua_pop(L,1);
 		// notice: in lua 5.2, lua_Integer maybe 52bit
 		vh = v >> 31;
 		if (vh == 0 || vh == -1) {
-			*(uint32_t *)value = (uint32_t)v;
+			*(uint32_t *)args->value = (uint32_t)v;
 			return 4;
 		}
 		else {
-			*(uint64_t *)value = (uint64_t)v;
+			*(uint64_t *)args->value = (uint64_t)v;
 			return 8;
 		}
 	}
 	case SPROTO_TBOOLEAN: {
 		int v = lua_toboolean(L, -1);
-		*(int *)value = v;
+		if (!lua_isboolean(L,-1)) {
+			return luaL_error(L, ".%s[%d] is not a boolean (Is a %s)",
+				args->tagname, args->index, lua_typename(L, lua_type(L, -1)));
+		}
+		*(int *)args->value = v;
 		lua_pop(L,1);
 		return 4;
 	}
 	case SPROTO_TSTRING: {
 		size_t sz = 0;
-		const char * str = luaL_checklstring(L, -1, &sz);
-		if (sz > length)
+		const char * str;
+		if (!lua_isstring(L, -1)) {
+			return luaL_error(L, ".%s[%d] is not a string (Is a %s)", 
+				args->tagname, args->index, lua_typename(L, lua_type(L, -1)));
+		} else {
+			str = lua_tolstring(L, -1, &sz);
+		}
+		if (sz > args->length)
 			return -1;
-		memcpy(value, str, sz);
+		memcpy(args->value, str, sz);
 		lua_pop(L,1);
 		return sz;
 	}
 	case SPROTO_TSTRUCT: {
 		struct encode_ud sub;
 		int r;
+		int top = lua_gettop(L);
+		if (!lua_istable(L, top)) {
+			return luaL_error(L, ".%s[%d] is not a table (Is a %s)", 
+				args->tagname, args->index, lua_typename(L, lua_type(L, -1)));
+		}
 		sub.L = L;
-		sub.st = st;
-		sub.tbl_index = lua_gettop(L);
+		sub.st = args->subtype;
+		sub.tbl_index = top;
 		sub.array_tag = NULL;
 		sub.array_index = 0;
 		sub.deep = self->deep + 1;
-		r = sproto_encode(st, value, length, encode, &sub);
-		lua_pop(L,1);
+		lua_pushnil(L);	// prepare an iterator slot
+		sub.iter_index = sub.tbl_index + 1;
+		r = sproto_encode(args->subtype, args->value, args->length, encode, &sub);
+		lua_settop(L, top-1);	// pop the value
 		return r;
 	}
 	default:
-		return luaL_error(L, "Invalid field type %d", type);
+		return luaL_error(L, "Invalid field type %d", args->type);
 	}
 }
 
@@ -205,21 +255,27 @@ lencode(lua_State *L) {
 	struct encode_ud self;
 	void * buffer = lua_touserdata(L, lua_upvalueindex(1));
 	int sz = lua_tointeger(L, lua_upvalueindex(2));
-
+	int tbl_index = 2;
 	struct sproto_type * st = lua_touserdata(L, 1);
 	if (st == NULL) {
 		return luaL_argerror(L, 1, "Need a sproto_type object");
 	}
-	luaL_checktype(L, 2, LUA_TTABLE);
-	luaL_checkstack(L, ENCODE_DEEPLEVEL + 8, NULL);
+	luaL_checktype(L, tbl_index, LUA_TTABLE);
+	luaL_checkstack(L, ENCODE_DEEPLEVEL*2 + 8, NULL);
 	self.L = L;
 	self.st = st;
-	self.tbl_index = 2;
-	self.array_tag = NULL;
-	self.array_index = 0;
-	self.deep = 0;
+	self.tbl_index = tbl_index;
 	for (;;) {
-		int r = sproto_encode(st, buffer, sz, encode, &self);
+		int r;
+		self.array_tag = NULL;
+		self.array_index = 0;
+		self.deep = 0;
+
+		lua_settop(L, tbl_index);
+		lua_pushnil(L);	// for iterator (stack slot 3)
+		self.iter_index = tbl_index+1;
+
+		r = sproto_encode(st, buffer, sz, encode, &self);
 		if (r<0) {
 			buffer = expand_buffer(L, sz, sz*2);
 			sz *= 2;
@@ -236,21 +292,23 @@ struct decode_ud {
 	int array_index;
 	int result_index;
 	int deep;
+	int mainindex_tag;
+	int key_index;
 };
 
 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;
+decode(const struct sproto_arg *args) {
+	struct decode_ud * self = args->ud;
 	lua_State *L = self->L;
 	if (self->deep >= ENCODE_DEEPLEVEL)
 		return luaL_error(L, "The table is too deep");
-	if (index > 0) {
+	if (args->index > 0) {
 		// It's array
-		if (tagname != self->array_tag) {
-			self->array_tag = tagname;
+		if (args->tagname != self->array_tag) {
+			self->array_tag = args->tagname;
 			lua_newtable(L);
 			lua_pushvalue(L, -1);
-			lua_setfield(L, self->result_index, tagname);
+			lua_setfield(L, self->result_index, args->tagname);
 			if (self->array_index) {
 				lua_replace(L, self->array_index);
 			} else {
@@ -258,20 +316,20 @@ decode(void *ud, const char *tagname, int type, int index, struct sproto_type *s
 			}
 		}
 	}
-	switch (type) {
+	switch (args->type) {
 	case SPROTO_TINTEGER: {
 		// notice: in lua 5.2, 52bit integer support (not 64)
-		lua_Integer v = *(uint64_t*)value;
+		lua_Integer v = *(uint64_t*)args->value;
 		lua_pushinteger(L, v);
 		break;
 	}
 	case SPROTO_TBOOLEAN: {
-		int v = *(uint64_t*)value;
+		int v = *(uint64_t*)args->value;
 		lua_pushboolean(L,v);
 		break;
 	}
 	case SPROTO_TSTRING: {
-		lua_pushlstring(L, value, length);
+		lua_pushlstring(L, args->value, args->length);
 		break;
 	}
 	case SPROTO_TSTRUCT: {
@@ -283,20 +341,47 @@ decode(void *ud, const char *tagname, int type, int index, struct sproto_type *s
 		sub.deep = self->deep + 1;
 		sub.array_index = 0;
 		sub.array_tag = NULL;
+		if (args->mainindex >= 0) {
+			// This struct will set into a map, so mark the main index tag.
+			sub.mainindex_tag = args->mainindex;
+			lua_pushnil(L);
+			sub.key_index = lua_gettop(L);
 
-		r = sproto_decode(st, value, length, decode, &sub);
-		if (r < 0 || r != length)
-			return r;
-		lua_settop(L, sub.result_index);
-		break;
+			r = sproto_decode(args->subtype, args->value, args->length, decode, &sub);
+			if (r < 0 || r != args->length)
+				return r;
+			// assert(args->index > 0);
+			lua_pushvalue(L, sub.key_index);
+			if (lua_isnil(L, -1)) {
+				luaL_error(L, "Can't find main index (tag=%d) in [%s]", args->mainindex, args->tagname);
+			}
+			lua_pushvalue(L, sub.result_index);
+			lua_rawset(L, self->array_index);
+			lua_settop(L, sub.result_index-1);
+			return 0;
+		} else {
+			sub.mainindex_tag = -1;
+			sub.key_index = 0;
+			r = sproto_decode(args->subtype, args->value, args->length, decode, &sub);
+			if (r < 0 || r != args->length)
+				return r;
+			lua_settop(L, sub.result_index);
+			break;
+		}
 	}
 	default:
 		luaL_error(L, "Invalid type");
 	}
-	if (index > 0) {
-		lua_rawseti(L, self->array_index, index);
+	if (args->index > 0) {
+		lua_rawseti(L, self->array_index, args->index);
 	} else {
-		lua_setfield(L, self->result_index, tagname);
+		if (self->mainindex_tag == args->tagid) {
+			// This tag is marked, save the value to key_index
+			// assert(self->key_index > 0);
+			lua_pushvalue(L,-1);
+			lua_replace(L, self->key_index);
+		}
+		lua_setfield(L, self->result_index, args->tagname);
 	}
 
 	return 0;
@@ -339,12 +424,14 @@ ldecode(lua_State *L) {
 	if (!lua_istable(L, -1)) {
 		lua_newtable(L);
 	}
-	luaL_checkstack(L, ENCODE_DEEPLEVEL*2 + 8, NULL);
+	luaL_checkstack(L, ENCODE_DEEPLEVEL*3 + 8, NULL);
 	self.L = L;
 	self.result_index = lua_gettop(L);
 	self.array_index = 0;
 	self.array_tag = NULL;
 	self.deep = 0;
+	self.mainindex_tag = -1;
+	self.key_index = 0;
 	r = sproto_decode(st, buffer, (int)sz, decode, &self);
 	if (r < 0) {
 		return luaL_error(L, "decode error");

lualib-src/sproto/sproto.c

@@ -17,6 +17,7 @@ struct field {
 	int type;
 	const char * name;
 	struct sproto_type * st;
+	int key;
 };
 
 struct sproto_type {
@@ -188,6 +189,7 @@ import_field(struct sproto *s, struct field *f, const uint8_t * stream) {
 	f->type = -1;
 	f->name = NULL;
 	f->st = NULL;
+	f->key = -1;
 
 	sz = todword(stream);
 	stream += SIZEOF_LENGTH;
@@ -234,6 +236,9 @@ import_field(struct sproto *s, struct field *f, const uint8_t * stream) {
 			if (value)
 				array = SPROTO_TARRAY;
 			break;
+		case 5:	// key
+			f->key = value;
+			break;
 		default:
 			return NULL;
 		}
@@ -485,7 +490,11 @@ sproto_dump(struct sproto *s) {
 					type_name = buildin[t];
 				}
 			}
-			printf("\t%s (%d) %s%s\n", f->name, f->tag, array, type_name);
+			if (f->key >= 0) {
+				printf("\t%s (%d) %s%s(%d)\n", f->name, f->tag, array, type_name, f->key);
+			} else {
+				printf("\t%s (%d) %s%s\n", f->name, f->tag, array, type_name);
+			}
 		}
 	}
 	printf("=== %d protocol ===\n", s->protocol_n);
@@ -637,22 +646,37 @@ encode_uint64(uint64_t v, uint8_t * data, int size) {
 	return fill_size(data, sizeof(v));
 }
 
+/*
+//#define CB(tagname,type,index,subtype,value,length) cb(ud, tagname,type,index,subtype,value,length)
+
 static int
-encode_string(sproto_callback cb, void *ud, struct field *f, uint8_t *data, int size) {
+do_cb(sproto_callback cb, void *ud, const char *tagname, int type, int index, struct sproto_type *subtype, void *value, int length) {
+	if (subtype) {
+		if (type >= 0) {
+			printf("callback: tag=%s[%d], subtype[%s]:%d\n",tagname,index, subtype->name, type);
+		} else {
+			printf("callback: tag=%s[%d], subtype[%s]\n",tagname,index, subtype->name);
+		}
+	} else if (index > 0) {
+		printf("callback: tag=%s[%d]\n",tagname,index);
+	} else if (index == 0) {
+		printf("callback: tag=%s\n",tagname);
+	} else {
+		printf("callback: tag=%s [mainkey]\n",tagname);
+	}
+	return cb(ud, tagname,type,index,subtype,value,length);
+}
+#define CB(tagname,type,index,subtype,value,length) do_cb(cb,ud, tagname,type,index,subtype,value,length)
+*/
+
+static int
+encode_object(sproto_callback cb, struct sproto_arg *args, uint8_t *data, int size) {
 	int sz;
 	if (size < SIZEOF_LENGTH)
 		return -1;
-	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;
-	}
-	sz = cb(ud, f->name, SPROTO_TSTRUCT, 0, f->st, data+SIZEOF_LENGTH, size-SIZEOF_LENGTH);
+	args->value = data+SIZEOF_LENGTH;
+	args->length = size-SIZEOF_LENGTH;
+	sz = cb(args);
 	return fill_size(data, sz);
 }
 
@@ -672,7 +696,7 @@ 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) {
+encode_integer_array(sproto_callback cb, struct sproto_arg *args, uint8_t *buffer, int size) {
 	uint8_t * header = buffer;
 	int intlen;
 	int index;
@@ -688,7 +712,10 @@ encode_integer_array(sproto_callback cb, void *ud, struct field *f, uint8_t *buf
 			uint64_t u64;
 			uint32_t u32;
 		} u;
-		sz = cb(ud, f->name, SPROTO_TINTEGER, index, f->st, &u, sizeof(u));
+		args->value = &u;
+		args->length = sizeof(u);
+		args->index = index;
+		sz = cb(args);
 		if (sz < 0)
 			return NULL;
 		if (sz == 0)
@@ -749,27 +776,26 @@ 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) {
+encode_array(sproto_callback cb, struct sproto_arg *args, uint8_t *data, int size) {
 	uint8_t * buffer;
-	int index;
-	int type;
 	int sz;
 	if (size < SIZEOF_LENGTH)
 		return -1;
 	size -= SIZEOF_LENGTH;
-	index = 1;
 	buffer = data + SIZEOF_LENGTH;
-	type = f->type & ~SPROTO_TARRAY;
-	switch (type) {
+	switch (args->type) {
 	case SPROTO_TINTEGER:
-		buffer = encode_integer_array(cb,ud,f,buffer,size);
+		buffer = encode_integer_array(cb,args,buffer,size);
 		if (buffer == NULL)
 			return -1;
 		break;
 	case SPROTO_TBOOLEAN:
+		args->index = 1;
 		for (;;) {
 			int v = 0;
-			int sz = cb(ud, f->name, type, index, f->st, &v, sizeof(v));
+			args->value = &v;
+			args->length = sizeof(v);
+			sz = cb(args);
 			if (sz < 0)
 				return -1;
 			if (sz == 0)
@@ -779,16 +805,18 @@ encode_array(sproto_callback cb, void *ud, struct field *f, uint8_t *data, int s
 			buffer[0] = v ? 1: 0;
 			size -= 1;
 			buffer += 1;
-			index++;
+			++args->index;
 		}
 		break;
 	default:
+		args->index = 1;
 		for (;;) {
-			int sz;
 			if (size < SIZEOF_LENGTH)
 				return -1;
 			size -= SIZEOF_LENGTH;
-			sz = cb(ud, f->name, type, index, f->st, buffer+SIZEOF_LENGTH, size);
+			args->value = buffer+SIZEOF_LENGTH;
+			args->length = size;
+			sz = cb(args);
 			if (sz < 0)
 				return -1;
 			if (sz == 0)
@@ -796,7 +824,7 @@ encode_array(sproto_callback cb, void *ud, struct field *f, uint8_t *data, int s
 			fill_size(buffer, sz);
 			buffer += SIZEOF_LENGTH+sz;
 			size -=sz;
-			index ++;
+			++args->index;
 		}
 		break;
 	}
@@ -808,6 +836,7 @@ encode_array(sproto_callback cb, void *ud, struct field *f, uint8_t *data, int s
 
 int
 sproto_encode(struct sproto_type *st, void * buffer, int size, sproto_callback cb, void *ud) {
+	struct sproto_arg args;
 	uint8_t * header = buffer;
 	uint8_t * data;
 	int header_sz = SIZEOF_HEADER + st->maxn * SIZEOF_FIELD;
@@ -817,6 +846,7 @@ sproto_encode(struct sproto_type *st, void * buffer, int size, sproto_callback c
 	int datasz;
 	if (size < header_sz)
 		return -1;
+	args.ud = ud;
 	data = header + header_sz;
 	size -= header_sz;
 	index = 0;
@@ -826,9 +856,16 @@ sproto_encode(struct sproto_type *st, void * buffer, int size, sproto_callback c
 		int type = f->type;
 		int value = 0;
 		int sz = -1;
+		args.tagname = f->name;
+		args.tagid = f->tag;
+		args.subtype = f->st;
+		args.mainindex = f->key;
 		if (type & SPROTO_TARRAY) {
-			sz = encode_array(cb,ud, f, data, size);
+			args.type = type & ~SPROTO_TARRAY;
+			sz = encode_array(cb, &args, data, size);
 		} else {
+			args.type = type;
+			args.index = 0;
 			switch(type) {
 			case SPROTO_TINTEGER:
 			case SPROTO_TBOOLEAN: {
@@ -836,7 +873,9 @@ sproto_encode(struct sproto_type *st, void * buffer, int size, sproto_callback c
 					uint64_t u64;
 					uint32_t u32;
 				} u;
-				sz = cb(ud, f->name, type, 0, NULL, &u, sizeof(u));
+				args.value = &u;
+				args.length = sizeof(u);
+				sz = cb(&args);
 				if (sz < 0)
 					return -1;
 				if (sz == 0)
@@ -855,12 +894,9 @@ sproto_encode(struct sproto_type *st, void * buffer, int size, sproto_callback c
 				}
 				break;
 			}
+			case SPROTO_TSTRUCT:
 			case SPROTO_TSTRING: {
-				sz = encode_string(cb, ud, f, data, size);
-				break;
-			}
-			case SPROTO_TSTRUCT: {
-				sz = encode_struct(cb, ud, f, data, size);
+				sz = encode_object(cb, &args, data, size);
 				break;
 			}
 			}
@@ -904,9 +940,8 @@ sproto_encode(struct sproto_type *st, void * buffer, int size, sproto_callback c
 }
 
 static int
-decode_array_object(sproto_callback cb, void *ud, struct field *f, uint8_t * stream, int sz) {
+decode_array_object(sproto_callback cb, struct sproto_arg *args, uint8_t * stream, int sz) {
 	uint32_t hsz;
-	int type = f->type & ~SPROTO_TARRAY;
 	int index = 1;
 	while (sz > 0) {
 		if (sz < SIZEOF_LENGTH)
@@ -916,7 +951,10 @@ decode_array_object(sproto_callback cb, void *ud, struct field *f, uint8_t * str
 		sz -= SIZEOF_LENGTH;
 		if (hsz > sz)
 			return -1;
-		if (cb(ud, f->name, type, index, f->st, stream, hsz))
+		args->index = index;
+		args->value = stream;
+		args->length = hsz;
+		if (cb(args))
 			return -1;
 		sz -= hsz;
 		stream += hsz;
@@ -935,9 +973,9 @@ expand64(uint32_t v) {
 }
 
 static int
-decode_array(sproto_callback cb, void *ud, struct field *f, uint8_t * stream) {
+decode_array(sproto_callback cb, struct sproto_arg *args, uint8_t * stream) {
 	uint32_t sz = todword(stream);
-	int type = f->type & ~SPROTO_TARRAY;
+	int type = args->type;
 	int i;
 	stream += SIZEOF_LENGTH;
 	switch (type) {
@@ -953,7 +991,10 @@ decode_array(sproto_callback cb, void *ud, struct field *f, uint8_t * stream) {
 				return -1;
 			for (i=0;i<sz/sizeof(uint32_t);i++) {
 				uint64_t value = expand64(todword(stream + i*sizeof(uint32_t)));
-				cb(ud, f->name, SPROTO_TINTEGER, i+1, NULL, &value, sizeof(value));
+				args->index = i+1;
+				args->value = &value;
+				args->length = sizeof(value);
+				cb(args);
 			}
 		} else if (len == sizeof(uint64_t)) {
 			if (sz % sizeof(uint64_t) != 0)
@@ -962,7 +1003,10 @@ decode_array(sproto_callback cb, void *ud, struct field *f, uint8_t * stream) {
 				uint64_t low = todword(stream + i*sizeof(uint64_t));
 				uint64_t hi = todword(stream + i*sizeof(uint64_t) + sizeof(uint32_t));
 				uint64_t value = low | hi << 32;
-				cb(ud, f->name, SPROTO_TINTEGER, i+1, NULL, &value, sizeof(value));
+				args->index = i+1;
+				args->value = &value;
+				args->length = sizeof(value);
+				cb(args);
 			}
 		} else {
 			return -1;
@@ -972,12 +1016,15 @@ decode_array(sproto_callback cb, void *ud, struct field *f, uint8_t * stream) {
 	case SPROTO_TBOOLEAN:
 		for (i=0;i<sz;i++) {
 			uint64_t value = stream[i];
-			cb(ud, f->name, SPROTO_TBOOLEAN, i+1, NULL, &value, sizeof(value));
+			args->index = i+1;
+			args->value = &value;
+			args->length = sizeof(value);
+			cb(args);
 		}
 		break;
 	case SPROTO_TSTRING:
 	case SPROTO_TSTRUCT:
-		return decode_array_object(cb, ud, f, stream, sz);
+		return decode_array_object(cb, args, stream, sz);
 	default:
 		return -1;
 	}
@@ -986,6 +1033,7 @@ decode_array(sproto_callback cb, void *ud, struct field *f, uint8_t * stream) {
 
 int
 sproto_decode(struct sproto_type *st, const void * data, int size, sproto_callback cb, void *ud) {
+	struct sproto_arg args;
 	int total = size;
 	uint8_t * stream;
 	uint8_t * datastream;
@@ -994,6 +1042,8 @@ sproto_decode(struct sproto_type *st, const void * data, int size, sproto_callba
 	int tag;
 	if (size < SIZEOF_HEADER)
 		return -1;
+	// debug print
+	// printf("sproto_decode[%p] (%s)\n", ud, st->name);
 	stream = (void *)data;
 	fn = toword(stream);
 	stream += SIZEOF_HEADER;
@@ -1001,7 +1051,8 @@ sproto_decode(struct sproto_type *st, const void * data, int size, sproto_callba
 	if (size < fn * SIZEOF_FIELD)
 		return -1;
 	datastream = stream + fn * SIZEOF_FIELD;
-	size -= fn * SIZEOF_FIELD ;
+	size -= fn * SIZEOF_FIELD;
+	args.ud = ud;
 
 	tag = -1;
 	for (i=0;i<fn;i++) {
@@ -1028,9 +1079,15 @@ sproto_decode(struct sproto_type *st, const void * data, int size, sproto_callba
 		f = findtag(st, tag);
 		if (f == NULL)
 			continue;
+		args.tagname = f->name;
+		args.tagid = f->tag;
+		args.type = f->type & ~SPROTO_TARRAY;
+		args.subtype = f->st;
+		args.index = 0;
+		args.mainindex = f->key;
 		if (value < 0) {
 			if (f->type & SPROTO_TARRAY) {
-				if (decode_array(cb, ud, f, currentdata)) {
+				if (decode_array(cb, &args, currentdata)) {
 					return -1;
 				}
 			} else {
@@ -1039,21 +1096,27 @@ sproto_decode(struct sproto_type *st, const void * data, int size, sproto_callba
 					uint32_t sz = todword(currentdata);
 					if (sz == sizeof(uint32_t)) {
 						uint64_t v = expand64(todword(currentdata + SIZEOF_LENGTH));
-						cb(ud, f->name, SPROTO_TINTEGER, 0, NULL, &v, sizeof(v));
+						args.value = &v;
+						args.length = sizeof(v);
+						cb(&args);
 					} else if (sz != sizeof(uint64_t)) {
 						return -1;
 					} else {
 						uint32_t low = todword(currentdata + SIZEOF_LENGTH);
 						uint32_t hi = todword(currentdata + SIZEOF_LENGTH + sizeof(uint32_t));
 						uint64_t v = (uint64_t)low | (uint64_t) hi << 32;
-						cb(ud, f->name, SPROTO_TINTEGER, 0, NULL, &v, sizeof(v));
+						args.value = &v;
+						args.length = sizeof(v);
+						cb(&args);
 					}
 					break;
 				}
 				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))
+					args.value = currentdata+SIZEOF_LENGTH;
+					args.length = sz;
+					if (cb(&args))
 						return -1;
 					break;
 				}
@@ -1065,7 +1128,9 @@ sproto_decode(struct sproto_type *st, const void * data, int size, sproto_callba
 			return -1;
 		} else {
 			uint64_t v = value;
-			cb(ud, f->name, f->type, 0, NULL, &v, sizeof(v));
+			args.value = &v;
+			args.length = sizeof(v);
+			cb(&args);
 		}
 	}
 	return total - size;

lualib-src/sproto/sproto.h

@@ -27,7 +27,19 @@ struct sproto_type * sproto_type(struct sproto *, const char * type_name);
 int sproto_pack(const void * src, int srcsz, void * buffer, int bufsz);
 int sproto_unpack(const void * src, int srcsz, void * buffer, int bufsz);
 
-typedef int (*sproto_callback)(void *ud, const char *tagname, int type, int index, struct sproto_type *, void *value, int length);
+struct sproto_arg {
+	void *ud;
+	const char *tagname;
+	int tagid;
+	int type;
+	struct sproto_type *subtype;
+	void *value;
+	int length;
+	int index;	// array base 1
+	int mainindex;	// for map
+};
+
+typedef int (*sproto_callback)(const struct sproto_arg *args);
 
 int sproto_decode(struct sproto_type *, const void * data, int size, sproto_callback cb, void *ud);
 int sproto_encode(struct sproto_type *, void * buffer, int size, sproto_callback cb, void *ud);

lualib/dns.lua

@@ -0,0 +1,290 @@
+--[[
+	lua dns resolver library
+	See  https://github.com/xjdrew/levent/blob/master/levent/dns.lua for more detail
+
+-- resource record type:
+-- TYPE            value and meaning
+-- A               1 a host address
+-- NS              2 an authoritative name server
+-- MD              3 a mail destination (Obsolete - use MX)
+-- MF              4 a mail forwarder (Obsolete - use MX)
+-- CNAME           5 the canonical name for an alias
+-- SOA             6 marks the start of a zone of authority
+-- MB              7 a mailbox domain name (EXPERIMENTAL)
+-- MG              8 a mail group member (EXPERIMENTAL)
+-- MR              9 a mail rename domain name (EXPERIMENTAL)
+-- NULL            10 a null RR (EXPERIMENTAL)
+-- WKS             11 a well known service description
+-- PTR             12 a domain name pointer
+-- HINFO           13 host information
+-- MINFO           14 mailbox or mail list information
+-- MX              15 mail exchange
+-- TXT             16 text strings
+-- AAAA            28 a ipv6 host address
+-- only appear in the question section:
+-- AXFR            252 A request for a transfer of an entire zone
+-- MAILB           253 A request for mailbox-related records (MB, MG or MR)
+-- MAILA           254 A request for mail agent RRs (Obsolete - see MX)
+-- *               255 A request for all records
+--
+-- resource recode class:
+-- IN              1 the Internet
+-- CS              2 the CSNET class (Obsolete - used only for examples in some obsolete RFCs)
+-- CH              3 the CHAOS class
+-- HS              4 Hesiod [Dyer 87]
+-- only appear in the question section:
+-- *               255 any class
+-- ]]
+
+--[[
+-- struct header {
+--  uint16_t tid     # identifier assigned by the program that generates any kind of query.
+--  uint16_t flags   # flags
+--  uint16_t qdcount # the number of entries in the question section.
+--  uint16_t ancount # the number of resource records in the answer section.
+--  uint16_t nscount # the number of name server resource records in the authority records section.
+--  uint16_t arcount # the number of resource records in the additional records section.
+-- }
+--
+-- request body:
+-- struct request {
+--  string name
+--  uint16_t atype
+--  uint16_t class
+-- }
+--
+-- response body:
+-- struct response {
+--  string name
+--  uint16_t atype
+--  uint16_t class
+--  uint16_t ttl
+--  uint16_t rdlength
+--  string rdata
+-- }
+--]]
+
+local skynet = require "skynet"
+local socket = require "socket"
+
+local MAX_DOMAIN_LEN = 1024
+local MAX_LABEL_LEN = 63
+local MAX_PACKET_LEN = 2048
+local DNS_HEADER_LEN = 12
+
+local QTYPE = {
+	A = 1,
+	CNAME = 5,
+	AAAA = 28,
+}
+
+local QCLASS = {
+	IN = 1,
+}
+
+local dns = {}
+
+local function verify_domain_name(name)
+	if #name > MAX_DOMAIN_LEN then
+		return false
+	end
+	if not name:match("^[%l%d-%.]+$") then
+		return false
+	end
+	for w in name:gmatch("([%w-]+)%.?") do
+		if #w > MAX_LABEL_LEN then
+			return false
+		end
+	end
+	return true
+end
+
+local next_tid = 1
+local function gen_tid()
+	local tid = next_tid
+	next_tid = next_tid + 1
+	return tid
+end
+
+local function pack_header(t)
+	return string.pack(">HHHHHH",
+		t.tid, t.flags, t.qdcount, t.ancount or 0, t.nscount or 0, t.arcount or 0)
+end
+
+local function pack_question(name, qtype, qclass)
+	local labels = {}
+	for w in name:gmatch("([%w-]+)%.?") do
+		table.insert(labels, string.pack("s1",w))
+	end
+	table.insert(labels, '\0')
+	table.insert(labels, string.pack(">HH", qtype, qclass))
+	return table.concat(labels)
+end
+
+local function unpack_header(chunk)
+	local tid, flags, qdcount, ancount, nscount, arcount, left = string.unpack(">HHHHHH", chunk)
+	return {
+		tid = tid,
+		flags = flags,
+		qdcount = qdcount,
+		ancount = ancount,
+		nscount = nscount,
+		arcount = arcount
+	}, left
+end
+
+-- unpack a resource name
+local function unpack_name(chunk, left)
+	local t = {}
+	local jump_pointer
+	local tag, offset, label
+	while true do
+		tag, left = string.unpack("B", chunk, left)
+		if tag & 0xc0 == 0xc0 then
+			-- pointer
+			offset,left = string.unpack(">H", chunk, left - 1)
+			offset = offset & 0x3fff
+			if not jump_pointer then
+				jump_pointer = left
+			end
+			-- offset is base 0, need to plus 1
+			left = offset + 1
+		elseif tag == 0 then
+			break
+		else
+			label, left = string.unpack("s1", chunk, left - 1)
+			t[#t+1] = label
+		end
+	end
+	return table.concat(t, "."), jump_pointer or left
+end
+
+local function unpack_question(chunk, left)
+	local name, left = unpack_name(chunk, left)
+	local atype, class, left = string.unpack(">HH", chunk, left)
+	return {
+		name = name,
+		atype = atype,
+		class = class
+	}, left
+end
+
+local function unpack_answer(chunk, left)
+	local name, left = unpack_name(chunk, left)
+	local atype, class, ttl, rdata, left = string.unpack(">HHI4s2", chunk, left)
+	return {
+		name = name,
+		atype = atype,
+		class = class,
+		ttl = ttl,
+		rdata = rdata
+	},left
+end
+
+local function unpack_rdata(qtype, chunk)
+	if qtype == QTYPE.A then
+		local a,b,c,d = string.unpack("BBBB", chunk)
+		return string.format("%d.%d.%d.%d", a,b,c,d)
+	elseif qtype == QTYPE.AAAA then
+		local a,b,c,d,e,f,g,h = string.unpack(">HHHHHHHH", chunk)
+		return string.format("%x:%x:%x:%x:%x:%x:%x:%x", a, b, c, d, e, f, g, h)
+	else
+		error("Error qtype " .. qtype)
+	end
+end
+
+local dns_server
+local request_pool = {}
+
+local function resolve(content)
+	if #content < DNS_HEADER_LEN then
+		-- drop
+		skynet.error("Recv an invalid package when dns query")
+		return
+	end
+	local answer_header,left = unpack_header(content)
+	-- verify answer
+	assert(answer_header.qdcount == 1, "malformed packet")
+
+	local resp = request_pool[answer_header.tid]
+	if not resp then
+		skynet.error("Recv an invalid tid when dns query")
+		return
+	end
+
+	local question,left = unpack_question(content, left)
+	if question.name ~= resp.name then
+		skynet.error("Recv an invalid name when dns query")
+		return
+	end
+
+	local ttl
+	local answer
+	local answers = {}
+	for i=1, answer_header.ancount do
+		answer, left = unpack_answer(content, left)
+		-- only extract qtype address
+		if answer.atype == resp.qtype then
+			local ip = unpack_rdata(resp.qtype, answer.rdata)
+			ttl = ttl and math.min(ttl, answer.ttl) or answer.ttl
+			answers[#answers+1] = ip
+		end
+	end
+
+	if #answers > 0 then
+		resp.answers = answers
+	end
+
+	skynet.wakeup(resp.co)
+end
+
+function dns.server(server, port)
+	if not server then
+		local f = assert(io.open "/etc/resolv.conf")
+		for line in f:lines() do
+			server = line:match("%s*nameserver%s+([^%s]+)")
+			if server then
+				break
+			end
+		end
+		assert(server, "Can't get nameserver")
+	end
+	dns_server = socket.udp(function(data, sz, from)
+		resolve(skynet.tostring(data,sz))
+	end)
+	socket.udp_connect(dns_server, server, port or 53)
+	return server
+end
+
+local function suspend(tid, name, qtype)
+	local req = {
+		name = name,
+		tid = tid,
+		qtype = qtype,
+		time = skynet.now(),	-- for timeout
+		co = coroutine.running(),
+	}
+	request_pool[tid] = req
+	skynet.wait()
+	local answers = request_pool[tid].answers
+	request_pool[tid] = nil
+	assert(answers, "no ip")
+	return answers[1], answers
+end
+
+function dns.resolve(name, ipv6)
+	local qtype = ipv6 and QTYPE.AAAA or QTYPE.A
+	local name = name:lower()
+	assert(verify_domain_name(name) , "illegal name")
+	local question_header = {
+		tid = gen_tid(),
+		flags = 0x100, -- flags: 00000001 00000000, set RD
+		qdcount = 1,
+	}
+	local req = pack_header(question_header) .. pack_question(name, qtype, QCLASS.IN)
+	assert(dns_server, "Call dns.server fist")
+	socket.write(dns_server, req)
+	return suspend(question_header.tid, name, qtype)
+end
+
+return dns

lualib/http/httpc.lua

@@ -14,10 +14,15 @@ local function request(fd, method, host, url, recvheader, header, content)
 		for k,v in pairs(header) do
 			header_content = string.format("%s%s:%s\r\n", header_content, k, v)
 		end
+		if header.host then
+			host = ""
+		end
+	else
+		host = string.format("host:%s\r\n",host)
 	end
 
 	if content then
-		local data = string.format("%s %s HTTP/1.1\r\nhost:%s\r\ncontent-length:%d\r\n%s\r\n%s", method, url, host, #content, header_content, content)
+		local data = string.format("%s %s HTTP/1.1\r\n%scontent-length:%d\r\n%s\r\n%s", method, url, host, #content, header_content, content)
 		write(data)
 	else
 		local request_header = string.format("%s %s HTTP/1.1\r\nhost:%s\r\ncontent-length:0\r\n%s\r\n", method, url, host, header_content)

lualib/http/httpd.lua

@@ -1,6 +1,8 @@
 local internal = require "http.internal"
 
 local table = table
+local string = string
+local type = type
 
 local httpd = {}
 
@@ -112,7 +114,13 @@ local function writeall(writefunc, statuscode, bodyfunc, header)
 	writefunc(statusline)
 	if header then
 		for k,v in pairs(header) do
-			writefunc(string.format("%s: %s\r\n", k,v))
+			if type(v) == "table" then
+				for _,v in ipairs(v) do
+					writefunc(string.format("%s: %s\r\n", k,v))
+				end
+			else
+				writefunc(string.format("%s: %s\r\n", k,v))
+			end
 		end
 	end
 	local t = type(bodyfunc)

lualib/http/internal.lua

@@ -1,3 +1,6 @@
+local table = table
+local type = type
+
 local M = {}
 
 local LIMIT = 8192
@@ -83,7 +86,12 @@ function M.parseheader(lines, from, header)
 			end
 			name = name:lower()
 			if header[name] then
-				header[name] = header[name] .. ", " .. value
+				local v = header[name]
+				if type(v) == "table" then
+					table.insert(v, value)
+				else
+					header[name] = { v , value }
+				end
 			else
 				header[name] = value
 			end

lualib/sproto.lua

@@ -6,20 +6,21 @@ local host = {}
 
 local weak_mt = { __mode = "kv" }
 local sproto_mt = { __index = sproto }
+local sproto_nogc = { __index = sproto }
 local host_mt = { __index = host }
 
 function sproto_mt:__gc()
 	core.deleteproto(self.__cobj)
 end
 
-function sproto.new(...)
-	local cobj = assert(core.newproto(...))
+function sproto.new(bin,sz,nogc)
+	local cobj = assert(core.newproto(bin,sz))
 	local self = {
 		__cobj = cobj,
 		__tcache = setmetatable( {} , weak_mt ),
 		__pcache = setmetatable( {} , weak_mt ),
 	}
-	return setmetatable(self, sproto_mt)
+	return setmetatable(self, nogc and sproto_nogc or sproto_mt)
 end
 
 function sproto.parse(ptext)
@@ -63,9 +64,9 @@ function sproto:pencode(typename, tbl)
 	return core.pack(core.encode(st, tbl))
 end
 
-function sproto:pdecode(typename, bin)
+function sproto:pdecode(typename, ...)
 	local st = querytype(self, typename)
-	return core.decode(st, core.unpack(bin))
+	return core.decode(st, core.unpack(...))
 end
 
 local function queryproto(self, pname)

lualib/sprotoloader.lua

@@ -16,7 +16,8 @@ loader.save = core.saveproto
 
 function loader.load(index)
 	local bin, sz = core.loadproto(index)
-	return sproto.new(bin,sz)
+	--  no __gc in metatable
+	return sproto.new(bin,sz, true)
 end
 
 return loader

lualib/sprotoparser.lua

@@ -1,6 +1,40 @@
 local lpeg = require "lpeg"
 local table = require "table"
 
+local packbytes
+local packvalue
+
+if _VERSION == "Lua 5.3" then
+	function packbytes(str)
+		return string.pack("<s4",str)
+	end
+
+	function packvalue(id)
+		id = (id + 1) * 2
+		return string.pack("<I2",id)
+	end
+else
+	function packbytes(str)
+		local size = #str
+		local a = size % 256
+		size = math.floor(size / 256)
+		local b = size % 256
+		size = math.floor(size / 256)
+		local c = size % 256
+		size = math.floor(size / 256)
+		local d = size
+		return string.char(a)..string.char(b)..string.char(c)..string.char(d) .. str
+	end
+
+	function packvalue(id)
+		id = (id + 1) * 2
+		assert(id >=0 and id < 65536)
+		local a = id % 256
+		local b = math.floor(id / 256)
+		return string.char(a) .. string.char(b)
+	end
+end
+
 local P = lpeg.P
 local S = lpeg.S
 local R = lpeg.R
@@ -35,6 +69,7 @@ local word = alpha * alnum ^ 0
 local name = C(word)
 local typename = C(word * ("." * word) ^ 0)
 local tag = R"09" ^ 1 / tonumber
+local mainkey = "(" * blank0 * name * blank0 * ")"
 
 local function multipat(pat)
 	return Ct(blank0 * (pat * blanks) ^ 0 * pat^0 * blank0)
@@ -46,10 +81,10 @@ end
 
 local typedef = P {
 	"ALL",
-	FIELD = namedpat("field", (name * blanks * tag * blank0 * ":" * blank0 * (C"*")^0 * typename)),
+	FIELD = namedpat("field", (name * blanks * tag * blank0 * ":" * blank0 * (C"*")^0 * typename * mainkey^0)),
 	STRUCT = P"{" * multipat(V"FIELD" + V"TYPE") * P"}",
 	TYPE = namedpat("type", P"." * name * blank0 * V"STRUCT" ),
-	SUBPROTO = Ct((C"request" + C"response") * blanks * (name + V"STRUCT")),
+	SUBPROTO = Ct((C"request" + C"response") * blanks * (typename + V"STRUCT")),
 	PROTOCOL = namedpat("protocol", name * blanks * tag * blank0 * P"{" * multipat(V"SUBPROTO") * P"}"),
 	ALL = multipat(V"TYPE" + V"PROTOCOL"),
 }
@@ -97,6 +132,11 @@ function convert.type(all, obj)
 				field.array = true
 				fieldtype = f[4]
 			end
+			local mainkey = f[5]
+			if mainkey then
+				assert(field.array)
+				field.key = mainkey
+			end
 			field.typename = fieldtype
 		else
 			assert(f.type == "type")	-- nest type
@@ -146,6 +186,32 @@ local function checktype(types, ptype, t)
 	end
 end
 
+local function check_protocol(r)
+	local map = {}
+	local type = r.type
+	for name, v in pairs(r.protocol) do
+		local tag = v.tag
+		local request = v.request
+		local response = v.response
+		local p = map[tag]
+		
+		if p then
+			error(string.format("redefined protocol tag %d at %s", tag, name))
+		end
+
+		if request and not type[request] then
+			error(string.format("Undefined request type %s in protocol %s", request, name))
+		end
+
+		if response and not type[response] then
+			error(string.format("Undefined response type %s in protocol %s", response, name))
+		end
+
+		map[tag] = v
+	end
+	return r
+end
+
 local function flattypename(r)
 	for typename, t in pairs(r.type) do
 		for _, f in pairs(t) do
@@ -164,7 +230,7 @@ end
 local function parser(text,filename)
 	local state = { file = filename, pos = 0, line = 1 }
 	local r = lpeg.match(proto * -1 + exception , text , 1, state )
-	return flattypename(adjust(r))
+	return flattypename(check_protocol(adjust(r)))
 end
 
 --[[
@@ -176,6 +242,7 @@ end
 		type 2 : integer
 		tag	3 :	integer
 		array 4	: boolean
+		key 5 : integer # If key exists, array must be true, and it's a map.
 	}
 	name 0 : string
 	fields 1 : *field
@@ -194,25 +261,18 @@ end
 }
 ]]
 
-local function packbytes(str)
-	str = string.pack("<s4",str)
-	return str
-end
-
-local function packvalue(id)
-	id = (id + 1) * 2
-	local str = string.pack("<I2", id)
-	return str
-end
-
 local function packfield(f)
 	local strtbl = {}
 	if f.array then
-		table.insert(strtbl, "\5\0")  -- 5 fields
+		if f.key then
+			table.insert(strtbl, "\6\0")  -- 6 fields
+		else
+			table.insert(strtbl, "\5\0")  -- 5 fields
+		end
 	else
 		table.insert(strtbl, "\4\0")	-- 4 fields
 	end
-	table.insert(strtbl, "\0\0")	-- name	(tag = 0, ref =0)
+	table.insert(strtbl, "\0\0")	-- name	(tag = 0, ref an object)
 	if f.buildin then
 		table.insert(strtbl, packvalue(f.buildin))	-- buildin (tag = 1)
 		table.insert(strtbl, "\1\0")	-- skip (tag = 2)
@@ -225,7 +285,10 @@ local function packfield(f)
 	if f.array then
 		table.insert(strtbl, packvalue(1))	-- array = true (tag = 4)
 	end
-	table.insert(strtbl, packbytes(f.name))
+	if f.key then
+		table.insert(strtbl, packvalue(f.key)) -- key tag (tag = 5)
+	end
+	table.insert(strtbl, packbytes(f.name)) -- external object (name)
 	return packbytes(table.concat(strtbl))
 end
 
@@ -238,11 +301,22 @@ local function packtype(name, t, alltypes)
 		tmp.tag = f.tag
 
 		tmp.buildin = buildin_types[f.typename]
+		local subtype
 		if not tmp.buildin then
-			tmp.type = assert(alltypes[f.typename])
+			subtype = assert(alltypes[f.typename])
+			tmp.type = subtype.id
 		else
 			tmp.type = nil
 		end
+		if f.key then
+			tmp.key = subtype.fields[f.key]
+			if not tmp.key then
+				error("Invalid map index :" .. f.key)
+			end
+		else
+			tmp.key = nil
+		end
+
 		table.insert(fields, packfield(tmp))
 	end
 	local data
@@ -274,6 +348,7 @@ local function packproto(name, p, alltypes)
 		if request == nil then
 			error(string.format("Protocol %s request type %s not found", name, p.request))
 		end
+		request = request.id
 	end
 	local tmp = {
 		"\4\0",	-- 4 fields
@@ -284,12 +359,12 @@ local function packproto(name, p, alltypes)
 		tmp[1] = "\2\0"
 	else
 		if p.request then
-			table.insert(tmp, packvalue(alltypes[p.request])) -- request typename (tag=2)
+			table.insert(tmp, packvalue(alltypes[p.request].id)) -- request typename (tag=2)
 		else
 			table.insert(tmp, "\1\0")
 		end
 		if p.response then
-			table.insert(tmp, packvalue(alltypes[p.response])) -- request typename (tag=3)
+			table.insert(tmp, packvalue(alltypes[p.response].id)) -- request typename (tag=3)
 		else
 			tmp[1] = "\3\0"
 		end
@@ -312,7 +387,13 @@ local function packgroup(t,p)
 	end
 	table.sort(alltypes)	-- make result stable
 	for idx, name in ipairs(alltypes) do
-		alltypes[name] = idx - 1
+		local fields = {}
+		for _, type_fields in ipairs(t[name]) do
+			if buildin_types[type_fields.typename] then
+				fields[type_fields.name] = type_fields.tag
+			end
+		end
+		alltypes[name] = { id = idx - 1, fields = fields }
 	end
 	tt = {}
 	for _,name in ipairs(alltypes) do

service-src/service_snlua.c

@@ -156,3 +156,12 @@ snlua_release(struct snlua *l) {
 	lua_close(l->L);
 	skynet_free(l);
 }
+
+void
+snlua_signal(struct snlua *l, int signal) {
+	skynet_error(l->ctx, "recv a signal %d", signal);
+#ifdef lua_checksig
+	// If our lua support signal (modified lua version by skynet), trigger it.
+	skynet_sig_L = l->L;
+#endif
+}

service/debug_console.lua

@@ -50,8 +50,11 @@ end
 
 local function docmd(cmdline, print, fd)
 	local split = split_cmdline(cmdline)
-	table.insert(split, fd)
-	local cmd = COMMAND[split[1]]
+	local command = split[1]
+	if command == "debug" then
+		table.insert(split, fd)
+	end
+	local cmd = COMMAND[command]
 	local ok, list
 	if cmd then
 		ok, list = pcall(cmd, select(2,table.unpack(split)))
@@ -126,6 +129,7 @@ function COMMAND.help()
 		logoff = "logoff address",
 		log = "launch a new lua service with log",
 		debug = "debug address : debug a lua service",
+		signal = "signal address sig",
 	}
 end
 
@@ -244,3 +248,12 @@ function COMMAND.logoff(address)
 	address = adjust_address(address)
 	core.command("LOGOFF", skynet.address(address))
 end
+
+function COMMAND.signal(address, sig)
+	address = skynet.address(adjust_address(address))
+	if sig then
+		core.command("SIGNAL", string.format("%s %d",address,sig))
+	else
+		core.command("SIGNAL", address)
+	end
+end

skynet-src/skynet_module.c

@@ -75,7 +75,7 @@ _query(const char * name) {
 static int
 _open_sym(struct skynet_module *mod) {
 	size_t name_size = strlen(mod->name);
-	char tmp[name_size + 9]; // create/init/release , longest name is release (7)
+	char tmp[name_size + 9]; // create/init/release/signal , longest name is release (7)
 	memcpy(tmp, mod->name, name_size);
 	strcpy(tmp+name_size, "_create");
 	mod->create = dlsym(mod->module, tmp);
@@ -83,6 +83,8 @@ _open_sym(struct skynet_module *mod) {
 	mod->init = dlsym(mod->module, tmp);
 	strcpy(tmp+name_size, "_release");
 	mod->release = dlsym(mod->module, tmp);
+	strcpy(tmp+name_size, "_signal");
+	mod->signal = dlsym(mod->module, tmp);
 
 	return mod->init == NULL;
 }
@@ -150,6 +152,13 @@ skynet_module_instance_release(struct skynet_module *m, void *inst) {
 	}
 }
 
+void
+skynet_module_instance_signal(struct skynet_module *m, void *inst, int signal) {
+	if (m->signal) {
+		m->signal(inst, signal);
+	}
+}
+
 void 
 skynet_module_init(const char *path) {
 	struct modules *m = skynet_malloc(sizeof(*m));

skynet-src/skynet_module.h

@@ -6,6 +6,7 @@ struct skynet_context;
 typedef void * (*skynet_dl_create)(void);
 typedef int (*skynet_dl_init)(void * inst, struct skynet_context *, const char * parm);
 typedef void (*skynet_dl_release)(void * inst);
+typedef void (*skynet_dl_signal)(void * inst, int signal);
 
 struct skynet_module {
 	const char * name;
@@ -13,6 +14,7 @@ struct skynet_module {
 	skynet_dl_create create;
 	skynet_dl_init init;
 	skynet_dl_release release;
+	skynet_dl_signal signal;
 };
 
 void skynet_module_insert(struct skynet_module *mod);
@@ -20,6 +22,7 @@ struct skynet_module * skynet_module_query(const char * name);
 void * skynet_module_instance_create(struct skynet_module *);
 int skynet_module_instance_init(struct skynet_module *, void * inst, struct skynet_context *ctx, const char * parm);
 void skynet_module_instance_release(struct skynet_module *, void *inst);
+void skynet_module_instance_signal(struct skynet_module *, void *inst, int signal);
 
 void skynet_module_init(const char *path);
 

skynet-src/skynet_server.c

@@ -589,6 +589,26 @@ cmd_logoff(struct skynet_context * context, const char * param) {
 	return NULL;
 }
 
+static const char *
+cmd_signal(struct skynet_context * context, const char * param) {
+	uint32_t handle = tohandle(context, param);
+	if (handle == 0)
+		return NULL;
+	struct skynet_context * ctx = skynet_handle_grab(handle);
+	if (ctx == NULL)
+		return NULL;
+	param = strchr(param, ' ');
+	int sig = 0;
+	if (param) {
+		sig = strtol(param, NULL, 0);
+	}
+	// NOTICE: the signal function should be thread safe.
+	skynet_module_instance_signal(ctx->mod, ctx->instance, sig);
+
+	skynet_context_release(ctx);
+	return NULL;
+}
+
 static struct command_func cmd_funcs[] = {
 	{ "TIMEOUT", cmd_timeout },
 	{ "REG", cmd_reg },
@@ -607,6 +627,7 @@ static struct command_func cmd_funcs[] = {
 	{ "MQLEN", cmd_mqlen },
 	{ "LOGON", cmd_logon },
 	{ "LOGOFF", cmd_logoff },
+	{ "SIGNAL", cmd_signal },
 	{ NULL, NULL },
 };
 

test/testdns.lua

@@ -0,0 +1,11 @@
+local skynet = require "skynet"
+local dns = require "dns"
+
+skynet.start(function()
+	print("nameserver:", dns.server())	-- set nameserver
+	-- you can specify the server like dns.server("8.8.4.4", 53)
+	local ip, ips = dns.resolve "github.com"
+	for k,v in ipairs(ips) do
+		print("github.com",v)
+	end
+end)

test/testhttp.lua

@@ -1,16 +1,24 @@
 local skynet = require "skynet"
 local httpc = require "http.httpc"
+local dns = require "dns"
 
 skynet.start(function()
 	print("GET baidu.com")
-	local header = {}
-	local status, body = httpc.get("baidu.com", "/", header)
+	local respheader = {}
+	local status, body = httpc.get("baidu.com", "/", respheader)
 	print("[header] =====>")
-	for k,v in pairs(header) do
+	for k,v in pairs(respheader) do
 		print(k,v)
 	end
 	print("[body] =====>", status)
 	print(body)
 
+	local respheader = {}
+	dns.server()
+	local ip = dns.resolve "baidu.com"
+	print(string.format("GET %s (baidu.com)", ip))
+	local status, body = httpc.get("baidu.com", "/", respheader, { host = "baidu.com" })
+	print(status)
+
 	skynet.exit()
 end)