u_char *
ngx_log_errno(u_char *buf, u_char *last, ngx_err_t err)
{
if (buf > last - 50) {
/* leave a space for an error code */
buf = last - 50;
*buf++ = '.';
*buf++ = '.';
*buf++ = '.';
}
#if (NGX_WIN32)
buf = ngx_slprintf(buf, last, ((unsigned) err < 0x80000000)
? " (%d: " : " (%Xd: ", err);
#else
buf = ngx_slprintf(buf, last, " (%d: ", err);
#endif
buf = ngx_strerror(err, buf, last - buf);
if (buf < last) {
*buf++ = ')';
}
return buf;
}
static int
ngx_http_lua_socket_error_retval_handler(ngx_http_request_t *r,
ngx_http_lua_socket_udp_upstream_t *u, lua_State *L)
{
u_char errstr[NGX_MAX_ERROR_STR];
u_char *p;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"lua udp socket error retval handler");
if (u->ft_type & NGX_HTTP_LUA_SOCKET_FT_RESOLVER) {
return 2;
}
lua_pushnil(L);
if (u->ft_type & NGX_HTTP_LUA_SOCKET_FT_PARTIALWRITE) {
lua_pushliteral(L, "partial write");
} else if (u->ft_type & NGX_HTTP_LUA_SOCKET_FT_TIMEOUT) {
lua_pushliteral(L, "timeout");
} else if (u->ft_type & NGX_HTTP_LUA_SOCKET_FT_CLOSED) {
lua_pushliteral(L, "closed");
} else if (u->ft_type & NGX_HTTP_LUA_SOCKET_FT_BUFTOOSMALL) {
lua_pushliteral(L, "buffer too small");
} else if (u->ft_type & NGX_HTTP_LUA_SOCKET_FT_NOMEM) {
lua_pushliteral(L, "out of memory");
} else {
if (u->socket_errno) {
#if (nginx_version >= 1000000)
p = ngx_strerror(u->socket_errno, errstr, sizeof(errstr));
#else
p = ngx_strerror_r(u->socket_errno, errstr, sizeof(errstr));
#endif
/* for compatibility with LuaSocket */
ngx_strlow(errstr, errstr, p - errstr);
lua_pushlstring(L, (char *) errstr, p - errstr);
} else {
lua_pushliteral(L, "error");
}
}
return 2;
}
static int
ngx_tcp_lua_req_error_retval_handler(ngx_tcp_session_t *s, lua_State *L)
{
u_char errstr[NGX_MAX_ERROR_STR];
u_char *p;
ngx_tcp_lua_ctx_t *ctx;
ngx_log_debug0(NGX_LOG_DEBUG_TCP, s->connection->log, 0,
"lua socket error retval handler");
//ngx_tcp_lua_socket_finalize(s, u);
ctx = s->ctx;
lua_pushnil(L);
if (ctx->ft_type & NGX_TCP_LUA_REQ_FT_TIMEOUT) {
lua_pushliteral(L, "timeout");
} else if (ctx->ft_type & NGX_TCP_LUA_REQ_FT_CLOSED) {
lua_pushliteral(L, "closed");
} else if (ctx->ft_type & NGX_TCP_LUA_REQ_FT_NOMEM) {
lua_pushliteral(L, "out of memory");
} else {
if (ctx->socket_errno) {
p = ngx_strerror(ctx->socket_errno, errstr, sizeof(errstr));
/* for compatibility with LuaSocket */
ngx_strlow(errstr, errstr, p - errstr);
lua_pushlstring(L, (char *) errstr, p - errstr);
} else {
lua_pushliteral(L, "error");
}
}
return 2;
}
mrb_parser_state ngx_init_mruby_parser(ngx_str_t *source_filename, const ngx_log_t *log) {
FILE *source_file;
char *source;
struct stat source_file_stat;
unsigned int source_size;
struct mrb_parser_state *parser;
if (source_filename == NULL) {
ngx_log_error(NGX_LOG_CRIT, log, "mruby source filename is invalid");
return NULL;
}
mrb_interpreter = mrb_open();
if (mrb_interpreter == NULL) {
ngx_log_error(NGX_LOG_CRIT, "could not allocate mruby interpreter");
return NULL;
}
parser = mrb_parser_new(mrb_interpreter);
stat(source_filename, &source_file_stat);
if (source_file_stat == NULL) {
ngx_log_error(NGX_LOG_CRIT, log, "mruby file '%s' does not exist.", source_filename);
return NULL;
}
source_size = (source_file_stat.st_size * sizeof(char)) + 1;
source = calloc(source_size);
if (source == NULL) {
ngx_log_error(NGX_LOG_CRIT, log, "could not allocate memory for mruby source");
return NULL;
}
source_file = fopen(source_filename, "r");
fread(source, sizeof(char), source_file_stat.st_size, source_file);
if (ferror(source_file)) {
ngx_log_error(
NGX_LOG_CRIT,
log,
"could not read mruby file '%s': %s",
source_filename,
ngx_strerror(ferror(source_file))
);
free(source);
return NULL;
} else {
fclose(source_file);
}
parser->filename = (char *)source_filename;
parser->s = source;
parser->send = source + strlen(source);
parser->capture_errors = 1;
parser->lineno = 1;
return parser;
}
static ngx_int_t
ngx_http_store_plusplus_add_path(ngx_http_request_t *r, ngx_conhash_t *conhash, ngx_chain_t *out)
{
ngx_str_t value;
size_t len;
ngx_int_t rc;
ngx_buf_t *b;
u_char *p, *path_name;
ngx_file_info_t fi;
ngx_err_t err;
rc = ngx_http_arg(r, (u_char *) STORE_VALUE_STR, sizeof(STORE_VALUE_STR) - 1, &value);
if (rc != NGX_OK) {
return rc;
}
b = ngx_create_temp_buf(r->pool, 1024);
if (b == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
if (value.data[0] != '/') {
b->last = ngx_sprintf(b->last, "ERROR: must be an absolute path." CRLF);
rc = NGX_OK;
goto done;
}
if (value.data[value.len - 1] == '/') {
value.len--;
}
// check whether the store path is existent.
len = value.len + 1 + sizeof(NGX_STORE_PLUSPLUS_TMP_PATH) - 1;
path_name = ngx_pcalloc(r->pool, len + 1);
if (path_name == NULL) {
return NGX_ERROR;
}
p = ngx_cpymem(path_name, value.data, value.len);
*p = '\0';
rc = ngx_file_info(path_name, &fi);
if (rc == NGX_FILE_ERROR) {
err = ngx_errno;
b->last = ngx_strerror(err, b->last, b->end - b->last);
*b->last++ = CR;
*b->last++ = LF;
rc = NGX_OK;
goto done;
}
// create temp_path in this store path
p = ngx_cpymem(path_name, value.data, value.len);
*p++ = '/';
p = ngx_cpymem(p, NGX_STORE_PLUSPLUS_TMP_PATH, sizeof(NGX_STORE_PLUSPLUS_TMP_PATH) - 1);
*p++ = '\0';
if (ngx_create_dir(path_name, ngx_dir_access(NGX_FILE_OWNER_ACCESS))
== NGX_FILE_ERROR)
{
err = ngx_errno;
if (err != NGX_EEXIST) {
b->last = ngx_strerror(err, b->last, b->end - b->last);
*b->last++ = CR;
*b->last++ = LF;
rc = NGX_OK;
goto done;
}
}
rc = ngx_conhash_add_node(conhash, value.data, value.len, NULL);
if (rc == NGX_OK) {
b->last = ngx_sprintf(b->last, "Add node successfully!" CRLF);
}
if (rc == NGX_DECLINED) {
b->last = ngx_sprintf(b->last, "The node already exists!" CRLF);
rc = NGX_OK;
}
if (rc == NGX_AGAIN) {
b->last = ngx_sprintf(b->last, "The conhash space is not enough!" CRLF);
rc = NGX_OK;
}
done:
b->last_buf = 1;
out->buf = b;
return rc;
}
static int
ngx_stream_lua_ngx_echo(lua_State *L, unsigned newline)
{
ngx_stream_session_t *s;
ngx_stream_lua_ctx_t *ctx;
const char *p;
size_t len;
size_t size;
ngx_buf_t *b;
ngx_chain_t *cl;
ngx_int_t rc;
int i;
int nargs;
int type;
ngx_err_t err;
const char *msg;
u_char errbuf[NGX_STREAM_LUA_MAX_ERROR_STR];
s = ngx_stream_lua_get_session(L);
if (s == NULL) {
return luaL_error(L, "no session object found");
}
ctx = ngx_stream_get_module_ctx(s, ngx_stream_lua_module);
if (ctx == NULL) {
return luaL_error(L, "no session ctx found");
}
ngx_stream_lua_check_context(L, ctx, NGX_STREAM_LUA_CONTEXT_CONTENT);
#if 0
if (ctx->acquired_raw_req_socket) {
lua_pushnil(L);
lua_pushliteral(L, "raw session socket acquired");
return 2;
}
#endif
if (ctx->eof) {
lua_pushnil(L);
lua_pushliteral(L, "seen eof");
return 2;
}
nargs = lua_gettop(L);
size = 0;
for (i = 1; i <= nargs; i++) {
type = lua_type(L, i);
switch (type) {
case LUA_TNUMBER:
case LUA_TSTRING:
lua_tolstring(L, i, &len);
size += len;
break;
case LUA_TNIL:
size += sizeof("nil") - 1;
break;
case LUA_TBOOLEAN:
if (lua_toboolean(L, i)) {
size += sizeof("true") - 1;
} else {
size += sizeof("false") - 1;
}
break;
case LUA_TTABLE:
size += ngx_stream_lua_calc_strlen_in_table(L, i, i,
0 /* strict */);
break;
case LUA_TLIGHTUSERDATA:
dd("userdata: %p", lua_touserdata(L, i));
if (lua_touserdata(L, i) == NULL) {
size += sizeof("null") - 1;
break;
}
continue;
default:
msg = lua_pushfstring(L, "string, number, boolean, nil, "
"ngx.null, or array table expected, "
"but got %s", lua_typename(L, type));
return luaL_argerror(L, i, msg);
}
}
if (newline) {
size += sizeof("\n") - 1;
}
if (size == 0) {
/* do nothing for empty strings */
lua_pushinteger(L, 1);
return 1;
}
cl = ngx_stream_lua_chain_get_free_buf(s->connection->log,
s->connection->pool,
&ctx->free_bufs, size);
if (cl == NULL) {
return luaL_error(L, "no memory");
}
b = cl->buf;
for (i = 1; i <= nargs; i++) {
type = lua_type(L, i);
switch (type) {
case LUA_TNUMBER:
case LUA_TSTRING:
p = lua_tolstring(L, i, &len);
b->last = ngx_copy(b->last, (u_char *) p, len);
break;
case LUA_TNIL:
*b->last++ = 'n';
*b->last++ = 'i';
*b->last++ = 'l';
break;
case LUA_TBOOLEAN:
if (lua_toboolean(L, i)) {
*b->last++ = 't';
*b->last++ = 'r';
*b->last++ = 'u';
*b->last++ = 'e';
} else {
*b->last++ = 'f';
*b->last++ = 'a';
*b->last++ = 'l';
*b->last++ = 's';
*b->last++ = 'e';
}
break;
case LUA_TTABLE:
b->last = ngx_stream_lua_copy_str_in_table(L, i, b->last);
break;
case LUA_TLIGHTUSERDATA:
*b->last++ = 'n';
*b->last++ = 'u';
*b->last++ = 'l';
*b->last++ = 'l';
break;
default:
return luaL_error(L, "impossible to reach here");
}
}
if (newline) {
*b->last++ = '\n';
}
#if 0
if (b->last != b->end) {
return luaL_error(L, "buffer error: %p != %p", b->last, b->end);
}
#endif
ngx_log_debug0(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
newline ? "stream lua say response"
: "stream lua print response");
ngx_set_errno(0);
rc = ngx_stream_lua_send_chain_link(s, ctx, cl);
if (rc == NGX_ERROR) {
err = ngx_errno;
lua_pushnil(L);
if (err) {
size = ngx_strerror(err, errbuf, sizeof(errbuf)) - errbuf;
ngx_strlow(errbuf, errbuf, size);
lua_pushlstring(L, (char *) errbuf, size);
} else {
lua_pushliteral(L, "unknown");
}
return 2;
}
dd("downstream write: %d, buf len: %d", (int) rc,
(int) (b->last - b->pos));
lua_pushinteger(L, 1);
return 1;
}
void
ngx_http_fsutil_code_common( ngx_http_script_engine_t *e )
{
fsutil_code_t *codeobj;
ngx_http_variable_value_t *vv_src;
ngx_http_variable_value_t *vv_dst;
char *dst;
char *src;
ngx_int_t i;
ngx_int_t rc;
codeobj = ( fsutil_code_t* )e->ip;
_x_getvar( src );
_x_getvar( dst );
# undef _x_getvar
# define lg( fmt ... ) \
ngx_log_error(NGX_LOG_ERR, e->request->connection->log, 0, fmt );
dst[ 0 ] = '/';
for ( i = 1; i < vv_dst->len; i++ ) {
if ( vv_dst->data[ i ] == '/' ) {
dst[ i ] = 0;
rc = ngx_http_fsutil_create_dir_if_not_found( e->request->connection->log, dst );
if ( NGX_OK != rc ) {
goto error_fserror_to_httpcode;
}
}
dst[ i ] = vv_dst->data[ i ];
}
dst[ i ] = 0;
ngx_memcpy( src, vv_src->data, vv_src->len );
src[ vv_src->len ] = 0;
/* lg( "src=%s dst=%s", src, dst ); */
switch ( codeobj->op ) {
case fsutil_op_mv :
if ( fsutil_opt_onexist_override & codeobj->opt ) {
/* lg( "to rename directly" ); */
rc = ngx_rename_file( src, dst );
}
else {
/*
* Rename does'nt support non-override operation. Thus we
* need to link to it first and then remove the original
* one
*/
/* lg( "link and unlink" ); */
rc = link( src, dst );
/* lg( "link rc=%d", rc ); */
if ( NGX_OK == rc ) {
rc = unlink( src );
/* lg( "unlink rc=%d", rc ); */
}
else if ( NGX_EEXIST == ngx_errno ) {
if ( fsutil_opt_onexist_touch & codeobj->opt ) {
rc = utimes( dst, NULL );
/* lg( "utimes rc=%d", rc ); */
}
else {
rc = NGX_OK;
}
}
}
break;
case fsutil_op_ln :
if ( fsutil_opt_onexist_override & codeobj->opt ) {
while ( NGX_OK != (
rc = link( src, dst ) ) ) {
if ( NGX_EEXIST != ngx_errno ) {
break;
}
rc = unlink( dst );
if ( NGX_OK == rc || NGX_ENOENT == ngx_errno ) {
continue;
}
else {
/* other error which can not be handled */
break;
}
}
}
else if ( fsutil_opt_onexist_touch & codeobj->opt ) {
if ( NGX_OK != ( rc = link( src, dst ) ) ) {
if ( NGX_EEXIST == ngx_errno ) {
rc = utimes( dst, NULL );
}
}
}
else {
/* ignore */
link( src, dst );
rc = NGX_OK;
}
break;
default:
goto error_op_unsupported;
}
if ( 0 != rc ) {
u_char errstr[ 1024 ];
ngx_strerror( ngx_errno, errstr, 1024 );
ngx_log_error(NGX_LOG_ERR, e->request->connection->log, 0,
"%V failed. src=%s dst=%s, err=%d %s", &opnames[ codeobj->op ], src, dst, ngx_errno, errstr );
goto error_op_failed;
}
e->ip += sizeof(fsutil_code_t);
return;
error_op_unsupported:
error_var_not_found:
e->status = NGX_HTTP_BAD_REQUEST;
e->ip += sizeof(fsutil_code_t) - sizeof(uintptr_t);
return;
error_op_failed:
error_fserror_to_httpcode:
switch ( rc ) {
case NGX_ENOTDIR :
e->status = NGX_HTTP_CONFLICT;
break;
default:
e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
}
e->ip += sizeof(fsutil_code_t) - sizeof(uintptr_t);
return;
error_500:
e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
e->ip += sizeof(fsutil_code_t) - sizeof(uintptr_t);
return;
}