#include <lauxlib.h>

#include <lua.h>

#include <lualib.h>

#include <haproxy/cli-t.h>

#include <haproxy/errors.h>

#include <haproxy/hlua-t.h>

#include <haproxy/http.h>

#include <haproxy/net_helper.h>

#include <haproxy/pattern-t.h>

#include <haproxy/proxy.h>

#include <haproxy/regex.h>

#include <haproxy/server.h>

#include <haproxy/stats.h>

#include <haproxy/stick_table.h>

#include <haproxy/time.h>

static int class_concat_ref;

static int class_proxy_ref;

static int class_server_ref;

static int class_listener_ref;

static int class_regex_ref;

static int class_stktable_ref;

#define STATS_LEN (MAX((int)ST_F_TOTAL_FIELDS, (int)INF_TOTAL_FIELDS))

static THREAD_LOCAL struct field stats[STATS_LEN];

int hlua_checkboolean(lua_State *L, int index)

{

if (!lua_isboolean(L, index))

luaL_argerror(L, index, "boolean expected");

return lua_toboolean(L, index);

}

static int hlua_fcn_pushunsigned(lua_State *L, unsigned int val)

{

#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))

lua_pushinteger(L, val);

if (val > INT_MAX)

lua_pushnumber(L, (lua_Number)val);

else

lua_pushinteger(L, (int)val);

return 1;

}

static int hlua_fcn_pushunsigned_ll(lua_State *L, unsigned long long val) {

#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))

/* 64 bits case, U64 is supported until LLONG_MAX */

if (val > LLONG_MAX)

lua_pushnumber(L, (lua_Number)val);

else

lua_pushinteger(L, val);

/* 32 bits case, U64 is supported until INT_MAX */

if (val > INT_MAX)

lua_pushnumber(L, (lua_Number)val);

else

lua_pushinteger(L, (int)val);

return 1;

}

int hlua_fcn_pushfield(lua_State *L, struct field *field)

{

/* The lua_Integer is always signed. Its length depends on

switch (field_format(field, 0)) {

case FF_EMPTY:

lua_pushnil(L);

return 1;

case FF_S32:

/* S32 is always supported. */

lua_pushinteger(L, field->u.s32);

return 1;

case FF_U32:

#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))

/* 64 bits case, U32 is always supported */

lua_pushinteger(L, field->u.u32);

/* 32 bits case, U32 is supported until INT_MAX. */

if (field->u.u32 > INT_MAX)

lua_pushnumber(L, (lua_Number)field->u.u32);

else

lua_pushinteger(L, field->u.u32);

return 1;

case FF_S64:

#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))

/* 64 bits case, S64 is always supported */

lua_pushinteger(L, field->u.s64);

/* 64 bits case, S64 is supported between INT_MIN and INT_MAX */

if (field->u.s64 < INT_MIN || field->u.s64 > INT_MAX)

lua_pushnumber(L, (lua_Number)field->u.s64);

else

lua_pushinteger(L, (int)field->u.s64);

return 1;

case FF_U64:

#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))

/* 64 bits case, U64 is supported until LLONG_MAX */

if (field->u.u64 > LLONG_MAX)

lua_pushnumber(L, (lua_Number)field->u.u64);

else

lua_pushinteger(L, field->u.u64);

/* 64 bits case, U64 is supported until INT_MAX */

if (field->u.u64 > INT_MAX)

lua_pushnumber(L, (lua_Number)field->u.u64);

else

lua_pushinteger(L, (int)field->u.u64);

return 1;

case FF_STR:

lua_pushstring(L, field->u.str);

return 1;

default:

break;

}

/* Default case, never reached. */

lua_pushnil(L);

return 1;

}

const char *hlua_pushstrippedstring(lua_State *L, const char *str)

{

const char *p;

const char *e;

for (p = str; HTTP_IS_LWS(*p); p++);

for (e = p + strlen(p) - 1; e > p && HTTP_IS_LWS(*e); e--);

return lua_pushlstring(L, p, e - p);

}

void hlua_class_const_int(lua_State *L, const char *name, int value)

{

lua_pushstring(L, name);

lua_pushinteger(L, value);

lua_rawset(L, -3);

}

