blob: 8353cd7355499bb4c6376848c08cedc17bdb436d [file] [log] [blame]
Thierry Fourniere726b142016-02-11 17:57:57 +01001/*
2 * Lua safe functions
3 *
4 * Copyright 2015-2016 Thierry Fournier <tfournier@arpalert.org>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 *
12 * All the functions in this file runs with a Lua stack, and can
Thierry Fournierfb0b5462016-01-21 09:28:58 +010013 * return with a longjmp. All of these function must be launched
14 * in an environment able to catch a longjmp, otherwise a
15 * critical error can be raised.
16 */
17#include <lauxlib.h>
18#include <lua.h>
19#include <lualib.h>
20
Thierry Fournierb1f46562016-01-21 09:46:15 +010021#include <common/time.h>
Thierry Fournierf61aa632016-02-19 20:56:00 +010022#include <common/uri_auth.h>
Thierry Fournierb1f46562016-01-21 09:46:15 +010023
William Lallemand9ed62032016-11-21 17:49:11 +010024#include <types/cli.h>
Thierry Fournier49d48422016-02-19 12:09:29 +010025#include <types/hlua.h>
Thierry Fournierf61aa632016-02-19 20:56:00 +010026#include <types/proxy.h>
William Lallemand9ed62032016-11-21 17:49:11 +010027#include <types/stats.h>
Thierry Fournier49d48422016-02-19 12:09:29 +010028
Thierry Fournierf61aa632016-02-19 20:56:00 +010029#include <proto/proxy.h>
30#include <proto/server.h>
William Lallemand9ed62032016-11-21 17:49:11 +010031#include <proto/stats.h>
Adis Nezirovic8878f8e2018-07-13 12:18:33 +020032#include <proto/stick_table.h>
Thierry Fournier94ed1c12016-02-24 08:06:32 +010033
Thierry Fournier1de16592016-01-27 09:49:07 +010034/* Contains the class reference of the concat object. */
35static int class_concat_ref;
Thierry Fournierf61aa632016-02-19 20:56:00 +010036static int class_proxy_ref;
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +010037static int class_server_ref;
Thierry Fournierff480422016-02-25 08:36:46 +010038static int class_listener_ref;
Thierry FOURNIER31904272017-10-25 12:59:51 +020039static int class_regex_ref;
Adis Nezirovic8878f8e2018-07-13 12:18:33 +020040static int class_stktable_ref;
Thierry Fournier1de16592016-01-27 09:49:07 +010041
Adis Nezirovic8878f8e2018-07-13 12:18:33 +020042#define MAX_STK_FILTER_LEN 4
Thierry Fournierf61aa632016-02-19 20:56:00 +010043#define STATS_LEN (MAX((int)ST_F_TOTAL_FIELDS, (int)INF_TOTAL_FIELDS))
Thierry Fourniereea77c02016-03-18 08:47:13 +010044
Thierry FOURNIERffbad792017-07-12 11:39:04 +020045static THREAD_LOCAL struct field stats[STATS_LEN];
Thierry Fourniereea77c02016-03-18 08:47:13 +010046
Thierry FOURNIER / OZON.IO7f3aa8b2016-11-24 20:37:38 +010047int hlua_checkboolean(lua_State *L, int index)
48{
49 if (!lua_isboolean(L, index))
50 luaL_argerror(L, index, "boolean expected");
51 return lua_toboolean(L, index);
52}
53
Adis Nezirovic8878f8e2018-07-13 12:18:33 +020054/* Helper to push unsigned integers to Lua stack, respecting Lua limitations */
55static int hlua_fcn_pushunsigned(lua_State *L, unsigned int val)
56{
57#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))
58 lua_pushinteger(L, val);
59#else
60 if (val > INT_MAX)
61 lua_pushnumber(L, (lua_Number)val);
62 else
63 lua_pushinteger(L, (int)val);
64#endif
65 return 1;
66}
67
68/* Helper to push unsigned long long to Lua stack, respecting Lua limitations */
69static int hlua_fcn_pushunsigned_ll(lua_State *L, unsigned long long val) {
70#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))
71 /* 64 bits case, U64 is supported until LLONG_MAX */
72 if (val > LLONG_MAX)
73 lua_pushnumber(L, (lua_Number)val);
74 else
75 lua_pushinteger(L, val);
76#else
77 /* 32 bits case, U64 is supported until INT_MAX */
78 if (val > INT_MAX)
79 lua_pushnumber(L, (lua_Number)val);
80 else
81 lua_pushinteger(L, (int)val);
82#endif
83 return 1;
84}
85
Joseph Herlantb3d92e32018-11-15 09:35:04 -080086/* This function gets a struct field and converts it in Lua
87 * variable. The variable is pushed at the top of the stack.
Thierry Fournier8b0d6e12016-03-16 18:29:13 +010088 */
89int hlua_fcn_pushfield(lua_State *L, struct field *field)
90{
91 /* The lua_Integer is always signed. Its length depends on
Joseph Herlantb3d92e32018-11-15 09:35:04 -080092 * compilation options, so the following code is conditioned
Thierry Fournier8b0d6e12016-03-16 18:29:13 +010093 * by some macros. Windows maros are not supported.
94 * If the number cannot be represented as integer, we try to
95 * convert to float.
96 */
97 switch (field_format(field, 0)) {
98
99 case FF_EMPTY:
100 lua_pushnil(L);
101 return 1;
102
103 case FF_S32:
104 /* S32 is always supported. */
105 lua_pushinteger(L, field->u.s32);
106 return 1;
107
108 case FF_U32:
109#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))
110 /* 64 bits case, U32 is always supported */
111 lua_pushinteger(L, field->u.u32);
112#else
113 /* 32 bits case, U32 is supported until INT_MAX. */
114 if (field->u.u32 > INT_MAX)
115 lua_pushnumber(L, (lua_Number)field->u.u32);
116 else
117 lua_pushinteger(L, field->u.u32);
118#endif
119 return 1;
120
121 case FF_S64:
122#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))
123 /* 64 bits case, S64 is always supported */
124 lua_pushinteger(L, field->u.s64);
125#else
126 /* 64 bits case, S64 is supported beetween INT_MIN and INT_MAX */
127 if (field->u.s64 < INT_MIN || field->u.s64 > INT_MAX)
128 lua_pushnumber(L, (lua_Number)field->u.s64);
129 else
130 lua_pushinteger(L, (int)field->u.s64);
131#endif
132 return 1;
133
134 case FF_U64:
135#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))
136 /* 64 bits case, U64 is supported until LLONG_MAX */
137 if (field->u.u64 > LLONG_MAX)
138 lua_pushnumber(L, (lua_Number)field->u.u64);
139 else
140 lua_pushinteger(L, field->u.u64);
141#else
142 /* 64 bits case, U64 is supported until INT_MAX */
143 if (field->u.u64 > INT_MAX)
144 lua_pushnumber(L, (lua_Number)field->u.u64);
145 else
146 lua_pushinteger(L, (int)field->u.u64);
147#endif
148 return 1;
149
150 case FF_STR:
151 lua_pushstring(L, field->u.str);
152 return 1;
153
154 default:
155 break;
156 }
157
158 /* Default case, never reached. */
159 lua_pushnil(L);
160 return 1;
161}
162
Thierry Fournier94ed1c12016-02-24 08:06:32 +0100163/* Some string are started or terminated by blank chars,
164 * this function removes the spaces, tabs, \r and
165 * \n at the begin and at the end of the string "str", and
166 * push the result in the lua stack.
167 * Returns a pointer to the Lua internal copy of the string.
168 */
169const char *hlua_pushstrippedstring(lua_State *L, const char *str)
170{
171 const char *p;
172 const char *e;
173
174 for (p = str; HTTP_IS_LWS(*p); p++);
175 for (e = p + strlen(p) - 1; e > p && HTTP_IS_LWS(*e); e--);
176
177 return lua_pushlstring(L, p, e - p);
178}
179
Thierry Fournierddd89882016-02-22 19:52:08 +0100180/* The three following functions are useful for adding entries
181 * in a table. These functions takes a string and respectively an
182 * integer, a string or a function and add it to the table in the
183 * top of the stack.
184 *
185 * These functions throws an error if no more stack size is
186 * available.
187 */
188void hlua_class_const_int(lua_State *L, const char *name, int value)
189{
Thierry Fournierddd89882016-02-22 19:52:08 +0100190 lua_pushstring(L, name);
191 lua_pushinteger(L, value);
192 lua_rawset(L, -3);
193}
194void hlua_class_const_str(lua_State *L, const char *name, const char *value)
195{
Thierry Fournierddd89882016-02-22 19:52:08 +0100196 lua_pushstring(L, name);
197 lua_pushstring(L, value);
198 lua_rawset(L, -3);
199}
200void hlua_class_function(lua_State *L, const char *name, int (*function)(lua_State *L))
201{
Thierry Fournierddd89882016-02-22 19:52:08 +0100202 lua_pushstring(L, name);
203 lua_pushcclosure(L, function, 0);
204 lua_rawset(L, -3);
205}
206
Joseph Herlantb3d92e32018-11-15 09:35:04 -0800207/* This function returns a string containing the HAProxy object name. */
Thierry Fournierddd89882016-02-22 19:52:08 +0100208int hlua_dump_object(struct lua_State *L)
209{
210 const char *name = (const char *)lua_tostring(L, lua_upvalueindex(1));
211 lua_pushfstring(L, "HAProxy class %s", name);
212 return 1;
213}
214
Thierry Fournier45e78d72016-02-19 18:34:46 +0100215/* This function register a table as metatable and. It names
216 * the metatable, and returns the associated reference.
217 * The original table is poped from the top of the stack.
218 * "name" is the referenced class name.
219 */
220int hlua_register_metatable(struct lua_State *L, char *name)
221{
222 /* Check the type of the top element. it must be
223 * a table.
224 */
225 if (lua_type(L, -1) != LUA_TTABLE)
226 luaL_error(L, "hlua_register_metatable() requires a type Table "
227 "in the top of the stack");
228
229 /* Add the __tostring function which identify the
230 * created object.
231 */
232 lua_pushstring(L, "__tostring");
233 lua_pushstring(L, name);
234 lua_pushcclosure(L, hlua_dump_object, 1);
235 lua_rawset(L, -3);
236
237 /* Register a named entry for the table. The table
238 * reference is copyed first because the function
239 * lua_setfield() pop the entry.
240 */
241 lua_pushvalue(L, -1);
242 lua_setfield(L, LUA_REGISTRYINDEX, name);
243
244 /* Creates the reference of the object. The
245 * function luaL_ref pop the top of the stack.
246 */
247 return luaL_ref(L, LUA_REGISTRYINDEX);
248}
249
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100250/* Return an object of the expected type, or throws an error. */
251void *hlua_checkudata(lua_State *L, int ud, int class_ref)
252{
253 void *p;
Thierry Fournier53518272016-01-27 10:34:09 +0100254 int ret;
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100255
256 /* Check if the stack entry is an array. */
257 if (!lua_istable(L, ud))
Thierry Fournier53518272016-01-27 10:34:09 +0100258 luaL_argerror(L, ud, NULL);
259
260 /* pop the metatable of the referencecd object. */
261 if (!lua_getmetatable(L, ud))
262 luaL_argerror(L, ud, NULL);
263
264 /* pop the expected metatable. */
265 lua_rawgeti(L, LUA_REGISTRYINDEX, class_ref);
266
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100267 /* Check if the metadata have the expected type. */
Thierry Fournier53518272016-01-27 10:34:09 +0100268 ret = lua_rawequal(L, -1, -2);
269 lua_pop(L, 2);
270 if (!ret)
271 luaL_argerror(L, ud, NULL);
272
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100273 /* Push on the stack at the entry [0] of the table. */
274 lua_rawgeti(L, ud, 0);
Thierry Fournier53518272016-01-27 10:34:09 +0100275
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100276 /* Check if this entry is userdata. */
277 p = lua_touserdata(L, -1);
278 if (!p)
Thierry Fournier53518272016-01-27 10:34:09 +0100279 luaL_argerror(L, ud, NULL);
280
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100281 /* Remove the entry returned by lua_rawgeti(). */
282 lua_pop(L, 1);
Thierry Fournier53518272016-01-27 10:34:09 +0100283
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100284 /* Return the associated struct. */
285 return p;
286}
287
Thierry Fournierb1f46562016-01-21 09:46:15 +0100288/* This function return the current date at epoch format in milliseconds. */
289int hlua_now(lua_State *L)
290{
291 lua_newtable(L);
292 lua_pushstring(L, "sec");
293 lua_pushinteger(L, now.tv_sec);
294 lua_rawset(L, -3);
295 lua_pushstring(L, "usec");
296 lua_pushinteger(L, now.tv_usec);
297 lua_rawset(L, -3);
298 return 1;
299}
300
Thierry Fournier1550d5d2016-01-21 09:35:41 +0100301/* This functions expects a Lua string as HTTP date, parse it and
302 * returns an integer containing the epoch format of the date, or
303 * nil if the parsing fails.
304 */
305static int hlua_parse_date(lua_State *L, int (*fcn)(const char *, int, struct tm*))
306{
307 const char *str;
308 size_t len;
309 struct tm tm;
310 time_t time;
311
312 str = luaL_checklstring(L, 1, &len);
313
314 if (!fcn(str, len, &tm)) {
315 lua_pushnil(L);
316 return 1;
317 }
318
319 /* This function considers the content of the broken-down time
320 * is exprimed in the UTC timezone. timegm don't care about
321 * the gnu variable tm_gmtoff. If gmtoff is set, or if you know
322 * the timezone from the broken-down time, it must be fixed
323 * after the conversion.
324 */
Willy Tarreauabd9bb22017-07-19 19:08:48 +0200325 time = my_timegm(&tm);
Thierry Fournier1550d5d2016-01-21 09:35:41 +0100326 if (time == -1) {
327 lua_pushnil(L);
328 return 1;
329 }
330
331 lua_pushinteger(L, (int)time);
332 return 1;
333}
334static int hlua_http_date(lua_State *L)
335{
336 return hlua_parse_date(L, parse_http_date);
337}
338static int hlua_imf_date(lua_State *L)
339{
340 return hlua_parse_date(L, parse_imf_date);
341}
342static int hlua_rfc850_date(lua_State *L)
343{
344 return hlua_parse_date(L, parse_rfc850_date);
345}
346static int hlua_asctime_date(lua_State *L)
347{
348 return hlua_parse_date(L, parse_asctime_date);
349}
350
Thierry Fourniereea77c02016-03-18 08:47:13 +0100351static int hlua_get_info(lua_State *L)
352{
353 int i;
354
355 stats_fill_info(stats, STATS_LEN);
356
357 lua_newtable(L);
358 for (i=0; i<INF_TOTAL_FIELDS; i++) {
359 lua_pushstring(L, info_field_names[i]);
360 hlua_fcn_pushfield(L, &stats[i]);
361 lua_settable(L, -3);
362 }
363 return 1;
364}
365
Thierry Fournier49d48422016-02-19 12:09:29 +0100366static struct hlua_concat *hlua_check_concat(lua_State *L, int ud)
Thierry Fournier1de16592016-01-27 09:49:07 +0100367{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200368 return (hlua_checkudata(L, ud, class_concat_ref));
Thierry Fournier1de16592016-01-27 09:49:07 +0100369}
370
371static int hlua_concat_add(lua_State *L)
372{
Thierry Fournier49d48422016-02-19 12:09:29 +0100373 struct hlua_concat *b;
374 char *buffer;
375 char *new;
Thierry Fournier1de16592016-01-27 09:49:07 +0100376 const char *str;
377 size_t l;
378
379 /* First arg must be a concat object. */
380 b = hlua_check_concat(L, 1);
381
382 /* Second arg must be a string. */
383 str = luaL_checklstring(L, 2, &l);
384
Thierry Fournier49d48422016-02-19 12:09:29 +0100385 /* Get the buffer. */
386 lua_rawgeti(L, 1, 1);
387 buffer = lua_touserdata(L, -1);
388 lua_pop(L, 1);
389
390 /* Update the buffer size if it s required. The old buffer
391 * is crushed by the new in the object array, so it will
392 * be deleted by the GC.
393 * Note that in the first loop, the "new" variable is only
394 * used as a flag.
395 */
396 new = NULL;
397 while (b->size - b->len < l) {
398 b->size += HLUA_CONCAT_BLOCSZ;
399 new = buffer;
400 }
401 if (new) {
402 new = lua_newuserdata(L, b->size);
403 memcpy(new, buffer, b->len);
404 lua_rawseti(L, 1, 1);
405 buffer = new;
406 }
407
408 /* Copy string, and update metadata. */
409 memcpy(buffer + b->len, str, l);
410 b->len += l;
Thierry Fournier1de16592016-01-27 09:49:07 +0100411 return 0;
412}
413
414static int hlua_concat_dump(lua_State *L)
415{
Thierry Fournier49d48422016-02-19 12:09:29 +0100416 struct hlua_concat *b;
417 char *buffer;
Thierry Fournier1de16592016-01-27 09:49:07 +0100418
419 /* First arg must be a concat object. */
420 b = hlua_check_concat(L, 1);
421
Thierry Fournier49d48422016-02-19 12:09:29 +0100422 /* Get the buffer. */
423 lua_rawgeti(L, 1, 1);
424 buffer = lua_touserdata(L, -1);
425 lua_pop(L, 1);
426
Thierry Fournier1de16592016-01-27 09:49:07 +0100427 /* Push the soncatenated strng in the stack. */
Thierry Fournier49d48422016-02-19 12:09:29 +0100428 lua_pushlstring(L, buffer, b->len);
Thierry Fournier1de16592016-01-27 09:49:07 +0100429 return 1;
430}
431
432int hlua_concat_new(lua_State *L)
433{
Thierry Fournier49d48422016-02-19 12:09:29 +0100434 struct hlua_concat *b;
Thierry Fournier1de16592016-01-27 09:49:07 +0100435
436 lua_newtable(L);
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200437 b = lua_newuserdata(L, sizeof(*b));
Thierry Fournier49d48422016-02-19 12:09:29 +0100438 b->size = HLUA_CONCAT_BLOCSZ;
439 b->len = 0;
Thierry Fournier1de16592016-01-27 09:49:07 +0100440 lua_rawseti(L, -2, 0);
Thierry Fournier49d48422016-02-19 12:09:29 +0100441 lua_newuserdata(L, HLUA_CONCAT_BLOCSZ);
442 lua_rawseti(L, -2, 1);
Thierry Fournier1de16592016-01-27 09:49:07 +0100443
444 lua_rawgeti(L, LUA_REGISTRYINDEX, class_concat_ref);
445 lua_setmetatable(L, -2);
446
Thierry Fournier1de16592016-01-27 09:49:07 +0100447 return 1;
448}
449
450static int concat_tostring(lua_State *L)
451{
452 const void *ptr = lua_topointer(L, 1);
453 lua_pushfstring(L, "Concat object: %p", ptr);
454 return 1;
455}
456
457static int hlua_concat_init(lua_State *L)
458{
459 /* Creates the buffered concat object. */
460 lua_newtable(L);
461
462 lua_pushstring(L, "__tostring");
463 lua_pushcclosure(L, concat_tostring, 0);
464 lua_settable(L, -3);
465
466 lua_pushstring(L, "__index"); /* Creates the index entry. */
467 lua_newtable(L); /* The "__index" content. */
468
469 lua_pushstring(L, "add");
470 lua_pushcclosure(L, hlua_concat_add, 0);
471 lua_settable(L, -3);
472
473 lua_pushstring(L, "dump");
474 lua_pushcclosure(L, hlua_concat_dump, 0);
475 lua_settable(L, -3);
476
477 lua_settable(L, -3); /* Sets the __index entry. */
478 class_concat_ref = luaL_ref(L, LUA_REGISTRYINDEX);
479
480 return 1;
481}
482
Adis Nezirovic8878f8e2018-07-13 12:18:33 +0200483int hlua_fcn_new_stktable(lua_State *L, struct stktable *tbl)
484{
485 lua_newtable(L);
486
487 /* Pop a class stktbl metatable and affect it to the userdata. */
488 lua_rawgeti(L, LUA_REGISTRYINDEX, class_stktable_ref);
489 lua_setmetatable(L, -2);
490
491 lua_pushlightuserdata(L, tbl);
492 lua_rawseti(L, -2, 0);
493 return 1;
494}
495
496static struct stktable *hlua_check_stktable(lua_State *L, int ud)
497{
498 return hlua_checkudata(L, ud, class_stktable_ref);
499}
500
501/* Extract stick table attributes into Lua table */
502int hlua_stktable_info(lua_State *L)
503{
504 struct stktable *tbl;
505 int dt;
506
507 tbl = hlua_check_stktable(L, 1);
508
509 if (!tbl->id) {
510 lua_pushnil(L);
511 return 1;
512 }
513
514 lua_newtable(L);
515
516 lua_pushstring(L, "type");
517 lua_pushstring(L, stktable_types[tbl->type].kw);
518 lua_settable(L, -3);
519
520 lua_pushstring(L, "length");
521 lua_pushinteger(L, tbl->key_size);
522 lua_settable(L, -3);
523
524 lua_pushstring(L, "size");
525 hlua_fcn_pushunsigned(L, tbl->size);
526 lua_settable(L, -3);
527
528 lua_pushstring(L, "used");
529 hlua_fcn_pushunsigned(L, tbl->current);
530 lua_settable(L, -3);
531
532 lua_pushstring(L, "nopurge");
533 lua_pushboolean(L, tbl->nopurge > 0);
534 lua_settable(L, -3);
535
536 lua_pushstring(L, "expire");
537 lua_pushinteger(L, tbl->expire);
538 lua_settable(L, -3);
539
540 /* Save data types periods (if applicable) in 'data' table */
541 lua_pushstring(L, "data");
542 lua_newtable(L);
543
544 for (dt = 0; dt < STKTABLE_DATA_TYPES; dt++) {
545 if (tbl->data_ofs[dt] == 0)
546 continue;
547
548 lua_pushstring(L, stktable_data_types[dt].name);
549
550 if (stktable_data_types[dt].arg_type == ARG_T_DELAY)
551 lua_pushinteger(L, tbl->data_arg[dt].u);
552 else
553 lua_pushinteger(L, -1);
554
555 lua_settable(L, -3);
556 }
557
558 lua_settable(L, -3);
559
560 return 1;
561}
562
563/* Helper to get extract stick table entry into Lua table */
564static void hlua_stktable_entry(lua_State *L, struct stktable *t, struct stksess *ts)
565{
566 int dt;
567 void *ptr;
568
569 for (dt = 0; dt < STKTABLE_DATA_TYPES; dt++) {
570
571 if (t->data_ofs[dt] == 0)
572 continue;
573
574 lua_pushstring(L, stktable_data_types[dt].name);
575
576 ptr = stktable_data_ptr(t, ts, dt);
577 switch (stktable_data_types[dt].std_type) {
578 case STD_T_SINT:
579 lua_pushinteger(L, stktable_data_cast(ptr, std_t_sint));
580 break;
581 case STD_T_UINT:
582 hlua_fcn_pushunsigned(L, stktable_data_cast(ptr, std_t_uint));
583 break;
584 case STD_T_ULL:
585 hlua_fcn_pushunsigned_ll(L, stktable_data_cast(ptr, std_t_ull));
586 break;
587 case STD_T_FRQP:
588 lua_pushinteger(L, read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp),
589 t->data_arg[dt].u));
590 break;
Adis Neziroviceafb2b12020-05-05 13:57:28 +0200591 case STD_T_DICT: {
592 struct dict_entry *de;
593 de = stktable_data_cast(ptr, std_t_dict);
594 lua_pushstring(L, de ? (char *)de->value.key : "-");
595 break;
596 }
Adis Nezirovic8878f8e2018-07-13 12:18:33 +0200597 }
598
599 lua_settable(L, -3);
600 }
601}
602
603/* Looks in table <t> for a sticky session matching key <key>
604 * Returns table with session data or nil
605 *
606 * The returned table always contains 'use' and 'expire' (integer) fields.
607 * For frequency/rate counters, each data entry is returned as table with
608 * 'value' and 'period' fields.
609 */
610int hlua_stktable_lookup(lua_State *L)
611{
612 struct stktable *t;
613 struct sample smp;
614 struct stktable_key *skey;
615 struct stksess *ts;
616
617 t = hlua_check_stktable(L, 1);
618 smp.data.type = SMP_T_STR;
619 smp.flags = SMP_F_CONST;
620 smp.data.u.str.area = (char *)luaL_checkstring(L, 2);
621
622 skey = smp_to_stkey(&smp, t);
623 if (!skey) {
624 lua_pushnil(L);
625 return 1;
626 }
627
628 ts = stktable_lookup_key(t, skey);
629 if (!ts) {
630 lua_pushnil(L);
631 return 1;
632 }
633
634 lua_newtable(L);
635 lua_pushstring(L, "use");
636 lua_pushinteger(L, ts->ref_cnt - 1);
637 lua_settable(L, -3);
638
639 lua_pushstring(L, "expire");
640 lua_pushinteger(L, tick_remain(now_ms, ts->expire));
641 lua_settable(L, -3);
642
643 hlua_stktable_entry(L, t, ts);
644 HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
645 ts->ref_cnt--;
646 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
647
648 return 1;
649}
650
651struct stk_filter {
652 long long val;
653 int type;
654 int op;
655};
656
657
658/* Helper for returning errors to callers using Lua convention (nil, err) */
659static int hlua_error(lua_State *L, const char *fmt, ...) {
660 char buf[256];
661 int len;
662 va_list args;
663 va_start(args, fmt);
664 len = vsnprintf(buf, sizeof(buf), fmt, args);
665 va_end(args);
666
667 if (len < 0) {
668 ha_alert("hlua_error(): Could not write error message.\n");
669 lua_pushnil(L);
670 return 1;
671 } else if (len >= sizeof(buf))
672 ha_alert("hlua_error(): Error message was truncated.\n");
673
674 lua_pushnil(L);
675 lua_pushstring(L, buf);
676
677 return 2;
678}
679
680/* Dump the contents of stick table <t>*/
681int hlua_stktable_dump(lua_State *L)
682{
683 struct stktable *t;
684 struct ebmb_node *eb;
685 struct ebmb_node *n;
686 struct stksess *ts;
687 int type;
688 int op;
689 int dt;
690 long long val;
691 struct stk_filter filter[MAX_STK_FILTER_LEN];
692 int filter_count = 0;
693 int i;
694 int skip_entry;
695 void *ptr;
696
697 t = hlua_check_stktable(L, 1);
698 type = lua_type(L, 2);
699
700 switch (type) {
701 case LUA_TNONE:
702 case LUA_TNIL:
703 break;
704 case LUA_TTABLE:
705 lua_pushnil(L);
706 while (lua_next(L, 2) != 0) {
707 int entry_idx = 0;
708
709 if (filter_count >= MAX_STK_FILTER_LEN)
710 return hlua_error(L, "Filter table too large (len > %d)", MAX_STK_FILTER_LEN);
711
712 if (lua_type(L, -1) != LUA_TTABLE || lua_rawlen(L, -1) != 3)
713 return hlua_error(L, "Filter table entry must be a triplet: {\"data_col\", \"op\", val} (entry #%d)", filter_count + 1);
714
715 lua_pushnil(L);
716 while (lua_next(L, -2) != 0) {
717 switch (entry_idx) {
718 case 0:
719 if (lua_type(L, -1) != LUA_TSTRING)
720 return hlua_error(L, "Filter table data column must be string (entry #%d)", filter_count + 1);
721
722 dt = stktable_get_data_type((char *)lua_tostring(L, -1));
723 if (dt < 0 || t->data_ofs[dt] == 0)
724 return hlua_error(L, "Filter table data column not present in stick table (entry #%d)", filter_count + 1);
725 filter[filter_count].type = dt;
726 break;
727 case 1:
728 if (lua_type(L, -1) != LUA_TSTRING)
729 return hlua_error(L, "Filter table operator must be string (entry #%d)", filter_count + 1);
730
731 op = get_std_op(lua_tostring(L, -1));
732 if (op < 0)
733 return hlua_error(L, "Unknown operator in filter table (entry #%d)", filter_count + 1);
734 filter[filter_count].op = op;
735 break;
736 case 2:
737 val = lua_tointeger(L, -1);
738 filter[filter_count].val = val;
739 filter_count++;
740 break;
741 default:
742 break;
743 }
744 entry_idx++;
745 lua_pop(L, 1);
746 }
747 lua_pop(L, 1);
748 }
749 break;
750 default:
751 return hlua_error(L, "filter table expected");
752 }
753
754 lua_newtable(L);
755
756 HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
757 eb = ebmb_first(&t->keys);
758 for (n = eb; n; n = ebmb_next(n)) {
759 ts = ebmb_entry(n, struct stksess, key);
760 if (!ts) {
761 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
762 return 1;
763 }
764 ts->ref_cnt++;
765 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
766
767 /* multi condition/value filter */
768 skip_entry = 0;
769 for (i = 0; i < filter_count; i++) {
770 if (t->data_ofs[filter[i].type] == 0)
771 continue;
772
773 ptr = stktable_data_ptr(t, ts, filter[i].type);
774
775 switch (stktable_data_types[filter[i].type].std_type) {
776 case STD_T_SINT:
777 val = stktable_data_cast(ptr, std_t_sint);
778 break;
779 case STD_T_UINT:
780 val = stktable_data_cast(ptr, std_t_uint);
781 break;
782 case STD_T_ULL:
783 val = stktable_data_cast(ptr, std_t_ull);
784 break;
785 case STD_T_FRQP:
786 val = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp),
787 t->data_arg[filter[i].type].u);
788 break;
789 default:
790 continue;
791 break;
792 }
793
794 op = filter[i].op;
795
796 if ((val < filter[i].val && (op == STD_OP_EQ || op == STD_OP_GT || op == STD_OP_GE)) ||
797 (val == filter[i].val && (op == STD_OP_NE || op == STD_OP_GT || op == STD_OP_LT)) ||
798 (val > filter[i].val && (op == STD_OP_EQ || op == STD_OP_LT || op == STD_OP_LE))) {
799 skip_entry = 1;
800 break;
801 }
802 }
803
804 if (skip_entry) {
805 HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
806 ts->ref_cnt--;
807 continue;
808 }
809
810 if (t->type == SMP_T_IPV4) {
811 char addr[INET_ADDRSTRLEN];
812 inet_ntop(AF_INET, (const void *)&ts->key.key, addr, sizeof(addr));
813 lua_pushstring(L, addr);
814 } else if (t->type == SMP_T_IPV6) {
815 char addr[INET6_ADDRSTRLEN];
816 inet_ntop(AF_INET6, (const void *)&ts->key.key, addr, sizeof(addr));
817 lua_pushstring(L, addr);
818 } else if (t->type == SMP_T_SINT) {
819 lua_pushinteger(L, *ts->key.key);
820 } else if (t->type == SMP_T_STR) {
821 lua_pushstring(L, (const char *)ts->key.key);
822 } else {
823 return hlua_error(L, "Unsupported stick table key type");
824 }
825
826 lua_newtable(L);
827 hlua_stktable_entry(L, t, ts);
828 lua_settable(L, -3);
829 HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
830 ts->ref_cnt--;
831 }
832 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
833
834 return 1;
835}
836
Thierry Fournierff480422016-02-25 08:36:46 +0100837int hlua_fcn_new_listener(lua_State *L, struct listener *lst)
838{
839 lua_newtable(L);
840
841 /* Pop a class sesison metatable and affect it to the userdata. */
842 lua_rawgeti(L, LUA_REGISTRYINDEX, class_listener_ref);
843 lua_setmetatable(L, -2);
844
845 lua_pushlightuserdata(L, lst);
846 lua_rawseti(L, -2, 0);
847 return 1;
848}
849
850static struct listener *hlua_check_listener(lua_State *L, int ud)
851{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200852 return hlua_checkudata(L, ud, class_listener_ref);
Thierry Fournierff480422016-02-25 08:36:46 +0100853}
854
855int hlua_listener_get_stats(lua_State *L)
856{
857 struct listener *li;
858 int i;
859
860 li = hlua_check_listener(L, 1);
861
Willy Tarreauc95bad52016-12-22 00:13:31 +0100862 if (!li->bind_conf->frontend) {
Thierry Fournierff480422016-02-25 08:36:46 +0100863 lua_pushnil(L);
864 return 1;
865 }
866
Willy Tarreauc95bad52016-12-22 00:13:31 +0100867 stats_fill_li_stats(li->bind_conf->frontend, li, ST_SHLGNDS, stats, STATS_LEN);
Thierry Fournierff480422016-02-25 08:36:46 +0100868
869 lua_newtable(L);
870 for (i=0; i<ST_F_TOTAL_FIELDS; i++) {
871 lua_pushstring(L, stat_field_names[i]);
872 hlua_fcn_pushfield(L, &stats[i]);
873 lua_settable(L, -3);
874 }
875 return 1;
876
877}
878
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100879int hlua_fcn_new_server(lua_State *L, struct server *srv)
880{
Patrick Hemmera62ae7e2018-04-29 14:23:48 -0400881 char buffer[12];
882
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100883 lua_newtable(L);
884
885 /* Pop a class sesison metatable and affect it to the userdata. */
886 lua_rawgeti(L, LUA_REGISTRYINDEX, class_server_ref);
887 lua_setmetatable(L, -2);
888
889 lua_pushlightuserdata(L, srv);
890 lua_rawseti(L, -2, 0);
Patrick Hemmera62ae7e2018-04-29 14:23:48 -0400891
892 /* Add server name. */
893 lua_pushstring(L, "name");
894 lua_pushstring(L, srv->id);
895 lua_settable(L, -3);
896
897 /* Add server puid. */
898 lua_pushstring(L, "puid");
899 snprintf(buffer, sizeof(buffer), "%d", srv->puid);
900 lua_pushstring(L, buffer);
901 lua_settable(L, -3);
902
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100903 return 1;
904}
905
906static struct server *hlua_check_server(lua_State *L, int ud)
907{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200908 return hlua_checkudata(L, ud, class_server_ref);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100909}
910
911int hlua_server_get_stats(lua_State *L)
912{
913 struct server *srv;
914 int i;
915
916 srv = hlua_check_server(L, 1);
917
918 if (!srv->proxy) {
919 lua_pushnil(L);
920 return 1;
921 }
922
923 stats_fill_sv_stats(srv->proxy, srv, ST_SHLGNDS, stats, STATS_LEN);
924
925 lua_newtable(L);
926 for (i=0; i<ST_F_TOTAL_FIELDS; i++) {
927 lua_pushstring(L, stat_field_names[i]);
928 hlua_fcn_pushfield(L, &stats[i]);
929 lua_settable(L, -3);
930 }
931 return 1;
932
933}
934
935int hlua_server_get_addr(lua_State *L)
936{
937 struct server *srv;
938 char addr[INET6_ADDRSTRLEN];
939 luaL_Buffer b;
940
941 srv = hlua_check_server(L, 1);
942
943 luaL_buffinit(L, &b);
944
945 switch (srv->addr.ss_family) {
946 case AF_INET:
947 inet_ntop(AF_INET, &((struct sockaddr_in *)&srv->addr)->sin_addr,
948 addr, INET_ADDRSTRLEN);
949 luaL_addstring(&b, addr);
950 luaL_addstring(&b, ":");
Nenad Merdanovic38494732017-07-23 22:04:58 -0400951 snprintf(addr, INET_ADDRSTRLEN, "%d", srv->svc_port);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100952 luaL_addstring(&b, addr);
953 break;
954 case AF_INET6:
955 inet_ntop(AF_INET6, &((struct sockaddr_in6 *)&srv->addr)->sin6_addr,
Nenad Merdanovica9f04042017-07-23 22:04:59 -0400956 addr, INET6_ADDRSTRLEN);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100957 luaL_addstring(&b, addr);
958 luaL_addstring(&b, ":");
Nenad Merdanovic38494732017-07-23 22:04:58 -0400959 snprintf(addr, INET_ADDRSTRLEN, "%d", srv->svc_port);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100960 luaL_addstring(&b, addr);
961 break;
962 case AF_UNIX:
963 luaL_addstring(&b, (char *)((struct sockaddr_un *)&srv->addr)->sun_path);
964 break;
965 default:
966 luaL_addstring(&b, "<unknown>");
967 break;
968 }
969
970 luaL_pushresult(&b);
971 return 1;
972}
973
974int hlua_server_is_draining(lua_State *L)
975{
976 struct server *srv;
977
978 srv = hlua_check_server(L, 1);
979 lua_pushinteger(L, server_is_draining(srv));
980 return 1;
981}
982
Patrick Hemmer32d539f2018-04-29 14:25:46 -0400983int hlua_server_set_maxconn(lua_State *L)
984{
985 struct server *srv;
986 const char *maxconn;
987 const char *err;
988
989 srv = hlua_check_server(L, 1);
990 maxconn = luaL_checkstring(L, 2);
991
992 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
993 err = server_parse_maxconn_change_request(srv, maxconn);
994 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
995 if (!err)
996 lua_pushnil(L);
997 else
998 hlua_pushstrippedstring(L, err);
999 return 1;
1000}
1001
1002int hlua_server_get_maxconn(lua_State *L)
1003{
1004 struct server *srv;
1005
1006 srv = hlua_check_server(L, 1);
1007 lua_pushinteger(L, srv->maxconn);
1008 return 1;
1009}
1010
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001011int hlua_server_set_weight(lua_State *L)
1012{
1013 struct server *srv;
1014 const char *weight;
1015 const char *err;
1016
1017 srv = hlua_check_server(L, 1);
1018 weight = luaL_checkstring(L, 2);
1019
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001020 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001021 err = server_parse_weight_change_request(srv, weight);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001022 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001023 if (!err)
1024 lua_pushnil(L);
1025 else
1026 hlua_pushstrippedstring(L, err);
1027 return 1;
1028}
1029
1030int hlua_server_get_weight(lua_State *L)
1031{
1032 struct server *srv;
1033
1034 srv = hlua_check_server(L, 1);
1035 lua_pushinteger(L, srv->uweight);
1036 return 1;
1037}
1038
1039int hlua_server_set_addr(lua_State *L)
1040{
1041 struct server *srv;
1042 const char *addr;
1043 const char *err;
1044
1045 srv = hlua_check_server(L, 1);
1046 addr = luaL_checkstring(L, 2);
1047
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001048 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001049 err = server_parse_addr_change_request(srv, addr, "Lua script");
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001050 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001051 if (!err)
1052 lua_pushnil(L);
1053 else
1054 hlua_pushstrippedstring(L, err);
1055 return 1;
1056}
1057
1058int hlua_server_shut_sess(lua_State *L)
1059{
1060 struct server *srv;
1061
1062 srv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001063 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001064 srv_shutdown_streams(srv, SF_ERR_KILLED);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001065 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001066 return 0;
1067}
1068
1069int hlua_server_set_drain(lua_State *L)
1070{
1071 struct server *srv;
1072
1073 srv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001074 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001075 srv_adm_set_drain(srv);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001076 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001077 return 0;
1078}
1079
1080int hlua_server_set_maint(lua_State *L)
1081{
1082 struct server *srv;
1083
1084 srv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001085 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001086 srv_adm_set_maint(srv);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001087 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001088 return 0;
1089}
1090
1091int hlua_server_set_ready(lua_State *L)
1092{
1093 struct server *srv;
1094
1095 srv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001096 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001097 srv_adm_set_ready(srv);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001098 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001099 return 0;
1100}
1101
1102int hlua_server_check_enable(lua_State *L)
1103{
1104 struct server *sv;
1105
1106 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001107 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001108 if (sv->check.state & CHK_ST_CONFIGURED) {
Adis Nezirovicceee9332017-07-26 09:19:06 +02001109 sv->check.state |= CHK_ST_ENABLED;
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001110 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001111 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001112 return 0;
1113}
1114
1115int hlua_server_check_disable(lua_State *L)
1116{
1117 struct server *sv;
1118
1119 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001120 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001121 if (sv->check.state & CHK_ST_CONFIGURED) {
Adis Nezirovicceee9332017-07-26 09:19:06 +02001122 sv->check.state &= ~CHK_ST_ENABLED;
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001123 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001124 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001125 return 0;
1126}
1127
1128int hlua_server_check_force_up(lua_State *L)
1129{
1130 struct server *sv;
1131
1132 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001133 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001134 if (!(sv->track)) {
1135 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02001136 srv_set_running(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001137 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001138 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001139 return 0;
1140}
1141
1142int hlua_server_check_force_nolb(lua_State *L)
1143{
1144 struct server *sv;
1145
1146 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001147 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001148 if (!(sv->track)) {
1149 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02001150 srv_set_stopping(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001151 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001152 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001153 return 0;
1154}
1155
1156int hlua_server_check_force_down(lua_State *L)
1157{
1158 struct server *sv;
1159
1160 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001161 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001162 if (!(sv->track)) {
1163 sv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02001164 srv_set_stopped(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001165 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001166 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001167 return 0;
1168}
1169
1170int hlua_server_agent_enable(lua_State *L)
1171{
1172 struct server *sv;
1173
1174 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001175 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001176 if (sv->agent.state & CHK_ST_CONFIGURED) {
1177 sv->agent.state |= CHK_ST_ENABLED;
1178 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001179 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001180 return 0;
1181}
1182
1183int hlua_server_agent_disable(lua_State *L)
1184{
1185 struct server *sv;
1186
1187 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001188 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001189 if (sv->agent.state & CHK_ST_CONFIGURED) {
1190 sv->agent.state &= ~CHK_ST_ENABLED;
1191 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001192 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001193 return 0;
1194}
1195
1196int hlua_server_agent_force_up(lua_State *L)
1197{
1198 struct server *sv;
1199
1200 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001201 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001202 if (sv->agent.state & CHK_ST_ENABLED) {
1203 sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02001204 srv_set_running(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001205 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001206 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001207 return 0;
1208}
1209
1210int hlua_server_agent_force_down(lua_State *L)
1211{
1212 struct server *sv;
1213
1214 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001215 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001216 if (sv->agent.state & CHK_ST_ENABLED) {
1217 sv->agent.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02001218 srv_set_stopped(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001219 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001220 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001221 return 0;
1222}
1223
Thierry Fournierf61aa632016-02-19 20:56:00 +01001224int hlua_fcn_new_proxy(lua_State *L, struct proxy *px)
1225{
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001226 struct server *srv;
Thierry Fournierff480422016-02-25 08:36:46 +01001227 struct listener *lst;
1228 int lid;
Willy Tarreau29d69802018-05-06 14:50:09 +02001229 char buffer[17];
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001230
Thierry Fournierf61aa632016-02-19 20:56:00 +01001231 lua_newtable(L);
1232
1233 /* Pop a class sesison metatable and affect it to the userdata. */
1234 lua_rawgeti(L, LUA_REGISTRYINDEX, class_proxy_ref);
1235 lua_setmetatable(L, -2);
1236
1237 lua_pushlightuserdata(L, px);
1238 lua_rawseti(L, -2, 0);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001239
Thierry FOURNIERf2bbe382017-07-24 13:59:22 +02001240 /* Add proxy name. */
1241 lua_pushstring(L, "name");
1242 lua_pushstring(L, px->id);
1243 lua_settable(L, -3);
1244
Baptiste Assmann46c72552017-10-26 21:51:58 +02001245 /* Add proxy uuid. */
1246 lua_pushstring(L, "uuid");
1247 snprintf(buffer, sizeof(buffer), "%d", px->uuid);
1248 lua_pushstring(L, buffer);
1249 lua_settable(L, -3);
1250
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001251 /* Browse and register servers. */
1252 lua_pushstring(L, "servers");
1253 lua_newtable(L);
1254 for (srv = px->srv; srv; srv = srv->next) {
1255 lua_pushstring(L, srv->id);
1256 hlua_fcn_new_server(L, srv);
1257 lua_settable(L, -3);
1258 }
1259 lua_settable(L, -3);
1260
Thierry Fournierff480422016-02-25 08:36:46 +01001261 /* Browse and register listeners. */
1262 lua_pushstring(L, "listeners");
1263 lua_newtable(L);
1264 lid = 1;
1265 list_for_each_entry(lst, &px->conf.listeners, by_fe) {
1266 if (lst->name)
1267 lua_pushstring(L, lst->name);
1268 else {
Willy Tarreau29d69802018-05-06 14:50:09 +02001269 snprintf(buffer, sizeof(buffer), "sock-%d", lid);
Thierry Fournierff480422016-02-25 08:36:46 +01001270 lid++;
1271 lua_pushstring(L, buffer);
1272 }
1273 hlua_fcn_new_listener(L, lst);
1274 lua_settable(L, -3);
1275 }
1276 lua_settable(L, -3);
1277
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001278 if (px->table && px->table->id) {
Adis Nezirovic8878f8e2018-07-13 12:18:33 +02001279 lua_pushstring(L, "stktable");
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001280 hlua_fcn_new_stktable(L, px->table);
Adis Nezirovic8878f8e2018-07-13 12:18:33 +02001281 lua_settable(L, -3);
1282 }
1283
Thierry Fournierf61aa632016-02-19 20:56:00 +01001284 return 1;
1285}
1286
1287static struct proxy *hlua_check_proxy(lua_State *L, int ud)
1288{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02001289 return hlua_checkudata(L, ud, class_proxy_ref);
Thierry Fournierf61aa632016-02-19 20:56:00 +01001290}
1291
1292int hlua_proxy_pause(lua_State *L)
1293{
1294 struct proxy *px;
1295
1296 px = hlua_check_proxy(L, 1);
1297 pause_proxy(px);
1298 return 0;
1299}
1300
1301int hlua_proxy_resume(lua_State *L)
1302{
1303 struct proxy *px;
1304
1305 px = hlua_check_proxy(L, 1);
1306 resume_proxy(px);
1307 return 0;
1308}
1309
1310int hlua_proxy_stop(lua_State *L)
1311{
1312 struct proxy *px;
1313
1314 px = hlua_check_proxy(L, 1);
1315 stop_proxy(px);
1316 return 0;
1317}
1318
1319int hlua_proxy_get_cap(lua_State *L)
1320{
1321 struct proxy *px;
1322 const char *str;
1323
1324 px = hlua_check_proxy(L, 1);
1325 str = proxy_cap_str(px->cap);
1326 lua_pushstring(L, str);
1327 return 1;
1328}
1329
1330int hlua_proxy_get_stats(lua_State *L)
1331{
1332 struct proxy *px;
1333 int i;
1334
1335 px = hlua_check_proxy(L, 1);
1336 if (px->cap & PR_CAP_BE)
1337 stats_fill_be_stats(px, ST_SHLGNDS, stats, STATS_LEN);
1338 else
1339 stats_fill_fe_stats(px, stats, STATS_LEN);
1340 lua_newtable(L);
1341 for (i=0; i<ST_F_TOTAL_FIELDS; i++) {
1342 lua_pushstring(L, stat_field_names[i]);
1343 hlua_fcn_pushfield(L, &stats[i]);
1344 lua_settable(L, -3);
1345 }
1346 return 1;
1347}
1348
1349int hlua_proxy_get_mode(lua_State *L)
1350{
1351 struct proxy *px;
1352 const char *str;
1353
1354 px = hlua_check_proxy(L, 1);
1355 str = proxy_mode_str(px->mode);
1356 lua_pushstring(L, str);
1357 return 1;
1358}
1359
1360int hlua_proxy_shut_bcksess(lua_State *L)
1361{
1362 struct proxy *px;
1363
1364 px = hlua_check_proxy(L, 1);
1365 srv_shutdown_backup_streams(px, SF_ERR_KILLED);
1366 return 0;
1367}
1368
Thierry Fournier3d4a6752016-02-19 20:53:30 +01001369int hlua_fcn_post_init(lua_State *L)
1370{
Thierry Fournierf61aa632016-02-19 20:56:00 +01001371 struct proxy *px;
1372
1373 /* get core array. */
1374 if (lua_getglobal(L, "core") != LUA_TTABLE)
1375 lua_error(L);
1376
1377 /* Create proxies entry. */
1378 lua_pushstring(L, "proxies");
1379 lua_newtable(L);
1380
1381 /* List all proxies. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001382 for (px = proxies_list; px; px = px->next) {
Thierry Fournierf61aa632016-02-19 20:56:00 +01001383 lua_pushstring(L, px->id);
1384 hlua_fcn_new_proxy(L, px);
1385 lua_settable(L, -3);
1386 }
1387
1388 /* push "proxies" in "core" */
1389 lua_settable(L, -3);
1390
Thierry FOURNIER9b82a582017-07-24 13:30:43 +02001391 /* Create proxies entry. */
1392 lua_pushstring(L, "frontends");
1393 lua_newtable(L);
1394
1395 /* List all proxies. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001396 for (px = proxies_list; px; px = px->next) {
Thierry FOURNIER9b82a582017-07-24 13:30:43 +02001397 if (!(px->cap & PR_CAP_FE))
1398 continue;
1399 lua_pushstring(L, px->id);
1400 hlua_fcn_new_proxy(L, px);
1401 lua_settable(L, -3);
1402 }
1403
1404 /* push "frontends" in "core" */
1405 lua_settable(L, -3);
1406
1407 /* Create proxies entry. */
1408 lua_pushstring(L, "backends");
1409 lua_newtable(L);
1410
1411 /* List all proxies. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001412 for (px = proxies_list; px; px = px->next) {
Thierry FOURNIER9b82a582017-07-24 13:30:43 +02001413 if (!(px->cap & PR_CAP_BE))
1414 continue;
1415 lua_pushstring(L, px->id);
1416 hlua_fcn_new_proxy(L, px);
1417 lua_settable(L, -3);
1418 }
1419
1420 /* push "backend" in "core" */
1421 lua_settable(L, -3);
1422
Thierry Fournier3d4a6752016-02-19 20:53:30 +01001423 return 1;
1424}
1425
Thierry FOURNIER / OZON.IO8a1027a2016-11-24 20:48:38 +01001426/* This Lua function take a string, a list of separators.
1427 * It tokenize the input string using the list of separators
1428 * as separator.
1429 *
1430 * The functionreturns a tablle filled with tokens.
1431 */
1432int hlua_tokenize(lua_State *L)
1433{
1434 const char *str;
1435 const char *sep;
1436 int index;
1437 const char *token;
1438 const char *p;
1439 const char *c;
1440 int ignore_empty;
1441
1442 ignore_empty = 0;
1443
1444 str = luaL_checkstring(L, 1);
1445 sep = luaL_checkstring(L, 2);
1446 if (lua_gettop(L) == 3)
1447 ignore_empty = hlua_checkboolean(L, 3);
1448
1449 lua_newtable(L);
1450 index = 1;
1451 token = str;
1452 p = str;
1453 while(1) {
1454 for (c = sep; *c != '\0'; c++)
1455 if (*p == *c)
1456 break;
1457 if (*p == *c) {
1458 if ((!ignore_empty) || (p - token > 0)) {
1459 lua_pushlstring(L, token, p - token);
1460 lua_rawseti(L, -2, index);
1461 index++;
1462 }
1463 token = p + 1;
1464 }
1465 if (*p == '\0')
1466 break;
1467 p++;
1468 }
1469
1470 return 1;
1471}
1472
Thierry FOURNIER / OZON.IO62fec752016-11-10 20:38:11 +01001473int hlua_parse_addr(lua_State *L)
1474{
1475 struct hlua_addr *addr;
1476 const char *str = luaL_checkstring(L, 1);
1477 unsigned char mask;
1478
1479 addr = lua_newuserdata(L, sizeof(struct hlua_addr));
1480 if (!addr) {
1481 lua_pushnil(L);
1482 return 1;
1483 }
1484
1485 if (str2net(str, PAT_MF_NO_DNS, &addr->addr.v4.ip, &addr->addr.v4.mask)) {
1486 addr->type = AF_INET;
1487 return 1;
1488 }
1489
1490 if (str62net(str, &addr->addr.v6.ip, &mask)) {
1491 len2mask6(mask, &addr->addr.v6.mask);
1492 addr->type = AF_INET6;
1493 return 1;
1494 }
1495
1496 lua_pop(L, 1);
1497 lua_pushnil(L);
1498 return 1;
1499}
1500
1501int hlua_match_addr(lua_State *L)
1502{
1503 struct hlua_addr *addr1;
1504 struct hlua_addr *addr2;
1505
1506 if (!lua_isuserdata(L, 1) ||
1507 !lua_isuserdata(L, 2)) {
1508 lua_pushboolean(L, 0);
1509 return 1;
1510 }
1511
1512 addr1 = lua_touserdata(L, 1);
1513 addr2 = lua_touserdata(L, 2);
1514
1515 if (addr1->type != addr2->type) {
1516 lua_pushboolean(L, 0);
1517 return 1;
1518 }
1519
1520 if (addr1->type == AF_INET) {
1521 if ((addr1->addr.v4.ip.s_addr & addr2->addr.v4.mask.s_addr) ==
1522 (addr2->addr.v4.ip.s_addr & addr1->addr.v4.mask.s_addr)) {
1523 lua_pushboolean(L, 1);
1524 return 1;
1525 }
1526 } else {
Thierry FOURNIERde6925e2016-12-23 17:03:25 +01001527 int i;
1528
1529 for (i = 0; i < 16; i += 4) {
1530 if ((*(uint32_t *)&addr1->addr.v6.ip.s6_addr[i] &
1531 *(uint32_t *)&addr2->addr.v6.mask.s6_addr[i]) !=
1532 (*(uint32_t *)&addr2->addr.v6.ip.s6_addr[i] &
1533 *(uint32_t *)&addr1->addr.v6.mask.s6_addr[i]))
1534 break;
1535 }
1536 if (i == 16) {
Thierry FOURNIER / OZON.IO62fec752016-11-10 20:38:11 +01001537 lua_pushboolean(L, 1);
1538 return 1;
1539 }
1540 }
1541
1542 lua_pushboolean(L, 0);
1543 return 1;
1544}
1545
Dragan Dosen26743032019-04-30 15:54:36 +02001546static struct my_regex **hlua_check_regex(lua_State *L, int ud)
Thierry FOURNIER31904272017-10-25 12:59:51 +02001547{
1548 return (hlua_checkudata(L, ud, class_regex_ref));
1549}
1550
1551static int hlua_regex_comp(struct lua_State *L)
1552{
Dragan Dosen26743032019-04-30 15:54:36 +02001553 struct my_regex **regex;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001554 const char *str;
1555 int cs;
1556 char *err;
1557
1558 str = luaL_checkstring(L, 1);
1559 luaL_argcheck(L, lua_isboolean(L, 2), 2, NULL);
1560 cs = lua_toboolean(L, 2);
1561
1562 regex = lua_newuserdata(L, sizeof(*regex));
1563
1564 err = NULL;
Dragan Dosen26743032019-04-30 15:54:36 +02001565 if (!(*regex = regex_comp(str, cs, 1, &err))) {
Thierry FOURNIER31904272017-10-25 12:59:51 +02001566 lua_pushboolean(L, 0); /* status error */
1567 lua_pushstring(L, err); /* Reason */
1568 free(err);
1569 return 2;
1570 }
1571
1572 lua_pushboolean(L, 1); /* Status ok */
1573
1574 /* Create object */
1575 lua_newtable(L);
1576 lua_pushvalue(L, -3); /* Get the userdata pointer. */
1577 lua_rawseti(L, -2, 0);
1578 lua_rawgeti(L, LUA_REGISTRYINDEX, class_regex_ref);
1579 lua_setmetatable(L, -2);
1580 return 2;
1581}
1582
1583static int hlua_regex_exec(struct lua_State *L)
1584{
Dragan Dosen26743032019-04-30 15:54:36 +02001585 struct my_regex **regex;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001586 const char *str;
1587 size_t len;
Willy Tarreau83061a82018-07-13 11:56:34 +02001588 struct buffer *tmp;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001589
1590 regex = hlua_check_regex(L, 1);
1591 str = luaL_checklstring(L, 2, &len);
1592
Dragan Dosen26743032019-04-30 15:54:36 +02001593 if (!*regex) {
1594 lua_pushboolean(L, 0);
1595 return 1;
1596 }
1597
Thierry FOURNIER7c210e62017-10-27 14:13:51 +02001598 /* Copy the string because regex_exec2 require a 'char *'
1599 * and not a 'const char *'.
1600 */
1601 tmp = get_trash_chunk();
1602 if (len >= tmp->size) {
1603 lua_pushboolean(L, 0);
1604 return 1;
1605 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001606 memcpy(tmp->area, str, len);
Thierry FOURNIER7c210e62017-10-27 14:13:51 +02001607
Dragan Dosen26743032019-04-30 15:54:36 +02001608 lua_pushboolean(L, regex_exec2(*regex, tmp->area, len));
Thierry FOURNIER31904272017-10-25 12:59:51 +02001609
1610 return 1;
1611}
1612
1613static int hlua_regex_match(struct lua_State *L)
1614{
Dragan Dosen26743032019-04-30 15:54:36 +02001615 struct my_regex **regex;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001616 const char *str;
1617 size_t len;
1618 regmatch_t pmatch[20];
1619 int ret;
1620 int i;
Willy Tarreau83061a82018-07-13 11:56:34 +02001621 struct buffer *tmp;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001622
1623 regex = hlua_check_regex(L, 1);
1624 str = luaL_checklstring(L, 2, &len);
1625
Dragan Dosen26743032019-04-30 15:54:36 +02001626 if (!*regex) {
1627 lua_pushboolean(L, 0);
1628 return 1;
1629 }
1630
Thierry FOURNIER7c210e62017-10-27 14:13:51 +02001631 /* Copy the string because regex_exec2 require a 'char *'
1632 * and not a 'const char *'.
1633 */
1634 tmp = get_trash_chunk();
1635 if (len >= tmp->size) {
1636 lua_pushboolean(L, 0);
1637 return 1;
1638 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001639 memcpy(tmp->area, str, len);
Thierry FOURNIER7c210e62017-10-27 14:13:51 +02001640
Dragan Dosen26743032019-04-30 15:54:36 +02001641 ret = regex_exec_match2(*regex, tmp->area, len, 20, pmatch, 0);
Thierry FOURNIER31904272017-10-25 12:59:51 +02001642 lua_pushboolean(L, ret);
1643 lua_newtable(L);
1644 if (ret) {
1645 for (i = 0; i < 20 && pmatch[i].rm_so != -1; i++) {
1646 lua_pushlstring(L, str + pmatch[i].rm_so, pmatch[i].rm_eo - pmatch[i].rm_so);
1647 lua_rawseti(L, -2, i + 1);
1648 }
1649 }
1650 return 2;
1651}
1652
1653static int hlua_regex_free(struct lua_State *L)
1654{
Dragan Dosen26743032019-04-30 15:54:36 +02001655 struct my_regex **regex;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001656
1657 regex = hlua_check_regex(L, 1);
Dragan Dosen26743032019-04-30 15:54:36 +02001658 regex_free(*regex);
1659 *regex = NULL;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001660 return 0;
1661}
1662
Thierry Fournierfb0b5462016-01-21 09:28:58 +01001663int hlua_fcn_reg_core_fcn(lua_State *L)
1664{
Thierry Fournier1de16592016-01-27 09:49:07 +01001665 if (!hlua_concat_init(L))
1666 return 0;
1667
Thierry Fournier4f99b272016-02-22 08:40:02 +01001668 hlua_class_function(L, "now", hlua_now);
1669 hlua_class_function(L, "http_date", hlua_http_date);
1670 hlua_class_function(L, "imf_date", hlua_imf_date);
1671 hlua_class_function(L, "rfc850_date", hlua_rfc850_date);
1672 hlua_class_function(L, "asctime_date", hlua_asctime_date);
1673 hlua_class_function(L, "concat", hlua_concat_new);
Thierry Fourniereea77c02016-03-18 08:47:13 +01001674 hlua_class_function(L, "get_info", hlua_get_info);
Thierry FOURNIER / OZON.IO62fec752016-11-10 20:38:11 +01001675 hlua_class_function(L, "parse_addr", hlua_parse_addr);
1676 hlua_class_function(L, "match_addr", hlua_match_addr);
Thierry FOURNIER / OZON.IO8a1027a2016-11-24 20:48:38 +01001677 hlua_class_function(L, "tokenize", hlua_tokenize);
Thierry Fournier4f99b272016-02-22 08:40:02 +01001678
Thierry FOURNIER31904272017-10-25 12:59:51 +02001679 /* Create regex object. */
1680 lua_newtable(L);
1681 hlua_class_function(L, "new", hlua_regex_comp);
1682
1683 lua_newtable(L); /* The metatable. */
1684 lua_pushstring(L, "__index");
1685 lua_newtable(L);
1686 hlua_class_function(L, "exec", hlua_regex_exec);
1687 hlua_class_function(L, "match", hlua_regex_match);
1688 lua_rawset(L, -3); /* -> META["__index"] = TABLE */
1689 hlua_class_function(L, "__gc", hlua_regex_free);
1690
1691 lua_pushvalue(L, -1); /* Duplicate the metatable reference. */
1692 class_regex_ref = hlua_register_metatable(L, CLASS_REGEX);
1693
1694 lua_setmetatable(L, -2);
1695 lua_setglobal(L, CLASS_REGEX); /* Create global object called Regex */
1696
Adis Nezirovic8878f8e2018-07-13 12:18:33 +02001697 /* Create stktable object. */
1698 lua_newtable(L);
1699 lua_pushstring(L, "__index");
1700 lua_newtable(L);
1701 hlua_class_function(L, "info", hlua_stktable_info);
1702 hlua_class_function(L, "lookup", hlua_stktable_lookup);
1703 hlua_class_function(L, "dump", hlua_stktable_dump);
1704 lua_settable(L, -3); /* -> META["__index"] = TABLE */
1705 class_stktable_ref = hlua_register_metatable(L, CLASS_STKTABLE);
1706
Thierry Fournierff480422016-02-25 08:36:46 +01001707 /* Create listener object. */
1708 lua_newtable(L);
1709 lua_pushstring(L, "__index");
1710 lua_newtable(L);
1711 hlua_class_function(L, "get_stats", hlua_listener_get_stats);
1712 lua_settable(L, -3); /* -> META["__index"] = TABLE */
1713 class_listener_ref = hlua_register_metatable(L, CLASS_LISTENER);
1714
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001715 /* Create server object. */
1716 lua_newtable(L);
1717 lua_pushstring(L, "__index");
1718 lua_newtable(L);
1719 hlua_class_function(L, "is_draining", hlua_server_is_draining);
Patrick Hemmer32d539f2018-04-29 14:25:46 -04001720 hlua_class_function(L, "set_maxconn", hlua_server_set_maxconn);
1721 hlua_class_function(L, "get_maxconn", hlua_server_get_maxconn);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001722 hlua_class_function(L, "set_weight", hlua_server_set_weight);
1723 hlua_class_function(L, "get_weight", hlua_server_get_weight);
1724 hlua_class_function(L, "set_addr", hlua_server_set_addr);
1725 hlua_class_function(L, "get_addr", hlua_server_get_addr);
1726 hlua_class_function(L, "get_stats", hlua_server_get_stats);
1727 hlua_class_function(L, "shut_sess", hlua_server_shut_sess);
1728 hlua_class_function(L, "set_drain", hlua_server_set_drain);
1729 hlua_class_function(L, "set_maint", hlua_server_set_maint);
1730 hlua_class_function(L, "set_ready", hlua_server_set_ready);
1731 hlua_class_function(L, "check_enable", hlua_server_check_enable);
1732 hlua_class_function(L, "check_disable", hlua_server_check_disable);
1733 hlua_class_function(L, "check_force_up", hlua_server_check_force_up);
1734 hlua_class_function(L, "check_force_nolb", hlua_server_check_force_nolb);
1735 hlua_class_function(L, "check_force_down", hlua_server_check_force_down);
1736 hlua_class_function(L, "agent_enable", hlua_server_agent_enable);
1737 hlua_class_function(L, "agent_disable", hlua_server_agent_disable);
1738 hlua_class_function(L, "agent_force_up", hlua_server_agent_force_up);
1739 hlua_class_function(L, "agent_force_down", hlua_server_agent_force_down);
1740 lua_settable(L, -3); /* -> META["__index"] = TABLE */
1741 class_server_ref = hlua_register_metatable(L, CLASS_SERVER);
1742
Thierry Fournierf61aa632016-02-19 20:56:00 +01001743 /* Create proxy object. */
1744 lua_newtable(L);
1745 lua_pushstring(L, "__index");
1746 lua_newtable(L);
1747 hlua_class_function(L, "pause", hlua_proxy_pause);
1748 hlua_class_function(L, "resume", hlua_proxy_resume);
1749 hlua_class_function(L, "stop", hlua_proxy_stop);
1750 hlua_class_function(L, "shut_bcksess", hlua_proxy_shut_bcksess);
1751 hlua_class_function(L, "get_cap", hlua_proxy_get_cap);
1752 hlua_class_function(L, "get_mode", hlua_proxy_get_mode);
1753 hlua_class_function(L, "get_stats", hlua_proxy_get_stats);
1754 lua_settable(L, -3); /* -> META["__index"] = TABLE */
1755 class_proxy_ref = hlua_register_metatable(L, CLASS_PROXY);
1756
Thierry Fournier1550d5d2016-01-21 09:35:41 +01001757 return 5;
Thierry Fournierfb0b5462016-01-21 09:28:58 +01001758}