static void
ngx_http_lua_socket_udp_handle_error(ngx_http_request_t *r,
ngx_http_lua_socket_udp_upstream_t *u, ngx_uint_t ft_type)
{
ngx_http_lua_ctx_t *ctx;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"lua udp socket handle error");
u->ft_type |= ft_type;
#if 0
ngx_http_lua_socket_udp_finalize(r, u);
#endif
u->read_event_handler = ngx_http_lua_socket_dummy_handler;
if (u->waiting) {
u->waiting = 0;
ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module);
if (ctx == NULL) {
return;
}
ctx->resume_handler = ngx_http_lua_socket_udp_resume;
ctx->cur_co_ctx = u->co_ctx;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"lua udp socket waking up the current request");
r->write_event_handler(r);
}
}
static void
ngx_http_lua_socket_udp_cleanup(void *data)
{
ngx_http_lua_socket_udp_upstream_t *u = data;
ngx_http_request_t *r;
r = u->request;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"cleanup lua udp socket upstream request: \"%V\"", &r->uri);
ngx_http_lua_socket_udp_finalize(r, u);
}
static void
ngx_http_lua_udp_socket_cleanup(void *data)
{
ngx_http_lua_socket_udp_upstream_t *u;
ngx_http_lua_co_ctx_t *coctx = data;
u = coctx->data;
if (u == NULL) {
return;
}
if (u->request == NULL) {
return;
}
ngx_http_lua_socket_udp_finalize(u->request, u);
}
static int
ngx_http_lua_socket_udp_close(lua_State *L)
{
ngx_http_request_t *r;
ngx_http_lua_socket_udp_upstream_t *u;
if (lua_gettop(L) != 1) {
return luaL_error(L, "expecting 1 argument "
"(including the object) but seen %d", lua_gettop(L));
}
r = ngx_http_lua_get_req(L);
if (r == NULL) {
return luaL_error(L, "no request found");
}
luaL_checktype(L, 1, LUA_TTABLE);
lua_rawgeti(L, 1, SOCKET_CTX_INDEX);
u = lua_touserdata(L, -1);
lua_pop(L, 1);
if (u == NULL || u->udp_connection.connection == NULL) {
lua_pushnil(L);
lua_pushliteral(L, "closed");
return 2;
}
if (u->request != r) {
return luaL_error(L, "bad request");
}
if (u->waiting) {
lua_pushnil(L);
lua_pushliteral(L, "socket busy");
return 2;
}
ngx_http_lua_socket_udp_finalize(r, u);
lua_pushinteger(L, 1);
return 1;
}
static int
ngx_http_lua_socket_udp_setpeername(lua_State *L)
{
ngx_http_request_t *r;
ngx_http_lua_ctx_t *ctx;
ngx_str_t host;
int port;
ngx_resolver_ctx_t *rctx, temp;
ngx_http_core_loc_conf_t *clcf;
int saved_top;
int n;
u_char *p;
size_t len;
ngx_url_t url;
ngx_int_t rc;
ngx_http_lua_loc_conf_t *llcf;
ngx_udp_connection_t *uc;
int timeout;
ngx_http_lua_co_ctx_t *coctx;
ngx_http_lua_socket_udp_upstream_t *u;
/*
* TODO: we should probably accept an extra argument to setpeername()
* to allow the user bind the datagram unix domain socket himself,
* which is necessary for systems without autobind support.
*/
n = lua_gettop(L);
if (n != 2 && n != 3) {
return luaL_error(L, "ngx.socket.udp setpeername: expecting 2 or 3 "
"arguments (including the object), but seen %d", n);
}
lua_pushlightuserdata(L, &ngx_http_lua_request_key);
lua_rawget(L, LUA_GLOBALSINDEX);
r = lua_touserdata(L, -1);
lua_pop(L, 1);
if (r == NULL) {
return luaL_error(L, "no request found");
}
ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module);
if (ctx == NULL) {
return luaL_error(L, "no ctx found");
}
ngx_http_lua_check_context(L, ctx, NGX_HTTP_LUA_CONTEXT_REWRITE
| NGX_HTTP_LUA_CONTEXT_ACCESS
| NGX_HTTP_LUA_CONTEXT_CONTENT);
luaL_checktype(L, 1, LUA_TTABLE);
p = (u_char *) luaL_checklstring(L, 2, &len);
host.data = ngx_palloc(r->pool, len + 1);
if (host.data == NULL) {
return luaL_error(L, "out of memory");
}
host.len = len;
ngx_memcpy(host.data, p, len);
host.data[len] = '\0';
if (n == 3) {
port = luaL_checkinteger(L, 3);
if (port < 0 || port > 65536) {
lua_pushnil(L);
lua_pushfstring(L, "bad port number: %d", port);
return 2;
}
} else { /* n == 2 */
port = 0;
}
lua_rawgeti(L, 1, SOCKET_CTX_INDEX);
u = lua_touserdata(L, -1);
lua_pop(L, 1);
if (u) {
if (u->waiting) {
lua_pushnil(L);
lua_pushliteral(L, "socket busy");
return 2;
}
if (u->udp_connection.connection) {
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"lua udp socket reconnect without shutting down");
ngx_http_lua_socket_udp_finalize(r, u);
}
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"lua reuse socket upstream ctx");
} else {
u = lua_newuserdata(L, sizeof(ngx_http_lua_socket_udp_upstream_t));
if (u == NULL) {
return luaL_error(L, "out of memory");
}
#if 1
lua_createtable(L, 0 /* narr */, 1 /* nrec */); /* metatable */
lua_pushcfunction(L, ngx_http_lua_socket_udp_upstream_destroy);
lua_setfield(L, -2, "__gc");
lua_setmetatable(L, -2);
#endif
lua_rawseti(L, 1, SOCKET_CTX_INDEX);
}
ngx_memzero(u, sizeof(ngx_http_lua_socket_udp_upstream_t));
u->request = r; /* set the controlling request */
llcf = ngx_http_get_module_loc_conf(r, ngx_http_lua_module);
u->conf = llcf;
uc = &u->udp_connection;
uc->log = *r->connection->log;
dd("lua peer connection log: %p", &uc->log);
lua_rawgeti(L, 1, SOCKET_TIMEOUT_INDEX);
timeout = (ngx_int_t) lua_tointeger(L, -1);
lua_pop(L, 1);
if (timeout > 0) {
u->read_timeout = (ngx_msec_t) timeout;
} else {
u->read_timeout = u->conf->read_timeout;
}
ngx_memzero(&url, sizeof(ngx_url_t));
url.url.len = host.len;
url.url.data = host.data;
url.default_port = port;
url.no_resolve = 1;
if (ngx_parse_url(r->pool, &url) != NGX_OK) {
lua_pushnil(L);
if (url.err) {
lua_pushfstring(L, "failed to parse host name \"%s\": %s",
host.data, url.err);
} else {
lua_pushfstring(L, "failed to parse host name \"%s\"", host.data);
}
return 2;
}
u->resolved = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolved_t));
if (u->resolved == NULL) {
return luaL_error(L, "out of memory");
}
if (url.addrs && url.addrs[0].sockaddr) {
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"lua udp socket network address given directly");
u->resolved->sockaddr = url.addrs[0].sockaddr;
u->resolved->socklen = url.addrs[0].socklen;
u->resolved->naddrs = 1;
u->resolved->host = url.addrs[0].name;
} else {
u->resolved->host = host;
u->resolved->port = (in_port_t) port;
}
if (u->resolved->sockaddr) {
rc = ngx_http_lua_socket_resolve_retval_handler(r, u, L);
if (rc == NGX_AGAIN) {
return lua_yield(L, 0);
}
return rc;
}
clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
temp.name = host;
rctx = ngx_resolve_start(clcf->resolver, &temp);
if (rctx == NULL) {
u->ft_type |= NGX_HTTP_LUA_SOCKET_FT_RESOLVER;
lua_pushnil(L);
lua_pushliteral(L, "failed to start the resolver");
return 2;
}
if (rctx == NGX_NO_RESOLVER) {
u->ft_type |= NGX_HTTP_LUA_SOCKET_FT_RESOLVER;
lua_pushnil(L);
lua_pushfstring(L, "no resolver defined to resolve \"%s\"", host.data);
return 2;
}
rctx->name = host;
rctx->type = NGX_RESOLVE_A;
rctx->handler = ngx_http_lua_socket_resolve_handler;
rctx->data = u;
rctx->timeout = clcf->resolver_timeout;
u->co_ctx = ctx->cur_co_ctx;
u->resolved->ctx = rctx;
saved_top = lua_gettop(L);
coctx = ctx->cur_co_ctx;
coctx->cleanup = ngx_http_lua_udp_resolve_cleanup;
if (ngx_resolve_name(rctx) != NGX_OK) {
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"lua udp socket fail to run resolver immediately");
u->ft_type |= NGX_HTTP_LUA_SOCKET_FT_RESOLVER;
u->resolved->ctx = NULL;
lua_pushnil(L);
lua_pushfstring(L, "%s could not be resolved", host.data);
return 2;
}
if (u->waiting == 1) {
/* resolved and already connecting */
return lua_yield(L, 0);
}
n = lua_gettop(L) - saved_top;
if (n) {
/* errors occurred during resolving or connecting
* or already connected */
return n;
}
/* still resolving */
u->waiting = 1;
u->prepare_retvals = ngx_http_lua_socket_resolve_retval_handler;
coctx->data = u;
if (ctx->entered_content_phase) {
r->write_event_handler = ngx_http_lua_content_wev_handler;
} else {
r->write_event_handler = ngx_http_core_run_phases;
}
return lua_yield(L, 0);
}