void hlua_class_const_str(lua_State *L, const char *name, const char *value)

{

lua_pushstring(L, name);

lua_pushstring(L, value);

lua_rawset(L, -3);

}

void hlua_class_function(lua_State *L, const char *name, int (*function)(lua_State *L))

{

lua_pushstring(L, name);

lua_pushcclosure(L, function, 0);

lua_rawset(L, -3);

}

int hlua_dump_object(struct lua_State *L)

{

const char *name = (const char *)lua_tostring(L, lua_upvalueindex(1));

lua_pushfstring(L, "HAProxy class %s", name);

return 1;

}

int hlua_register_metatable(struct lua_State *L, char *name)

{

/* Check the type of the top element. it must be

if (lua_type(L, -1) != LUA_TTABLE)

luaL_error(L, "hlua_register_metatable() requires a type Table "

"in the top of the stack");

/* Add the __tostring function which identify the

lua_pushstring(L, "__tostring");

lua_pushstring(L, name);

lua_pushcclosure(L, hlua_dump_object, 1);

lua_rawset(L, -3);

/* Register a named entry for the table. The table

lua_pushvalue(L, -1);

lua_setfield(L, LUA_REGISTRYINDEX, name);

/* Creates the reference of the object. The

return luaL_ref(L, LUA_REGISTRYINDEX);

}

void *hlua_checkudata(lua_State *L, int ud, int class_ref)

{

void *p;

int ret;

/* Check if the stack entry is an array. */

if (!lua_istable(L, ud))

luaL_argerror(L, ud, NULL);

/* pop the metatable of the referencecd object. */

if (!lua_getmetatable(L, ud))

luaL_argerror(L, ud, NULL);

/* pop the expected metatable. */

lua_rawgeti(L, LUA_REGISTRYINDEX, class_ref);

/* Check if the metadata have the expected type. */

ret = lua_rawequal(L, -1, -2);

lua_pop(L, 2);

if (!ret)

luaL_argerror(L, ud, NULL);

/* Push on the stack at the entry [0] of the table. */

lua_rawgeti(L, ud, 0);

/* Check if this entry is userdata. */

p = lua_touserdata(L, -1);

if (!p)

luaL_argerror(L, ud, NULL);

/* Remove the entry returned by lua_rawgeti(). */

lua_pop(L, 1);

/* Return the associated struct. */

return p;

}

int hlua_now(lua_State *L)

{

lua_newtable(L);

lua_pushstring(L, "sec");

lua_pushinteger(L, now.tv_sec);

lua_rawset(L, -3);

lua_pushstring(L, "usec");

lua_pushinteger(L, now.tv_usec);

lua_rawset(L, -3);

return 1;

}

static int hlua_parse_date(lua_State *L, int (*fcn)(const char *, int, struct tm*))

{

const char *str;

size_t len;

struct tm tm;

time_t time;

str = luaL_checklstring(L, 1, &len);

if (!fcn(str, len, &tm)) {

lua_pushnil(L);

return 1;

}

/* This function considers the content of the broken-down time

time = my_timegm(&tm);

if (time == -1) {

lua_pushnil(L);

return 1;

}

lua_pushinteger(L, (int)time);

return 1;

}

static int hlua_http_date(lua_State *L)

{

return hlua_parse_date(L, parse_http_date);

}

static int hlua_imf_date(lua_State *L)

{

return hlua_parse_date(L, parse_imf_date);

}

static int hlua_rfc850_date(lua_State *L)

{

return hlua_parse_date(L, parse_rfc850_date);

}

static int hlua_asctime_date(lua_State *L)

{

return hlua_parse_date(L, parse_asctime_date);

}

static int hlua_get_info(lua_State *L)

{

int i;

stats_fill_info(stats, STATS_LEN);

lua_newtable(L);

for (i=0; i<INF_TOTAL_FIELDS; i++) {

lua_pushstring(L, info_fields[i].name);

hlua_fcn_pushfield(L, &stats[i]);

lua_settable(L, -3);

}

return 1;

}

static struct hlua_concat *hlua_check_concat(lua_State *L, int ud)

{

return (hlua_checkudata(L, ud, class_concat_ref));

}

static int hlua_concat_add(lua_State *L)

{

struct hlua_concat *b;

char *buffer;

char *new;

const char *str;

size_t l;

/* First arg must be a concat object. */

b = hlua_check_concat(L, 1);

/* Second arg must be a string. */

str = luaL_checklstring(L, 2, &l);

/* Get the buffer. */

lua_rawgeti(L, 1, 1);

buffer = lua_touserdata(L, -1);

lua_pop(L, 1);

/* Update the buffer size if it s required. The old buffer

new = NULL;

while (b->size - b->len < l) {

b->size += HLUA_CONCAT_BLOCSZ;

new = buffer;

}

if (new) {

new = lua_newuserdata(L, b->size);

memcpy(new, buffer, b->len);

lua_rawseti(L, 1, 1);

buffer = new;

}

/* Copy string, and update metadata. */

memcpy(buffer + b->len, str, l);

b->len += l;

return 0;

}

