release alpha 4

fix: httpc.post

3rd/lua/lstrlib.c

@@ -798,7 +798,8 @@ static int str_gsub (lua_State *L) {
 */
 
 /* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */
-#define MAX_ITEM	512
+#define MAX_ITEM  \
+  (sizeof(lua_Number) <= 4 ? 150 : sizeof(lua_Number) <= 8 ? 450 : 5050)
 
 /* valid flags in a format specification */
 #define FLAGS	"-+ #0"

HISTORY.md

@@ -1,3 +1,9 @@
+v1.0.0-alpha4 (2015-4-13)
+-----------
+* sproto can share c struct between states
+* udp api changed (use lua string now)
+* fix memory leak in dns module
+
 v1.0.0-alpha3 (2015-3-30)
 -----------
 * Update sproto (bugfix)

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2012-2014 codingnow.com
+Copyright (c) 2012-2015 codingnow.com
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

lualib-src/sproto/lsproto.c

@@ -48,15 +48,9 @@ LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
 
 static int
 lnewproto(lua_State *L) {
-	size_t sz = 0;
-	void * buffer;
 	struct sproto * sp;
-	if (lua_isuserdata(L,1)) {
-		buffer = lua_touserdata(L,1);
-		sz = luaL_checkinteger(L,2);
-	} else {
-		buffer = (void *)luaL_checklstring(L,1,&sz);
-	}
+	size_t sz;
+	void * buffer = (void *)luaL_checklstring(L,1,&sz);
 	sp = sproto_create(buffer, sz);
 	if (sp) {
 		lua_pushlightuserdata(L, sp);
@@ -199,7 +193,7 @@ encode(const struct sproto_arg *args) {
 			return -1;
 		memcpy(args->value, str, sz);
 		lua_pop(L,1);
-		return sz;
+		return sz + 1;	// The length of empty string is 1.
 	}
 	case SPROTO_TSTRUCT: {
 		struct encode_ud sub;
@@ -545,48 +539,38 @@ lprotocol(lua_State *L) {
 	return 3;
 }
 
-/* global sproto pointer for multi states */
-struct sproto_bin {
-	void *ptr;
-	size_t sz;
-};
-
-static struct sproto_bin G_sproto[MAX_GLOBALSPROTO];
+/* global sproto pointer for multi states
+   NOTICE : It is not thread safe
+ */
+static struct sproto * G_sproto[MAX_GLOBALSPROTO];
 
 static int
 lsaveproto(lua_State *L) {
-	size_t sz;
-	void * buffer = (void *)luaL_checklstring(L,1,&sz);
+	struct sproto * sp = lua_touserdata(L, 1);
 	int index = luaL_optinteger(L, 2, 0);
-	void * tmp;
-	struct sproto_bin * sbin = &G_sproto[index];
 	if (index < 0 || index >= MAX_GLOBALSPROTO) {
 		return luaL_error(L, "Invalid global slot index %d", index);
 	}
-	tmp = malloc(sz);
-	memcpy(tmp, buffer, sz);
-	if (sbin->ptr) {
-		free(sbin->ptr);
-	}
-	sbin->ptr = tmp;
-	sbin->sz = sz;
+	/* TODO : release old object (memory leak now, but thread safe)*/
+	G_sproto[index] = sp;
 	return 0;
 }
 
 static int
 lloadproto(lua_State *L) {
 	int index = luaL_optinteger(L, 1, 0);
-	struct sproto_bin * sbin = &G_sproto[index];
+	struct sproto * sp;
 	if (index < 0 || index >= MAX_GLOBALSPROTO) {
 		return luaL_error(L, "Invalid global slot index %d", index);
 	}
-	if (sbin->ptr == NULL) {
+	sp = G_sproto[index];
+	if (sp == NULL) {
 		return luaL_error(L, "nil sproto at index %d", index);
 	}
 
-	lua_pushlightuserdata(L, sbin->ptr);
-	lua_pushinteger(L, sbin->sz);
-	return 2;
+	lua_pushlightuserdata(L, sp);
+
+	return 1;
 }
 
 int

lualib-src/sproto/sproto.c

@@ -510,7 +510,7 @@ sproto_dump(struct sproto *s) {
 
 // query
 int
-sproto_prototag(struct sproto *sp, const char * name) {
+sproto_prototag(const struct sproto *sp, const char * name) {
 	int i;
 	for (i=0;i<sp->protocol_n;i++) {
 		if (strcmp(name, sp->proto[i].name) == 0) {
@@ -521,7 +521,7 @@ sproto_prototag(struct sproto *sp, const char * name) {
 }
 
 static struct protocol *
-query_proto(struct sproto *sp, int tag) {
+query_proto(const struct sproto *sp, int tag) {
 	int begin = 0, end = sp->protocol_n;
 	while(begin<end) {
 		int mid = (begin+end)/2;
@@ -539,7 +539,7 @@ query_proto(struct sproto *sp, int tag) {
 }
 
 struct sproto_type *
-sproto_protoquery(struct sproto *sp, int proto, int what) {
+sproto_protoquery(const struct sproto *sp, int proto, int what) {
 	struct protocol * p;
 	if (what <0 || what >1) {
 		return NULL;
@@ -552,7 +552,7 @@ sproto_protoquery(struct sproto *sp, int proto, int what) {
 }
 
 const char *
-sproto_protoname(struct sproto *sp, int proto) {
+sproto_protoname(const struct sproto *sp, int proto) {
 	struct protocol * p = query_proto(sp, proto);
 	if (p) {
 		return p->name;
@@ -561,7 +561,7 @@ sproto_protoname(struct sproto *sp, int proto) {
 }
 
 struct sproto_type *
-sproto_type(struct sproto *sp, const char * type_name) {
+sproto_type(const struct sproto *sp, const char * type_name) {
 	int i;
 	for (i=0;i<sp->type_n;i++) {
 		if (strcmp(type_name, sp->type[i].name) == 0) {
@@ -577,7 +577,7 @@ sproto_name(struct sproto_type * st) {
 }
 
 static struct field *
-findtag(struct sproto_type *st, int tag) {
+findtag(const struct sproto_type *st, int tag) {
 	int begin, end;
 	if (st->base >=0 ) {
 		tag -= st->base;
@@ -609,10 +609,6 @@ findtag(struct sproto_type *st, int tag) {
 
 static inline int
 fill_size(uint8_t * data, int sz) {
-	if (sz < 0)
-		return -1;
-	if (sz == 0)
-		return 0;
 	data[0] = sz & 0xff;
 	data[1] = (sz >> 8) & 0xff;
 	data[2] = (sz >> 16) & 0xff;
@@ -677,6 +673,11 @@ encode_object(sproto_callback cb, struct sproto_arg *args, uint8_t *data, int si
 	args->value = data+SIZEOF_LENGTH;
 	args->length = size-SIZEOF_LENGTH;
 	sz = cb(args);
+	if (sz <= 0)
+		return sz;
+	if (args->type == SPROTO_TSTRING) {
+		--sz;	// the length of null string is 1
+	}
 	return fill_size(data, sz);
 }
 
@@ -718,7 +719,7 @@ encode_integer_array(sproto_callback cb, struct sproto_arg *args, uint8_t *buffe
 		sz = cb(args);
 		if (sz < 0)
 			return NULL;
-		if (sz == 0)
+		if (sz == 0)	// nil object, end of array
 			break;
 		if (size < sizeof(uint64_t))
 			return NULL;
@@ -798,7 +799,7 @@ encode_array(sproto_callback cb, struct sproto_arg *args, uint8_t *data, int siz
 			sz = cb(args);
 			if (sz < 0)
 				return -1;
-			if (sz == 0)
+			if (sz == 0)	// nil object , end of array
 				break;
 			if (size < 1)
 				return -1;
@@ -817,10 +818,13 @@ encode_array(sproto_callback cb, struct sproto_arg *args, uint8_t *data, int siz
 			args->value = buffer+SIZEOF_LENGTH;
 			args->length = size;
 			sz = cb(args);
-			if (sz < 0)
-				return -1;
 			if (sz == 0)
 				break;
+			if (sz < 0)
+				return -1;
+			if (args->type == SPROTO_TSTRING) {
+				--sz;
+			}
 			fill_size(buffer, sz);
 			buffer += SIZEOF_LENGTH+sz;
 			size -=sz;
@@ -829,13 +833,13 @@ encode_array(sproto_callback cb, struct sproto_arg *args, uint8_t *data, int siz
 		break;
 	}
 	sz = buffer - (data + SIZEOF_LENGTH);
-	if (sz == 0)
+	if (sz == 0)	// empty array
 		return 0;
 	return fill_size(data, sz);
 }
 
 int
-sproto_encode(struct sproto_type *st, void * buffer, int size, sproto_callback cb, void *ud) {
+sproto_encode(const struct sproto_type *st, void * buffer, int size, sproto_callback cb, void *ud) {
 	struct sproto_arg args;
 	uint8_t * header = buffer;
 	uint8_t * data;
@@ -878,7 +882,7 @@ sproto_encode(struct sproto_type *st, void * buffer, int size, sproto_callback c
 				sz = cb(&args);
 				if (sz < 0)
 					return -1;
-				if (sz == 0)
+				if (sz == 0)	// nil object
 					continue;
 				if (sz == sizeof(uint32_t)) {
 					if (u.u32 < 0x7fff) {
@@ -895,11 +899,10 @@ sproto_encode(struct sproto_type *st, void * buffer, int size, sproto_callback c
 				break;
 			}
 			case SPROTO_TSTRUCT:
-			case SPROTO_TSTRING: {
+			case SPROTO_TSTRING:
 				sz = encode_object(cb, &args, data, size);
 				break;
 			}
-			}
 		}
 		if (sz < 0)
 			return -1;
@@ -1032,7 +1035,7 @@ decode_array(sproto_callback cb, struct sproto_arg *args, uint8_t * stream) {
 }
 
 int
-sproto_decode(struct sproto_type *st, const void * data, int size, sproto_callback cb, void *ud) {
+sproto_decode(const struct sproto_type *st, const void * data, int size, sproto_callback cb, void *ud) {
 	struct sproto_arg args;
 	int total = size;
 	uint8_t * stream;

lualib-src/sproto/sproto.h

@@ -17,12 +17,12 @@ struct sproto_type;
 struct sproto * sproto_create(const void * proto, size_t sz);
 void sproto_release(struct sproto *);
 
-int sproto_prototag(struct sproto *, const char * name);
-const char * sproto_protoname(struct sproto *, int proto);
+int sproto_prototag(const struct sproto *, const char * name);
+const char * sproto_protoname(const struct sproto *, int proto);
 // SPROTO_REQUEST(0) : request, SPROTO_RESPONSE(1): response
-struct sproto_type * sproto_protoquery(struct sproto *, int proto, int what);
+struct sproto_type * sproto_protoquery(const struct sproto *, int proto, int what);
 
-struct sproto_type * sproto_type(struct sproto *, const char * type_name);
+struct sproto_type * sproto_type(const 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);
@@ -41,8 +41,8 @@ struct sproto_arg {
 
 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);
+int sproto_decode(const struct sproto_type *, const void * data, int size, sproto_callback cb, void *ud);
+int sproto_encode(const struct sproto_type *, void * buffer, int size, sproto_callback cb, void *ud);
 
 // for debug use
 void sproto_dump(struct sproto *);

lualib/dns.lua

@@ -249,8 +249,8 @@ function dns.server(server, port)
 		end
 		assert(server, "Can't get nameserver")
 	end
-	dns_server = socket.udp(function(data, sz, from)
-		resolve(skynet.tostring(data,sz))
+	dns_server = socket.udp(function(str, from)
+		resolve(str)
 	end)
 	socket.udp_connect(dns_server, server, port or 53)
 	return server

lualib/http/httpc.lua

@@ -16,6 +16,8 @@ local function request(fd, method, host, url, recvheader, header, content)
 		end
 		if header.host then
 			host = ""
+		else
+			host = string.format("host:%s\r\n", host)
 		end
 	else
 		host = string.format("host:%s\r\n",host)

lualib/sharemap.lua

@@ -30,12 +30,14 @@ function sharemap.writer(typename, obj)
 	local sp = loadsp()
 	obj = obj or {}
 	local stmobj = stm.new(sp:encode(typename,obj))
-	obj.__typename = typename
-	obj.__obj = stmobj
-	obj.__data = obj
-	obj.commit = sharemap.commit
-	obj.copy = sharemap.copy
-	return setmetatable(obj, { __index = obj.__data, __newindex = obj.__data })
+	local ret = {
+		__typename = typename,
+		__obj = stmobj,
+		__data = obj,
+		commit = sharemap.commit,
+		copy = sharemap.copy,
+	}
+	return setmetatable(ret, { __index = obj, __newindex = obj })
 end
 
 local function decode(msg, sz, self)
@@ -63,7 +65,7 @@ function sharemap.reader(typename, stmcpy)
 		__data = data,
 		update = sharemap.update,
 	}
-	return setmetatable(obj, { __index = obj.__data, __newindex = error })
+	return setmetatable(obj, { __index = data, __newindex = error })
 end
 
 return sharemap

lualib/skynet.lua

@@ -398,6 +398,7 @@ skynet.pack = assert(c.pack)
 skynet.packstring = assert(c.packstring)
 skynet.unpack = assert(c.unpack)
 skynet.tostring = assert(c.tostring)
+skynet.trash = assert(c.trash)
 
 local function yield_call(service, session)
 	watching_session[session] = service

lualib/socket.lua

@@ -1,5 +1,6 @@
 local driver = require "socketdriver"
 local skynet = require "skynet"
+local skynet_core = require "skynet.core"
 local assert = assert
 
 local socket = {}	-- api
@@ -127,7 +128,9 @@ socket_message[6] = function(id, size, data, address)
 		driver.drop(data, size)
 		return
 	end
-	s.callback(data, size, address)
+	local str = skynet.tostring(data, size)
+	skynet_core.trash(data, size)
+	s.callback(str, address)
 end
 
 skynet.register_protocol {

lualib/sproto.lua

@@ -13,14 +13,23 @@ function sproto_mt:__gc()
 	core.deleteproto(self.__cobj)
 end
 
-function sproto.new(bin,sz,nogc)
-	local cobj = assert(core.newproto(bin,sz))
+function sproto.new(bin)
+	local cobj = assert(core.newproto(bin))
 	local self = {
 		__cobj = cobj,
 		__tcache = setmetatable( {} , weak_mt ),
 		__pcache = setmetatable( {} , weak_mt ),
 	}
-	return setmetatable(self, nogc and sproto_nogc or sproto_mt)
+	return setmetatable(self, sproto_mt)
+end
+
+function sproto.sharenew(cobj)
+	local self = {
+		__cobj = cobj,
+		__tcache = setmetatable( {} , weak_mt ),
+		__pcache = setmetatable( {} , weak_mt ),
+	}
+	return setmetatable(self, sproto_nogc)
 end
 
 function sproto.parse(ptext)

lualib/sprotoloader.lua

@@ -8,16 +8,19 @@ function loader.register(filename, index)
 	local f = assert(io.open(filename), "Can't open sproto file")
 	local data = f:read "a"
 	f:close()
-	local bin = parser.parse(data)
-	core.saveproto(bin, index)
+	local sp = core.newproto(parser.parse(data))
+	core.saveproto(sp, index)
 end
 
-loader.save = core.saveproto
+function loader.save(bin, index)
+	local sp = core.newproto(bin)
+	core.saveproto(sp, index)
+end
 
 function loader.load(index)
-	local bin, sz = core.loadproto(index)
+	local sp = core.loadproto(index)
 	--  no __gc in metatable
-	return sproto.new(bin,sz, true)
+	return sproto.sharenew(sp)
 end
 
 return loader

skynet-src/malloc_hook.h

@@ -1,5 +1,5 @@
-#ifndef __MALLOC_HOOK_H
-#define __MALLOC_HOOK_H
+#ifndef SKYNET_MALLOC_HOOK_H
+#define SKYNET_MALLOC_HOOK_H
 
 #include <stdlib.h>
 
@@ -10,5 +10,5 @@ extern size_t mallctl_int64(const char* name, size_t* newval);
 extern int    mallctl_opt(const char* name, int* newval);
 extern void   dump_c_mem(void);
 
-#endif /* __MALLOC_HOOK_H */
+#endif /* SKYNET_MALLOC_HOOK_H */
 

skynet-src/rwlock.h

@@ -1,5 +1,5 @@
-#ifndef _RWLOCK_H_
-#define _RWLOCK_H_
+#ifndef SKYNET_RWLOCK_H
+#define SKYNET_RWLOCK_H
 
 struct rwlock {
 	int write;

test/testudp.lua

@@ -3,16 +3,15 @@ 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
+	host = socket.udp(function(str, from)
 		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))
+	local c = socket.udp(function(str, from)
+		print("client recv", str, socket.udp_address(from))
 	end)
 	socket.udp_connect(c, "127.0.0.1", 8765)
 	for i=1,20 do