diff --git a/3rd/lua-mysqlaux/lua_mysqlaux.c b/3rd/lua-mysqlaux/lua_mysqlaux.c deleted file mode 100755 index ba170ddb2..000000000 --- a/3rd/lua-mysqlaux/lua_mysqlaux.c +++ /dev/null @@ -1,372 +0,0 @@ -// -// lua_mysqlaux.c -// -// Created by changfeng on 6/17/14. -// Copyright (c) 2014 changfeng. All rights reserved. -// -#include -#include -#include - -#include -#include - -#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; -} - diff --git a/3rd/lua/lgc.c b/3rd/lua/lgc.c index c0f2858cd..51c11f5b9 100644 --- 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 */ diff --git a/Makefile b/Makefile index ec52fcd39..0d0cd8559 100644 --- a/Makefile +++ b/Makefile @@ -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 : diff --git a/examples/simpleweb.lua b/examples/simpleweb.lua index 234c2d08f..5d38dfb1b 100644 --- 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) diff --git a/lualib-src/lua-netpack.c b/lualib-src/lua-netpack.c index 1e2ad6328..e424f90cf 100644 --- a/lualib-src/lua-netpack.c +++ b/lualib-src/lua-netpack.c @@ -317,9 +317,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 +365,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 diff --git a/lualib-src/lua_mysqlaux.c b/lualib-src/lua_mysqlaux.c new file mode 100755 index 000000000..31fabad83 --- /dev/null +++ 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 +#include +#include + +#include +#include + +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; +} + diff --git a/lualib-src/sproto/lsproto.c b/lualib-src/sproto/lsproto.c index 602f86e91..af86e389f 100644 --- 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 { @@ -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)); @@ -188,6 +193,7 @@ expand_buffer(lua_State *L, int osz, int nsz) { */ 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; @@ -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 { diff --git a/lualib-src/sproto/sproto.c b/lualib-src/sproto/sproto.c index ca43cd9b5..24d364922 100644 --- 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;iname = 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;in = n; t->f = pool_alloc(&s->memory, sizeof(struct field) * n); for (i=0;if[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;iname = 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;itype_n); - int i,j; for (i=0;itype_n;i++) { struct sproto_type *t = &s->type[i]; printf("%s\n", t->name); for (j=0;jn;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(ttype & ~SPROTO_TARRAY; + if (t == SPROTO_TSTRUCT) { + type_name = f->st->name; + } else { + assert(tname, 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); @@ -518,10 +531,11 @@ query_proto(struct sproto *sp, int tag) { 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]; } @@ -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,7 +800,7 @@ 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); @@ -783,13 +811,16 @@ sproto_encode(struct sproto_type *st, void * buffer, int size, sproto_callback c 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;in;i++) { struct field *f = &st->f[i]; int type = f->type; @@ -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)) { @@ -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 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 diff --git a/lualib/mysql.lua b/lualib/mysql.lua index b81e2ecca..58843e68a 100755 --- 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 diff --git a/service-src/service_harbor.c b/service-src/service_harbor.c index 3fd834b47..b78953d19 100644 --- 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); } } diff --git a/skynet-src/skynet_server.c b/skynet-src/skynet_server.c index 0a3a6b00f..a1961f131 100644 --- 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); diff --git a/skynet-src/skynet_socket.c b/skynet-src/skynet_socket.c index 573b9f0ee..38ba4ea96 100644 --- 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); } }