static int hlua_concat_dump(lua_State *L)

{

struct hlua_concat *b;

char *buffer;

/* First arg must be a concat object. */

b = hlua_check_concat(L, 1);

/* Get the buffer. */

lua_rawgeti(L, 1, 1);

buffer = lua_touserdata(L, -1);

lua_pop(L, 1);

/* Push the soncatenated string in the stack. */

lua_pushlstring(L, buffer, b->len);

return 1;

}

int hlua_concat_new(lua_State *L)

{

struct hlua_concat *b;

lua_newtable(L);

b = lua_newuserdata(L, sizeof(*b));

b->size = HLUA_CONCAT_BLOCSZ;

b->len = 0;

lua_rawseti(L, -2, 0);

lua_newuserdata(L, HLUA_CONCAT_BLOCSZ);

lua_rawseti(L, -2, 1);

lua_rawgeti(L, LUA_REGISTRYINDEX, class_concat_ref);

lua_setmetatable(L, -2);

return 1;

}

static int concat_tostring(lua_State *L)

{

const void *ptr = lua_topointer(L, 1);

lua_pushfstring(L, "Concat object: %p", ptr);

return 1;

}

static int hlua_concat_init(lua_State *L)

{

/* Creates the buffered concat object. */

lua_newtable(L);

lua_pushstring(L, "__tostring");

lua_pushcclosure(L, concat_tostring, 0);

lua_settable(L, -3);

lua_pushstring(L, "__index"); /* Creates the index entry. */

lua_newtable(L); /* The "__index" content. */

lua_pushstring(L, "add");

lua_pushcclosure(L, hlua_concat_add, 0);

lua_settable(L, -3);

lua_pushstring(L, "dump");

lua_pushcclosure(L, hlua_concat_dump, 0);

lua_settable(L, -3);

lua_settable(L, -3); /* Sets the __index entry. */

class_concat_ref = luaL_ref(L, LUA_REGISTRYINDEX);

return 1;

}

int hlua_fcn_new_stktable(lua_State *L, struct stktable *tbl)

{

lua_newtable(L);

/* Pop a class stktbl metatable and affect it to the userdata. */

lua_rawgeti(L, LUA_REGISTRYINDEX, class_stktable_ref);

lua_setmetatable(L, -2);

lua_pushlightuserdata(L, tbl);

lua_rawseti(L, -2, 0);

return 1;

}

static struct stktable *hlua_check_stktable(lua_State *L, int ud)

{

return hlua_checkudata(L, ud, class_stktable_ref);

}

int hlua_stktable_info(lua_State *L)

{

struct stktable *tbl;

int dt;

tbl = hlua_check_stktable(L, 1);

if (!tbl->id) {

lua_pushnil(L);

return 1;

}

lua_newtable(L);

lua_pushstring(L, "type");

lua_pushstring(L, stktable_types[tbl->type].kw);

lua_settable(L, -3);

lua_pushstring(L, "length");

lua_pushinteger(L, tbl->key_size);

lua_settable(L, -3);

lua_pushstring(L, "size");

hlua_fcn_pushunsigned(L, tbl->size);

lua_settable(L, -3);

lua_pushstring(L, "used");

hlua_fcn_pushunsigned(L, tbl->current);

lua_settable(L, -3);

lua_pushstring(L, "nopurge");

lua_pushboolean(L, tbl->nopurge > 0);

lua_settable(L, -3);

lua_pushstring(L, "expire");

lua_pushinteger(L, tbl->expire);

lua_settable(L, -3);

/* Save data types periods (if applicable) in 'data' table */

lua_pushstring(L, "data");

lua_newtable(L);

for (dt = 0; dt < STKTABLE_DATA_TYPES; dt++) {

if (tbl->data_ofs[dt] == 0)

continue;

lua_pushstring(L, stktable_data_types[dt].name);

if (stktable_data_types[dt].arg_type == ARG_T_DELAY)

lua_pushinteger(L, tbl->data_arg[dt].u);

else

lua_pushinteger(L, -1);

lua_settable(L, -3);

}

lua_settable(L, -3);

return 1;

}

