void wsparser_init(wsparser_t * parser, int ver,size_t maxsize) {
automem_init(&parser->buf, 256);
automem_init(&parser->payload, 2048);
parser->offset = 0;
parser->ver = 13;
parser->maxsize = maxsize;
parser->st = WS_STATE_OPCODE;
}
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 lua_tpl_expand_variables(lua_State * L, automem_t * mem, int bufsize) {
if(lua_istable(L, 3)) {
const char * key ;
automem_init(mem, bufsize + 10240);
lua_pushnil(L);
automem_append_voidp(mem, "local _ARGS_= ...\n",sizeof("local _ARGS_= ...\n")-1);
while(lua_next(L, 3)) {
// -1 value -2 key
if(lua_isstring(L, -2)) {
size_t lkey;
if(NULL != (key = lua_tolstring(L, -2, &lkey))) {
automem_append_voidp(mem, "local ",sizeof("local ")-1);
automem_append_voidp(mem, key, lkey);
automem_append_voidp(mem, "=_ARGS_[\"",sizeof("=_ARGS_[\"")-1);
automem_append_voidp(mem, key, lkey);
automem_append_voidp(mem, "\"]\n", sizeof("\"]\n")-1);
}
}
lua_pop(L, 1);
}
} else
automem_init(mem, bufsize + 20);
}
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;
}
int ws_do_handeshake(automem_t * mem, char * key, int lkey)
{
char * sec;
char sha_out[20], base64_out[40];
size_t base64_len = sizeof(base64_out);
if (0 == lkey) return -1;
sec = malloc(lkey + sizeof(secret));
strcpy(sec, key);
strcpy(sec + lkey, secret);
sha1(sec, lkey + sizeof(secret) - 1, sha_out);
base64_encode(base64_out, &base64_len, sha_out, 20);
automem_init(mem, 256);
automem_append_voidp(mem, SWITCH_WEBSOCKET_PROTOCOL, sizeof(SWITCH_WEBSOCKET_PROTOCOL) - 1);
automem_append_voidp(mem, base64_out, base64_len);
automem_append_voidp(mem, "\r\n\r\n", 4);
free(sec);
return 0;
}
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_pushdata(wsparser_t * parser, unsigned char * data, uint32_t size, wsparser_onhandler handler, void * eParam)
{
unsigned char *p = data;
uint32_t i;
if (parser->buf.size > 0) {
automem_append_voidp(&parser->buf, data, size);
data = parser->buf.pdata;
size = parser->buf.size;
}
while (parser->offset < size) {
switch (parser->st) {
case WS_STATE_OPCODE:
if (size - parser->offset > 2) {
struct wsFrameHeader * fh = (struct wsFrameHeader *)&data[parser->offset];
parser->fin = fh->fin;
parser->mask = fh->mask;
parser->opcode = fh->opcode==WS_CONTINUATION_FRAME? parser->opcode: fh->opcode;
parser->offset += 2;
parser->st = WS_STATE_PLEN;
printf("OpCode = %d, Fin=%d\n", parser->opcode,parser->fin);
switch (fh->plen) {
case 126:
parser->st = WS_STATE_PLEN;
break;
case 127:
parser->st = WS_STATE_PLLEN;
break;
default:
parser->len = fh->plen;
parser->st = parser->mask ? WS_STATE_MASK : WS_STATE_PAYLOAD;
break;
}
if (WS_PING_FRAME == parser->opcode) {
handler(parser, NULL, eParam);
}
}
break;
case WS_STATE_PLEN:
if (size - parser->offset < 2) goto wsparser_pushdata_final;
parser->len = SWAP_U16(*(uint16_t *)&data[parser->offset]);
parser->offset += 2;
parser->st = parser->mask ? WS_STATE_MASK : WS_STATE_PAYLOAD;
break;
case WS_STATE_PLLEN:
if (size - parser->offset < 8) goto wsparser_pushdata_final;
parser->len = SWAP_U64(*(uint64_t *)&data[parser->offset]);
#if defined(_DEBUG)
printf("size = %lld", parser->len);
#endif
parser->offset += 8;
parser->st = parser->mask ? WS_STATE_MASK : WS_STATE_PAYLOAD;
break;
case WS_STATE_MASK:
if (size - parser->offset < 4) goto wsparser_pushdata_final;
memcpy(parser->msk_bytes, &data[parser->offset], 4);
parser->offset += 4;
parser->st = WS_STATE_PAYLOAD;
break;
case WS_STATE_PAYLOAD:
if (size - parser->offset < parser->len) goto wsparser_pushdata_final;
//处理帧数据
if (parser->mask) {
automem_t * m = &parser->payload;
automem_ensure_newspace(m, parser->len);
for (i = 0; i < parser->len; i++) {
m->pdata[m->size++] = data[parser->offset+i] ^ parser->msk_bytes[i % 4];
}
}
if (parser->fin == 1) {
wsFrame * f = malloc(sizeof(wsFrame));
f->len = parser->payload.size;
f->opcode = parser->opcode;
f->pdata = f->len > 0 ? parser->payload.pdata : NULL;
handler(parser, f, eParam);
if (f->len){
parser->payload.pdata = NULL;
parser->payload.size = parser->payload.buffersize = 0;
automem_init(&parser->payload, 2048);
}
}
parser->offset += (uint32_t)parser->len;
parser->st = WS_STATE_OPCODE;
break;
}
}
wsparser_pushdata_final:
if (size > parser->offset) {
if (data != parser->buf.pdata) {
automem_append_voidp(&parser->buf, data + parser->offset, size - parser->offset);//将未用完的加入到 buf.
parser->offset = 0;
}
}
else if (size <= parser->offset) {
if (data == parser->buf.pdata) {
}
if (parser->buf.buffersize > parser->maxsize)
automem_clean(&parser->buf, parser->maxsize);
else
automem_reset(&parser->buf);
parser->offset = 0;
}
return;
}
/*清理并重新初始化*/
void automem_clean(automem_t* pmen)
{
automem_uninit(pmen);
automem_init(pmen,128);
}
