void wsframe_free(wsFrame * frame) {
if (NULL != frame && frame->len > 0) {
automem_t mem;
mem.pdata = frame->pdata;
mem.buffersize = mem.size = frame->len;
automem_uninit(&mem);
}
free(frame);
}
/* 对模板文件进行编译.*/
int _lua_tpl_compile(lua_State * L)
{
int cache = 0,lbuf = 0;
unsigned int _var_size = 0;
size_t lfile;
const char *cfile = NULL,
* file= luaL_checklstring(L, 1,&lfile),
* buf = NULL;
#if defined(_WIN32) || defined(_WIN64)
automem_t mem= {NULL};
#else
automem_t mem= {
.size = 0,
.pdata = NULL
};
#endif
if(lua_isboolean(L, 2))
cache =lua_toboolean(L, 2);
if(0 != cache) {
struct stat st1,st2;
cfile=(char *)malloc(lfile+5);
memcpy((char *)cfile,file,lfile);
strcpy((char *)cfile+lfile,".tpl");
if((0 == stat(file,&st1)) && (0 == stat(cfile, &st2)))
{
if(st1.st_mtime <= st2.st_mtime) {
read_from_cached(L, &mem, cfile);
free((void*)cfile);
lua_pushlstring(L, mem.pdata, mem.size);
goto lua_tpl_compile_final;
}
}
}
if(NULL != (buf = file_get_contents(file, &lbuf)))
{
lua_tpl_expand_variables(L, &mem, lbuf);
_var_size = mem.size;
lua_tpl_compile_local(L, &mem, buf, lbuf);
free((void*)buf);
lua_pushlstring(L,(char *)mem.pdata,mem.size);
}
if(0 != cache && mem.pdata != NULL)
file_put_contents(cfile, mem.pdata + _var_size, mem.size - _var_size);
if(NULL != cfile)
free((void *)cfile);
lua_tpl_compile_final:
automem_uninit(&mem);
return 1;
}
static int getBodyParams(lua_State * L, char * s) {
automem_t mem;
automem_init(&mem, 128);
lua_newtable(L);
do {
lua_url_decode(L, s++, &mem);
s = strchr(s, '&');
} while (s);
automem_uninit(&mem);
return 1;
}
static void _cb_after_send_mem(uv_write_t * w, int status)
{
MELO_ASSERT(NULL != w, "w is NULL");
MELO_ASSERT(OK == status, "_cb_after_send_mem failed");
//see uxv_send_mem()
automem_t mem;
mem.pdata = (unsigned char*)w->data;
automem_uninit(&mem);
free(w);
}
static void after_queue_work(uv_work_t* req, int status)
{
automem_t mem;
webqueuework_t * qwork = container_of(req, webqueuework_t, work);
rbnode_t * n = rb_first(&qwork->request->headers);
automem_init(&mem, 256);
if (qwork->conn->proto == WEB_PROTO_HTTP) {
if (qwork->status == 101 && qwork->request->upgrade) {
webheader_t k;
rbnode_t * n;
const char * ver = NULL, *key = NULL;
k.key = "Sec-WebSocket-Version";
if (n = rb_find(&qwork->request->headers, &k.n)) ver = container_of(n, webheader_t, n)->val;
k.key = "Sec-WebSocket-Key";
if (n = rb_find(&qwork->request->headers, &k.n)) key = container_of(n, webheader_t, n)->val;
if (NULL != key && NULL != ver) {
ws_do_handeshake(&mem, key, strlen(key));
qwork->conn->proto = WEB_PROTO_WEBSOCKET;
if (uv_is_active((uv_handle_t *)&qwork->conn->conn)) {
wsparser_init(&qwork->conn->ws_parser, 13, 20480);
qwork->conn->request = webrequest_get(qwork->request);//引用起来,不丢掉.
}
goto contents_prepare_final;
}
}
rbnode_t * n = rb_first(&qwork->headers);
automem_init_headers(&mem, qwork->status, qwork->flags);
while (n) {
webheader_t * h = container_of(n, webheader_t, n);
automem_append_voidp(&mem, h->key, strlen(h->key));
automem_append_voidp(&mem, ": ", 2);
automem_append_voidp(&mem, h->val, strlen(h->val));
automem_append_voidp(&mem, "\r\n", 2);
n = rb_next(n);
}
automem_append_contents(&mem, qwork->mem.pdata, qwork->mem.size);
}
else if(qwork->conn->proto==WEB_PROTO_WEBSOCKET) {
wsframe_make(&mem, WS_TEXT_FRAME, 0, qwork->mem.pdata, qwork->mem.size);
}
contents_prepare_final:
if (0 != webconn_sendmem(qwork->conn, &mem)) {
automem_uninit(&mem);
}
webqueuework_free(qwork);
}
int automem_erase_ex(automem_t* pmem, unsigned int size,unsigned int limit)
{
if(size < pmem->size)
{
unsigned int newsize = pmem->size - size;
if(pmem->buffersize > (newsize + limit))
{
#if defined(_WIN32) || defined(_WIN64)
char * buffer = (char*) HeapAlloc(GetProcessHeap(), 0, newsize + limit);
memcpy(buffer, pmem->pdata + size, newsize);
HeapFree(GetProcessHeap(),0,pmem->pdata);
#else
char * buffer = (unsigned char*) malloc(newsize + limit);
memcpy(buffer, pmem->pdata + size, newsize);
free(pmem->pdata);
#endif
pmem->pdata = (unsigned char*)buffer;
pmem->size = newsize;
pmem->buffersize = newsize + limit;
}
else
{
memmove(pmem->pdata, pmem->pdata + size, newsize);
pmem->size = newsize;
}
}
else
{
pmem->size = 0;
if(pmem->buffersize > limit)
{
automem_uninit(pmem);
automem_init(pmem, limit);
}
}
return pmem->size;
}
static void webrequest_threadproc(uv_work_t * req)
{
int ref = LUA_NOREF,sess_ref = LUA_NOREF;
automem_t mem;
webqueuework_t * qwork = container_of(req, webqueuework_t, work);
lua_State * L = luaL_newstate();
qwork->flags = qwork->conn->flags;
luaL_openlibs(L);
ref = lua_pushwebctx(L, qwork);
sess_ref = luasession_init(L,qwork);
automem_init(&mem,100);
automem_append_voidp(&mem, "require(\"", sizeof("require(\"") - 1);
automem_append_voidp(&mem, qwork->request->file, strlen(qwork->request->file));
switch (qwork->conn->proto) {
case WEB_PROTO_HTTP:
automem_append_voidp(&mem, "\"):main()", sizeof("\"):main()"));
break;
case WEB_PROTO_WEBSOCKET:
automem_append_voidp(&mem, "\"):websocket()", sizeof("\"):websocket()"));
break;
}
luaL_dostring(L, mem.pdata);
if (LUA_TSTRING == lua_type(L, -1)) {
size_t len;
const char * err = lua_tolstring(L, -1, &len);
qwork->status = 500;
automem_append_voidp(&qwork->mem, err, len);
}
automem_uninit(&mem);
luaL_unref(L,LUA_REGISTRYINDEX, ref);
lua_close(L);
}
void wsparser_uninit(wsparser_t * parser) {
automem_uninit(&parser->buf);
}