static void hlua_stktable_entry(lua_State *L, struct stktable *t, struct stksess *ts)

{

int dt;

void *ptr;

for (dt = 0; dt < STKTABLE_DATA_TYPES; dt++) {

if (t->data_ofs[dt] == 0)

continue;

lua_pushstring(L, stktable_data_types[dt].name);

ptr = stktable_data_ptr(t, ts, dt);

switch (stktable_data_types[dt].std_type) {

case STD_T_SINT:

lua_pushinteger(L, stktable_data_cast(ptr, std_t_sint));

break;

case STD_T_UINT:

hlua_fcn_pushunsigned(L, stktable_data_cast(ptr, std_t_uint));

break;

case STD_T_ULL:

hlua_fcn_pushunsigned_ll(L, stktable_data_cast(ptr, std_t_ull));

break;

case STD_T_FRQP:

lua_pushinteger(L, read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp),

t->data_arg[dt].u));

break;

case STD_T_DICT: {

struct dict_entry *de;

de = stktable_data_cast(ptr, std_t_dict);

lua_pushstring(L, de ? (char *)de->value.key : "-");

break;

}

}

lua_settable(L, -3);

}

}

int hlua_stktable_lookup(lua_State *L)

{

struct stktable *t;

struct sample smp;

struct stktable_key *skey;

struct stksess *ts;

t = hlua_check_stktable(L, 1);

smp.data.type = SMP_T_STR;

smp.flags = SMP_F_CONST;

smp.data.u.str.area = (char *)lua_tolstring(L, 2, &smp.data.u.str.data);

skey = smp_to_stkey(&smp, t);

if (!skey) {

lua_pushnil(L);

return 1;

}

ts = stktable_lookup_key(t, skey);

if (!ts) {

lua_pushnil(L);

return 1;

}

lua_newtable(L);

lua_pushstring(L, "use");

lua_pushinteger(L, ts->ref_cnt - 1);

lua_settable(L, -3);

lua_pushstring(L, "expire");

lua_pushinteger(L, tick_remain(now_ms, ts->expire));

lua_settable(L, -3);

hlua_stktable_entry(L, t, ts);

HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);

ts->ref_cnt--;

HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);

return 1;

}

struct stk_filter {

};

static int hlua_error(lua_State *L, const char *fmt, ...) {

char buf[256];

int len;

va_list args;

va_start(args, fmt);

len = vsnprintf(buf, sizeof(buf), fmt, args);

va_end(args);

if (len < 0) {

ha_alert("hlua_error(): Could not write error message.\n");

lua_pushnil(L);

return 1;

} else if (len >= sizeof(buf))

ha_alert("hlua_error(): Error message was truncated.\n");

lua_pushnil(L);

lua_pushstring(L, buf);

return 2;

}

int hlua_stktable_dump(lua_State *L)

{

struct stktable *t;

struct ebmb_node *eb;

struct ebmb_node *n;

struct stksess *ts;

int type;

int op;

int dt;

long long val;

struct stk_filter filter[STKTABLE_FILTER_LEN];

int filter_count = 0;

int i;

int skip_entry;

void *ptr;

t = hlua_check_stktable(L, 1);

type = lua_type(L, 2);

switch (type) {

case LUA_TNONE:

case LUA_TNIL:

break;

case LUA_TTABLE:

lua_pushnil(L);

while (lua_next(L, 2) != 0) {

int entry_idx = 0;

if (filter_count >= STKTABLE_FILTER_LEN)

return hlua_error(L, "Filter table too large (len > %d)", STKTABLE_FILTER_LEN);

if (lua_type(L, -1) != LUA_TTABLE || lua_rawlen(L, -1) != 3)

return hlua_error(L, "Filter table entry must be a triplet: {\"data_col\", \"op\", val} (entry #%d)", filter_count + 1);

lua_pushnil(L);

while (lua_next(L, -2) != 0) {

switch (entry_idx) {

case 0:

if (lua_type(L, -1) != LUA_TSTRING)

return hlua_error(L, "Filter table data column must be string (entry #%d)", filter_count + 1);

dt = stktable_get_data_type((char *)lua_tostring(L, -1));

if (dt < 0 || t->data_ofs[dt] == 0)

return hlua_error(L, "Filter table data column not present in stick table (entry #%d)", filter_count + 1);

filter[filter_count].type = dt;

break;

case 1:

if (lua_type(L, -1) != LUA_TSTRING)

return hlua_error(L, "Filter table operator must be string (entry #%d)", filter_count + 1);

op = get_std_op(lua_tostring(L, -1));

if (op < 0)

return hlua_error(L, "Unknown operator in filter table (entry #%d)", filter_count + 1);

filter[filter_count].op = op;

break;

case 2:

val = lua_tointeger(L, -1);

filter[filter_count].val = val;

filter_count++;

break;

default:

break;

}

entry_idx++;

lua_pop(L, 1);

}

lua_pop(L, 1);

}

break;

default:

return hlua_error(L, "filter table expected");

}

lua_newtable(L);

HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);

eb = ebmb_first(&t->keys);

for (n = eb; n; n = ebmb_next(n)) {

ts = ebmb_entry(n, struct stksess, key);

if (!ts) {

HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);

return 1;

}

ts->ref_cnt++;

HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);

/* multi condition/value filter */

skip_entry = 0;

for (i = 0; i < filter_count; i++) {

if (t->data_ofs[filter[i].type] == 0)

continue;

ptr = stktable_data_ptr(t, ts, filter[i].type);

switch (stktable_data_types[filter[i].type].std_type) {

case STD_T_SINT:

val = stktable_data_cast(ptr, std_t_sint);

break;

case STD_T_UINT:

val = stktable_data_cast(ptr, std_t_uint);

break;

case STD_T_ULL:

val = stktable_data_cast(ptr, std_t_ull);

break;

case STD_T_FRQP:

val = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp),

t->data_arg[filter[i].type].u);

break;

default:

continue;

break;

}

op = filter[i].op;

if ((val < filter[i].val && (op == STD_OP_EQ || op == STD_OP_GT || op == STD_OP_GE)) ||

(val == filter[i].val && (op == STD_OP_NE || op == STD_OP_GT || op == STD_OP_LT)) ||

(val > filter[i].val && (op == STD_OP_EQ || op == STD_OP_LT || op == STD_OP_LE))) {

skip_entry = 1;

break;

}

}

if (skip_entry) {

HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);

ts->ref_cnt--;

continue;

}

if (t->type == SMP_T_IPV4) {

char addr[INET_ADDRSTRLEN];

inet_ntop(AF_INET, (const void *)&ts->key.key, addr, sizeof(addr));

lua_pushstring(L, addr);

} else if (t->type == SMP_T_IPV6) {

char addr[INET6_ADDRSTRLEN];

inet_ntop(AF_INET6, (const void *)&ts->key.key, addr, sizeof(addr));

lua_pushstring(L, addr);

} else if (t->type == SMP_T_SINT) {

lua_pushinteger(L, *ts->key.key);

} else if (t->type == SMP_T_STR) {

lua_pushstring(L, (const char *)ts->key.key);

} else {

return hlua_error(L, "Unsupported stick table key type");

}

lua_newtable(L);

hlua_stktable_entry(L, t, ts);

lua_settable(L, -3);

HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);

ts->ref_cnt--;

}

HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);

return 1;

}

int hlua_fcn_new_listener(lua_State *L, struct listener *lst)

{

lua_newtable(L);

/* Pop a class sesison metatable and affect it to the userdata. */

lua_rawgeti(L, LUA_REGISTRYINDEX, class_listener_ref);

lua_setmetatable(L, -2);

lua_pushlightuserdata(L, lst);

lua_rawseti(L, -2, 0);

return 1;

}

static struct listener *hlua_check_listener(lua_State *L, int ud)

{

return hlua_checkudata(L, ud, class_listener_ref);

}

int hlua_listener_get_stats(lua_State *L)

{

struct listener *li;

int i;

li = hlua_check_listener(L, 1);

if (!li->bind_conf->frontend) {

lua_pushnil(L);

return 1;

}

stats_fill_li_stats(li->bind_conf->frontend, li, STAT_SHLGNDS, stats, STATS_LEN);

lua_newtable(L);

for (i=0; i<ST_F_TOTAL_FIELDS; i++) {

lua_pushstring(L, stat_fields[i].name);

hlua_fcn_pushfield(L, &stats[i]);

lua_settable(L, -3);

}

return 1;

}

int hlua_fcn_new_server(lua_State *L, struct server *srv)

{

char buffer[12];

lua_newtable(L);

/* Pop a class sesison metatable and affect it to the userdata. */

lua_rawgeti(L, LUA_REGISTRYINDEX, class_server_ref);

lua_setmetatable(L, -2);

lua_pushlightuserdata(L, srv);

lua_rawseti(L, -2, 0);

/* Add server name. */

lua_pushstring(L, "name");

lua_pushstring(L, srv->id);

lua_settable(L, -3);

/* Add server puid. */

lua_pushstring(L, "puid");

snprintf(buffer, sizeof(buffer), "%d", srv->puid);

lua_pushstring(L, buffer);

lua_settable(L, -3);

return 1;

}

static struct server *hlua_check_server(lua_State *L, int ud)

{

return hlua_checkudata(L, ud, class_server_ref);

}

int hlua_server_get_stats(lua_State *L)

{

struct server *srv;

int i;

srv = hlua_check_server(L, 1);

if (!srv->proxy) {

lua_pushnil(L);

return 1;

}

stats_fill_sv_stats(srv->proxy, srv, STAT_SHLGNDS, stats, STATS_LEN);

lua_newtable(L);

for (i=0; i<ST_F_TOTAL_FIELDS; i++) {

lua_pushstring(L, stat_fields[i].name);

hlua_fcn_pushfield(L, &stats[i]);

lua_settable(L, -3);

}

return 1;

}

int hlua_server_get_addr(lua_State *L)

{

struct server *srv;

char addr[INET6_ADDRSTRLEN];

luaL_Buffer b;

srv = hlua_check_server(L, 1);

luaL_buffinit(L, &b);

switch (srv->addr.ss_family) {

case AF_INET:

inet_ntop(AF_INET, &((struct sockaddr_in *)&srv->addr)->sin_addr,

addr, INET_ADDRSTRLEN);

luaL_addstring(&b, addr);

luaL_addstring(&b, ":");

snprintf(addr, INET_ADDRSTRLEN, "%d", srv->svc_port);

luaL_addstring(&b, addr);

break;

case AF_INET6:

inet_ntop(AF_INET6, &((struct sockaddr_in6 *)&srv->addr)->sin6_addr,

addr, INET6_ADDRSTRLEN);

luaL_addstring(&b, addr);

luaL_addstring(&b, ":");

snprintf(addr, INET_ADDRSTRLEN, "%d", srv->svc_port);

luaL_addstring(&b, addr);

break;

case AF_UNIX:

luaL_addstring(&b, (char *)((struct sockaddr_un *)&srv->addr)->sun_path);

break;

default:

luaL_addstring(&b, "<unknown>");

break;

}

luaL_pushresult(&b);

return 1;

}

int hlua_server_is_draining(lua_State *L)

{

struct server *srv;

srv = hlua_check_server(L, 1);

lua_pushinteger(L, server_is_draining(srv));

return 1;

}

int hlua_server_set_maxconn(lua_State *L)

{

struct server *srv;

const char *maxconn;

const char *err;

srv = hlua_check_server(L, 1);

maxconn = luaL_checkstring(L, 2);

HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);

err = server_parse_maxconn_change_request(srv, maxconn);

HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);

if (!err)

lua_pushnil(L);

else

hlua_pushstrippedstring(L, err);

return 1;

}