blob: 06ff48dc147a00071665be90d8fcb45af2fc95d7 [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 */
Bertrand Jacquin3dfbd272021-01-21 21:14:07 +000017
18#define _GNU_SOURCE
19
Thierry Fournierfb0b5462016-01-21 09:28:58 +010020#include <lauxlib.h>
21#include <lua.h>
22#include <lualib.h>
23
Willy Tarreau83487a82020-06-04 20:19:54 +020024#include <haproxy/cli-t.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020025#include <haproxy/errors.h>
Willy Tarreau86416052020-06-04 09:20:54 +020026#include <haproxy/hlua-t.h>
Willy Tarreaucd72d8c2020-06-02 19:11:26 +020027#include <haproxy/http.h>
Willy Tarreau6131d6a2020-06-02 16:48:09 +020028#include <haproxy/net_helper.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020029#include <haproxy/pattern-t.h>
30#include <haproxy/proxy.h>
Willy Tarreau7cd8b6e2020-06-02 17:32:26 +020031#include <haproxy/regex.h>
Willy Tarreau1e56f922020-06-04 23:20:13 +020032#include <haproxy/server.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020033#include <haproxy/stats.h>
Willy Tarreau872f2ea2020-06-04 18:46:44 +020034#include <haproxy/stick_table.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020035#include <haproxy/time.h>
Thierry Fournier94ed1c12016-02-24 08:06:32 +010036
Thierry Fournier1de16592016-01-27 09:49:07 +010037/* Contains the class reference of the concat object. */
38static int class_concat_ref;
Thierry Fournierf61aa632016-02-19 20:56:00 +010039static int class_proxy_ref;
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +010040static int class_server_ref;
Thierry Fournierff480422016-02-25 08:36:46 +010041static int class_listener_ref;
Thierry FOURNIER31904272017-10-25 12:59:51 +020042static int class_regex_ref;
Adis Nezirovic8878f8e2018-07-13 12:18:33 +020043static int class_stktable_ref;
Thierry Fournier1de16592016-01-27 09:49:07 +010044
Thierry Fournierf61aa632016-02-19 20:56:00 +010045#define STATS_LEN (MAX((int)ST_F_TOTAL_FIELDS, (int)INF_TOTAL_FIELDS))
Thierry Fourniereea77c02016-03-18 08:47:13 +010046
Thierry FOURNIERffbad792017-07-12 11:39:04 +020047static THREAD_LOCAL struct field stats[STATS_LEN];
Thierry Fourniereea77c02016-03-18 08:47:13 +010048
Thierry FOURNIER / OZON.IO7f3aa8b2016-11-24 20:37:38 +010049int hlua_checkboolean(lua_State *L, int index)
50{
51 if (!lua_isboolean(L, index))
52 luaL_argerror(L, index, "boolean expected");
53 return lua_toboolean(L, index);
54}
55
Adis Nezirovic8878f8e2018-07-13 12:18:33 +020056/* Helper to push unsigned integers to Lua stack, respecting Lua limitations */
57static int hlua_fcn_pushunsigned(lua_State *L, unsigned int val)
58{
59#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))
60 lua_pushinteger(L, val);
61#else
62 if (val > INT_MAX)
63 lua_pushnumber(L, (lua_Number)val);
64 else
65 lua_pushinteger(L, (int)val);
66#endif
67 return 1;
68}
69
70/* Helper to push unsigned long long to Lua stack, respecting Lua limitations */
71static int hlua_fcn_pushunsigned_ll(lua_State *L, unsigned long long val) {
72#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))
73 /* 64 bits case, U64 is supported until LLONG_MAX */
74 if (val > LLONG_MAX)
75 lua_pushnumber(L, (lua_Number)val);
76 else
77 lua_pushinteger(L, val);
78#else
79 /* 32 bits case, U64 is supported until INT_MAX */
80 if (val > INT_MAX)
81 lua_pushnumber(L, (lua_Number)val);
82 else
83 lua_pushinteger(L, (int)val);
84#endif
85 return 1;
86}
87
Joseph Herlantb3d92e32018-11-15 09:35:04 -080088/* This function gets a struct field and converts it in Lua
89 * variable. The variable is pushed at the top of the stack.
Thierry Fournier8b0d6e12016-03-16 18:29:13 +010090 */
91int hlua_fcn_pushfield(lua_State *L, struct field *field)
92{
93 /* The lua_Integer is always signed. Its length depends on
Joseph Herlantb3d92e32018-11-15 09:35:04 -080094 * compilation options, so the following code is conditioned
Thierry Fournier8b0d6e12016-03-16 18:29:13 +010095 * by some macros. Windows maros are not supported.
96 * If the number cannot be represented as integer, we try to
97 * convert to float.
98 */
99 switch (field_format(field, 0)) {
100
101 case FF_EMPTY:
102 lua_pushnil(L);
103 return 1;
104
105 case FF_S32:
106 /* S32 is always supported. */
107 lua_pushinteger(L, field->u.s32);
108 return 1;
109
110 case FF_U32:
111#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))
112 /* 64 bits case, U32 is always supported */
113 lua_pushinteger(L, field->u.u32);
114#else
115 /* 32 bits case, U32 is supported until INT_MAX. */
116 if (field->u.u32 > INT_MAX)
117 lua_pushnumber(L, (lua_Number)field->u.u32);
118 else
119 lua_pushinteger(L, field->u.u32);
120#endif
121 return 1;
122
123 case FF_S64:
124#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))
125 /* 64 bits case, S64 is always supported */
126 lua_pushinteger(L, field->u.s64);
127#else
Ilya Shipitsince7b00f2020-03-23 22:28:40 +0500128 /* 64 bits case, S64 is supported between INT_MIN and INT_MAX */
Thierry Fournier8b0d6e12016-03-16 18:29:13 +0100129 if (field->u.s64 < INT_MIN || field->u.s64 > INT_MAX)
130 lua_pushnumber(L, (lua_Number)field->u.s64);
131 else
132 lua_pushinteger(L, (int)field->u.s64);
133#endif
134 return 1;
135
136 case FF_U64:
137#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))
138 /* 64 bits case, U64 is supported until LLONG_MAX */
139 if (field->u.u64 > LLONG_MAX)
140 lua_pushnumber(L, (lua_Number)field->u.u64);
141 else
142 lua_pushinteger(L, field->u.u64);
143#else
144 /* 64 bits case, U64 is supported until INT_MAX */
145 if (field->u.u64 > INT_MAX)
146 lua_pushnumber(L, (lua_Number)field->u.u64);
147 else
148 lua_pushinteger(L, (int)field->u.u64);
149#endif
150 return 1;
151
152 case FF_STR:
153 lua_pushstring(L, field->u.str);
154 return 1;
155
156 default:
157 break;
158 }
159
160 /* Default case, never reached. */
161 lua_pushnil(L);
162 return 1;
163}
164
Thierry Fournier94ed1c12016-02-24 08:06:32 +0100165/* Some string are started or terminated by blank chars,
166 * this function removes the spaces, tabs, \r and
167 * \n at the begin and at the end of the string "str", and
168 * push the result in the lua stack.
169 * Returns a pointer to the Lua internal copy of the string.
170 */
171const char *hlua_pushstrippedstring(lua_State *L, const char *str)
172{
173 const char *p;
174 const char *e;
175
176 for (p = str; HTTP_IS_LWS(*p); p++);
177 for (e = p + strlen(p) - 1; e > p && HTTP_IS_LWS(*e); e--);
178
179 return lua_pushlstring(L, p, e - p);
180}
181
Thierry Fournierddd89882016-02-22 19:52:08 +0100182/* The three following functions are useful for adding entries
183 * in a table. These functions takes a string and respectively an
184 * integer, a string or a function and add it to the table in the
185 * top of the stack.
186 *
187 * These functions throws an error if no more stack size is
188 * available.
189 */
190void hlua_class_const_int(lua_State *L, const char *name, int value)
191{
Thierry Fournierddd89882016-02-22 19:52:08 +0100192 lua_pushstring(L, name);
193 lua_pushinteger(L, value);
194 lua_rawset(L, -3);
195}
196void hlua_class_const_str(lua_State *L, const char *name, const char *value)
197{
Thierry Fournierddd89882016-02-22 19:52:08 +0100198 lua_pushstring(L, name);
199 lua_pushstring(L, value);
200 lua_rawset(L, -3);
201}
202void hlua_class_function(lua_State *L, const char *name, int (*function)(lua_State *L))
203{
Thierry Fournierddd89882016-02-22 19:52:08 +0100204 lua_pushstring(L, name);
205 lua_pushcclosure(L, function, 0);
206 lua_rawset(L, -3);
207}
208
Joseph Herlantb3d92e32018-11-15 09:35:04 -0800209/* This function returns a string containing the HAProxy object name. */
Thierry Fournierddd89882016-02-22 19:52:08 +0100210int hlua_dump_object(struct lua_State *L)
211{
212 const char *name = (const char *)lua_tostring(L, lua_upvalueindex(1));
213 lua_pushfstring(L, "HAProxy class %s", name);
214 return 1;
215}
216
Thierry Fournier45e78d72016-02-19 18:34:46 +0100217/* This function register a table as metatable and. It names
218 * the metatable, and returns the associated reference.
Ilya Shipitsince7b00f2020-03-23 22:28:40 +0500219 * The original table is popped from the top of the stack.
Thierry Fournier45e78d72016-02-19 18:34:46 +0100220 * "name" is the referenced class name.
221 */
222int hlua_register_metatable(struct lua_State *L, char *name)
223{
224 /* Check the type of the top element. it must be
225 * a table.
226 */
227 if (lua_type(L, -1) != LUA_TTABLE)
228 luaL_error(L, "hlua_register_metatable() requires a type Table "
229 "in the top of the stack");
230
231 /* Add the __tostring function which identify the
232 * created object.
233 */
234 lua_pushstring(L, "__tostring");
235 lua_pushstring(L, name);
236 lua_pushcclosure(L, hlua_dump_object, 1);
237 lua_rawset(L, -3);
238
239 /* Register a named entry for the table. The table
Ilya Shipitsince7b00f2020-03-23 22:28:40 +0500240 * reference is copied first because the function
Thierry Fournier45e78d72016-02-19 18:34:46 +0100241 * lua_setfield() pop the entry.
242 */
243 lua_pushvalue(L, -1);
244 lua_setfield(L, LUA_REGISTRYINDEX, name);
245
246 /* Creates the reference of the object. The
247 * function luaL_ref pop the top of the stack.
248 */
249 return luaL_ref(L, LUA_REGISTRYINDEX);
250}
251
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100252/* Return an object of the expected type, or throws an error. */
253void *hlua_checkudata(lua_State *L, int ud, int class_ref)
254{
255 void *p;
Thierry Fournier53518272016-01-27 10:34:09 +0100256 int ret;
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100257
258 /* Check if the stack entry is an array. */
259 if (!lua_istable(L, ud))
Thierry Fournier53518272016-01-27 10:34:09 +0100260 luaL_argerror(L, ud, NULL);
261
262 /* pop the metatable of the referencecd object. */
263 if (!lua_getmetatable(L, ud))
264 luaL_argerror(L, ud, NULL);
265
266 /* pop the expected metatable. */
267 lua_rawgeti(L, LUA_REGISTRYINDEX, class_ref);
268
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100269 /* Check if the metadata have the expected type. */
Thierry Fournier53518272016-01-27 10:34:09 +0100270 ret = lua_rawequal(L, -1, -2);
271 lua_pop(L, 2);
272 if (!ret)
273 luaL_argerror(L, ud, NULL);
274
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100275 /* Push on the stack at the entry [0] of the table. */
276 lua_rawgeti(L, ud, 0);
Thierry Fournier53518272016-01-27 10:34:09 +0100277
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100278 /* Check if this entry is userdata. */
279 p = lua_touserdata(L, -1);
280 if (!p)
Thierry Fournier53518272016-01-27 10:34:09 +0100281 luaL_argerror(L, ud, NULL);
282
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100283 /* Remove the entry returned by lua_rawgeti(). */
284 lua_pop(L, 1);
Thierry Fournier53518272016-01-27 10:34:09 +0100285
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100286 /* Return the associated struct. */
287 return p;
288}
289
Thierry Fournierb1f46562016-01-21 09:46:15 +0100290/* This function return the current date at epoch format in milliseconds. */
291int hlua_now(lua_State *L)
292{
293 lua_newtable(L);
294 lua_pushstring(L, "sec");
295 lua_pushinteger(L, now.tv_sec);
296 lua_rawset(L, -3);
297 lua_pushstring(L, "usec");
298 lua_pushinteger(L, now.tv_usec);
299 lua_rawset(L, -3);
300 return 1;
301}
302
Thierry Fournier1550d5d2016-01-21 09:35:41 +0100303/* This functions expects a Lua string as HTTP date, parse it and
304 * returns an integer containing the epoch format of the date, or
305 * nil if the parsing fails.
306 */
307static int hlua_parse_date(lua_State *L, int (*fcn)(const char *, int, struct tm*))
308{
309 const char *str;
310 size_t len;
311 struct tm tm;
312 time_t time;
313
314 str = luaL_checklstring(L, 1, &len);
315
316 if (!fcn(str, len, &tm)) {
317 lua_pushnil(L);
318 return 1;
319 }
320
321 /* This function considers the content of the broken-down time
322 * is exprimed in the UTC timezone. timegm don't care about
323 * the gnu variable tm_gmtoff. If gmtoff is set, or if you know
324 * the timezone from the broken-down time, it must be fixed
325 * after the conversion.
326 */
Willy Tarreauabd9bb22017-07-19 19:08:48 +0200327 time = my_timegm(&tm);
Thierry Fournier1550d5d2016-01-21 09:35:41 +0100328 if (time == -1) {
329 lua_pushnil(L);
330 return 1;
331 }
332
333 lua_pushinteger(L, (int)time);
334 return 1;
335}
336static int hlua_http_date(lua_State *L)
337{
338 return hlua_parse_date(L, parse_http_date);
339}
340static int hlua_imf_date(lua_State *L)
341{
342 return hlua_parse_date(L, parse_imf_date);
343}
344static int hlua_rfc850_date(lua_State *L)
345{
346 return hlua_parse_date(L, parse_rfc850_date);
347}
348static int hlua_asctime_date(lua_State *L)
349{
350 return hlua_parse_date(L, parse_asctime_date);
351}
352
Thierry Fourniereea77c02016-03-18 08:47:13 +0100353static int hlua_get_info(lua_State *L)
354{
355 int i;
356
357 stats_fill_info(stats, STATS_LEN);
358
359 lua_newtable(L);
360 for (i=0; i<INF_TOTAL_FIELDS; i++) {
Willy Tarreaueaa55372019-10-09 07:39:11 +0200361 lua_pushstring(L, info_fields[i].name);
Thierry Fourniereea77c02016-03-18 08:47:13 +0100362 hlua_fcn_pushfield(L, &stats[i]);
363 lua_settable(L, -3);
364 }
365 return 1;
366}
367
Thierry Fournier49d48422016-02-19 12:09:29 +0100368static struct hlua_concat *hlua_check_concat(lua_State *L, int ud)
Thierry Fournier1de16592016-01-27 09:49:07 +0100369{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200370 return (hlua_checkudata(L, ud, class_concat_ref));
Thierry Fournier1de16592016-01-27 09:49:07 +0100371}
372
373static int hlua_concat_add(lua_State *L)
374{
Thierry Fournier49d48422016-02-19 12:09:29 +0100375 struct hlua_concat *b;
376 char *buffer;
377 char *new;
Thierry Fournier1de16592016-01-27 09:49:07 +0100378 const char *str;
379 size_t l;
380
381 /* First arg must be a concat object. */
382 b = hlua_check_concat(L, 1);
383
384 /* Second arg must be a string. */
385 str = luaL_checklstring(L, 2, &l);
386
Thierry Fournier49d48422016-02-19 12:09:29 +0100387 /* Get the buffer. */
388 lua_rawgeti(L, 1, 1);
389 buffer = lua_touserdata(L, -1);
390 lua_pop(L, 1);
391
392 /* Update the buffer size if it s required. The old buffer
393 * is crushed by the new in the object array, so it will
394 * be deleted by the GC.
395 * Note that in the first loop, the "new" variable is only
396 * used as a flag.
397 */
398 new = NULL;
399 while (b->size - b->len < l) {
400 b->size += HLUA_CONCAT_BLOCSZ;
401 new = buffer;
402 }
403 if (new) {
404 new = lua_newuserdata(L, b->size);
405 memcpy(new, buffer, b->len);
406 lua_rawseti(L, 1, 1);
407 buffer = new;
408 }
409
410 /* Copy string, and update metadata. */
411 memcpy(buffer + b->len, str, l);
412 b->len += l;
Thierry Fournier1de16592016-01-27 09:49:07 +0100413 return 0;
414}
415
416static int hlua_concat_dump(lua_State *L)
417{
Thierry Fournier49d48422016-02-19 12:09:29 +0100418 struct hlua_concat *b;
419 char *buffer;
Thierry Fournier1de16592016-01-27 09:49:07 +0100420
421 /* First arg must be a concat object. */
422 b = hlua_check_concat(L, 1);
423
Thierry Fournier49d48422016-02-19 12:09:29 +0100424 /* Get the buffer. */
425 lua_rawgeti(L, 1, 1);
426 buffer = lua_touserdata(L, -1);
427 lua_pop(L, 1);
428
Ilya Shipitsince7b00f2020-03-23 22:28:40 +0500429 /* Push the soncatenated string in the stack. */
Thierry Fournier49d48422016-02-19 12:09:29 +0100430 lua_pushlstring(L, buffer, b->len);
Thierry Fournier1de16592016-01-27 09:49:07 +0100431 return 1;
432}
433
434int hlua_concat_new(lua_State *L)
435{
Thierry Fournier49d48422016-02-19 12:09:29 +0100436 struct hlua_concat *b;
Thierry Fournier1de16592016-01-27 09:49:07 +0100437
438 lua_newtable(L);
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200439 b = lua_newuserdata(L, sizeof(*b));
Thierry Fournier49d48422016-02-19 12:09:29 +0100440 b->size = HLUA_CONCAT_BLOCSZ;
441 b->len = 0;
Thierry Fournier1de16592016-01-27 09:49:07 +0100442 lua_rawseti(L, -2, 0);
Thierry Fournier49d48422016-02-19 12:09:29 +0100443 lua_newuserdata(L, HLUA_CONCAT_BLOCSZ);
444 lua_rawseti(L, -2, 1);
Thierry Fournier1de16592016-01-27 09:49:07 +0100445
446 lua_rawgeti(L, LUA_REGISTRYINDEX, class_concat_ref);
447 lua_setmetatable(L, -2);
448
Thierry Fournier1de16592016-01-27 09:49:07 +0100449 return 1;
450}
451
452static int concat_tostring(lua_State *L)
453{
454 const void *ptr = lua_topointer(L, 1);
455 lua_pushfstring(L, "Concat object: %p", ptr);
456 return 1;
457}
458
459static int hlua_concat_init(lua_State *L)
460{
461 /* Creates the buffered concat object. */
462 lua_newtable(L);
463
464 lua_pushstring(L, "__tostring");
465 lua_pushcclosure(L, concat_tostring, 0);
466 lua_settable(L, -3);
467
468 lua_pushstring(L, "__index"); /* Creates the index entry. */
469 lua_newtable(L); /* The "__index" content. */
470
471 lua_pushstring(L, "add");
472 lua_pushcclosure(L, hlua_concat_add, 0);
473 lua_settable(L, -3);
474
475 lua_pushstring(L, "dump");
476 lua_pushcclosure(L, hlua_concat_dump, 0);
477 lua_settable(L, -3);
478
479 lua_settable(L, -3); /* Sets the __index entry. */
480 class_concat_ref = luaL_ref(L, LUA_REGISTRYINDEX);
481
482 return 1;
483}
484
Adis Nezirovic8878f8e2018-07-13 12:18:33 +0200485int hlua_fcn_new_stktable(lua_State *L, struct stktable *tbl)
486{
487 lua_newtable(L);
488
489 /* Pop a class stktbl metatable and affect it to the userdata. */
490 lua_rawgeti(L, LUA_REGISTRYINDEX, class_stktable_ref);
491 lua_setmetatable(L, -2);
492
493 lua_pushlightuserdata(L, tbl);
494 lua_rawseti(L, -2, 0);
495 return 1;
496}
497
498static struct stktable *hlua_check_stktable(lua_State *L, int ud)
499{
500 return hlua_checkudata(L, ud, class_stktable_ref);
501}
502
503/* Extract stick table attributes into Lua table */
504int hlua_stktable_info(lua_State *L)
505{
506 struct stktable *tbl;
507 int dt;
508
509 tbl = hlua_check_stktable(L, 1);
510
511 if (!tbl->id) {
512 lua_pushnil(L);
513 return 1;
514 }
515
516 lua_newtable(L);
517
518 lua_pushstring(L, "type");
519 lua_pushstring(L, stktable_types[tbl->type].kw);
520 lua_settable(L, -3);
521
522 lua_pushstring(L, "length");
523 lua_pushinteger(L, tbl->key_size);
524 lua_settable(L, -3);
525
526 lua_pushstring(L, "size");
527 hlua_fcn_pushunsigned(L, tbl->size);
528 lua_settable(L, -3);
529
530 lua_pushstring(L, "used");
531 hlua_fcn_pushunsigned(L, tbl->current);
532 lua_settable(L, -3);
533
534 lua_pushstring(L, "nopurge");
535 lua_pushboolean(L, tbl->nopurge > 0);
536 lua_settable(L, -3);
537
538 lua_pushstring(L, "expire");
539 lua_pushinteger(L, tbl->expire);
540 lua_settable(L, -3);
541
542 /* Save data types periods (if applicable) in 'data' table */
543 lua_pushstring(L, "data");
544 lua_newtable(L);
545
546 for (dt = 0; dt < STKTABLE_DATA_TYPES; dt++) {
547 if (tbl->data_ofs[dt] == 0)
548 continue;
549
550 lua_pushstring(L, stktable_data_types[dt].name);
551
552 if (stktable_data_types[dt].arg_type == ARG_T_DELAY)
553 lua_pushinteger(L, tbl->data_arg[dt].u);
554 else
555 lua_pushinteger(L, -1);
556
557 lua_settable(L, -3);
558 }
559
560 lua_settable(L, -3);
561
562 return 1;
563}
564
565/* Helper to get extract stick table entry into Lua table */
566static void hlua_stktable_entry(lua_State *L, struct stktable *t, struct stksess *ts)
567{
568 int dt;
569 void *ptr;
570
571 for (dt = 0; dt < STKTABLE_DATA_TYPES; dt++) {
572
573 if (t->data_ofs[dt] == 0)
574 continue;
575
576 lua_pushstring(L, stktable_data_types[dt].name);
577
578 ptr = stktable_data_ptr(t, ts, dt);
579 switch (stktable_data_types[dt].std_type) {
580 case STD_T_SINT:
581 lua_pushinteger(L, stktable_data_cast(ptr, std_t_sint));
582 break;
583 case STD_T_UINT:
584 hlua_fcn_pushunsigned(L, stktable_data_cast(ptr, std_t_uint));
585 break;
586 case STD_T_ULL:
587 hlua_fcn_pushunsigned_ll(L, stktable_data_cast(ptr, std_t_ull));
588 break;
589 case STD_T_FRQP:
590 lua_pushinteger(L, read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp),
591 t->data_arg[dt].u));
592 break;
Adis Nezirovicad9f9ed2020-05-05 13:57:28 +0200593 case STD_T_DICT: {
594 struct dict_entry *de;
595 de = stktable_data_cast(ptr, std_t_dict);
596 lua_pushstring(L, de ? (char *)de->value.key : "-");
597 break;
598 }
Adis Nezirovic8878f8e2018-07-13 12:18:33 +0200599 }
600
601 lua_settable(L, -3);
602 }
603}
604
605/* Looks in table <t> for a sticky session matching key <key>
606 * Returns table with session data or nil
607 *
608 * The returned table always contains 'use' and 'expire' (integer) fields.
609 * For frequency/rate counters, each data entry is returned as table with
610 * 'value' and 'period' fields.
611 */
612int hlua_stktable_lookup(lua_State *L)
613{
614 struct stktable *t;
615 struct sample smp;
616 struct stktable_key *skey;
617 struct stksess *ts;
618
619 t = hlua_check_stktable(L, 1);
620 smp.data.type = SMP_T_STR;
621 smp.flags = SMP_F_CONST;
Nathan Neulinger31a841c2020-03-03 20:32:47 -0600622 smp.data.u.str.area = (char *)lua_tolstring(L, 2, &smp.data.u.str.data);
Adis Nezirovic8878f8e2018-07-13 12:18:33 +0200623
624 skey = smp_to_stkey(&smp, t);
625 if (!skey) {
626 lua_pushnil(L);
627 return 1;
628 }
629
630 ts = stktable_lookup_key(t, skey);
631 if (!ts) {
632 lua_pushnil(L);
633 return 1;
634 }
635
636 lua_newtable(L);
637 lua_pushstring(L, "use");
638 lua_pushinteger(L, ts->ref_cnt - 1);
639 lua_settable(L, -3);
640
641 lua_pushstring(L, "expire");
642 lua_pushinteger(L, tick_remain(now_ms, ts->expire));
643 lua_settable(L, -3);
644
645 hlua_stktable_entry(L, t, ts);
646 HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
647 ts->ref_cnt--;
648 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
649
650 return 1;
651}
652
653struct stk_filter {
654 long long val;
655 int type;
656 int op;
657};
658
659
660/* Helper for returning errors to callers using Lua convention (nil, err) */
661static int hlua_error(lua_State *L, const char *fmt, ...) {
662 char buf[256];
663 int len;
664 va_list args;
665 va_start(args, fmt);
666 len = vsnprintf(buf, sizeof(buf), fmt, args);
667 va_end(args);
668
669 if (len < 0) {
670 ha_alert("hlua_error(): Could not write error message.\n");
671 lua_pushnil(L);
672 return 1;
673 } else if (len >= sizeof(buf))
674 ha_alert("hlua_error(): Error message was truncated.\n");
675
676 lua_pushnil(L);
677 lua_pushstring(L, buf);
678
679 return 2;
680}
681
682/* Dump the contents of stick table <t>*/
683int hlua_stktable_dump(lua_State *L)
684{
685 struct stktable *t;
686 struct ebmb_node *eb;
687 struct ebmb_node *n;
688 struct stksess *ts;
689 int type;
690 int op;
691 int dt;
692 long long val;
Adis Nezirovic1a693fc2020-01-16 15:19:29 +0100693 struct stk_filter filter[STKTABLE_FILTER_LEN];
Adis Nezirovic8878f8e2018-07-13 12:18:33 +0200694 int filter_count = 0;
695 int i;
696 int skip_entry;
697 void *ptr;
698
699 t = hlua_check_stktable(L, 1);
700 type = lua_type(L, 2);
701
702 switch (type) {
703 case LUA_TNONE:
704 case LUA_TNIL:
705 break;
706 case LUA_TTABLE:
707 lua_pushnil(L);
708 while (lua_next(L, 2) != 0) {
709 int entry_idx = 0;
710
Adis Nezirovic1a693fc2020-01-16 15:19:29 +0100711 if (filter_count >= STKTABLE_FILTER_LEN)
712 return hlua_error(L, "Filter table too large (len > %d)", STKTABLE_FILTER_LEN);
Adis Nezirovic8878f8e2018-07-13 12:18:33 +0200713
714 if (lua_type(L, -1) != LUA_TTABLE || lua_rawlen(L, -1) != 3)
715 return hlua_error(L, "Filter table entry must be a triplet: {\"data_col\", \"op\", val} (entry #%d)", filter_count + 1);
716
717 lua_pushnil(L);
718 while (lua_next(L, -2) != 0) {
719 switch (entry_idx) {
720 case 0:
721 if (lua_type(L, -1) != LUA_TSTRING)
722 return hlua_error(L, "Filter table data column must be string (entry #%d)", filter_count + 1);
723
724 dt = stktable_get_data_type((char *)lua_tostring(L, -1));
725 if (dt < 0 || t->data_ofs[dt] == 0)
726 return hlua_error(L, "Filter table data column not present in stick table (entry #%d)", filter_count + 1);
727 filter[filter_count].type = dt;
728 break;
729 case 1:
730 if (lua_type(L, -1) != LUA_TSTRING)
731 return hlua_error(L, "Filter table operator must be string (entry #%d)", filter_count + 1);
732
733 op = get_std_op(lua_tostring(L, -1));
734 if (op < 0)
735 return hlua_error(L, "Unknown operator in filter table (entry #%d)", filter_count + 1);
736 filter[filter_count].op = op;
737 break;
738 case 2:
739 val = lua_tointeger(L, -1);
740 filter[filter_count].val = val;
741 filter_count++;
742 break;
743 default:
744 break;
745 }
746 entry_idx++;
747 lua_pop(L, 1);
748 }
749 lua_pop(L, 1);
750 }
751 break;
752 default:
753 return hlua_error(L, "filter table expected");
754 }
755
756 lua_newtable(L);
757
758 HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
759 eb = ebmb_first(&t->keys);
760 for (n = eb; n; n = ebmb_next(n)) {
761 ts = ebmb_entry(n, struct stksess, key);
762 if (!ts) {
763 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
764 return 1;
765 }
766 ts->ref_cnt++;
767 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
768
769 /* multi condition/value filter */
770 skip_entry = 0;
771 for (i = 0; i < filter_count; i++) {
772 if (t->data_ofs[filter[i].type] == 0)
773 continue;
774
775 ptr = stktable_data_ptr(t, ts, filter[i].type);
776
777 switch (stktable_data_types[filter[i].type].std_type) {
778 case STD_T_SINT:
779 val = stktable_data_cast(ptr, std_t_sint);
780 break;
781 case STD_T_UINT:
782 val = stktable_data_cast(ptr, std_t_uint);
783 break;
784 case STD_T_ULL:
785 val = stktable_data_cast(ptr, std_t_ull);
786 break;
787 case STD_T_FRQP:
788 val = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp),
789 t->data_arg[filter[i].type].u);
790 break;
791 default:
792 continue;
793 break;
794 }
795
796 op = filter[i].op;
797
798 if ((val < filter[i].val && (op == STD_OP_EQ || op == STD_OP_GT || op == STD_OP_GE)) ||
799 (val == filter[i].val && (op == STD_OP_NE || op == STD_OP_GT || op == STD_OP_LT)) ||
800 (val > filter[i].val && (op == STD_OP_EQ || op == STD_OP_LT || op == STD_OP_LE))) {
801 skip_entry = 1;
802 break;
803 }
804 }
805
806 if (skip_entry) {
807 HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
808 ts->ref_cnt--;
809 continue;
810 }
811
812 if (t->type == SMP_T_IPV4) {
813 char addr[INET_ADDRSTRLEN];
814 inet_ntop(AF_INET, (const void *)&ts->key.key, addr, sizeof(addr));
815 lua_pushstring(L, addr);
816 } else if (t->type == SMP_T_IPV6) {
817 char addr[INET6_ADDRSTRLEN];
818 inet_ntop(AF_INET6, (const void *)&ts->key.key, addr, sizeof(addr));
819 lua_pushstring(L, addr);
820 } else if (t->type == SMP_T_SINT) {
821 lua_pushinteger(L, *ts->key.key);
822 } else if (t->type == SMP_T_STR) {
823 lua_pushstring(L, (const char *)ts->key.key);
824 } else {
825 return hlua_error(L, "Unsupported stick table key type");
826 }
827
828 lua_newtable(L);
829 hlua_stktable_entry(L, t, ts);
830 lua_settable(L, -3);
831 HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
832 ts->ref_cnt--;
833 }
834 HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
835
836 return 1;
837}
838
Thierry Fournierff480422016-02-25 08:36:46 +0100839int hlua_fcn_new_listener(lua_State *L, struct listener *lst)
840{
841 lua_newtable(L);
842
843 /* Pop a class sesison metatable and affect it to the userdata. */
844 lua_rawgeti(L, LUA_REGISTRYINDEX, class_listener_ref);
845 lua_setmetatable(L, -2);
846
847 lua_pushlightuserdata(L, lst);
848 lua_rawseti(L, -2, 0);
849 return 1;
850}
851
852static struct listener *hlua_check_listener(lua_State *L, int ud)
853{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200854 return hlua_checkudata(L, ud, class_listener_ref);
Thierry Fournierff480422016-02-25 08:36:46 +0100855}
856
857int hlua_listener_get_stats(lua_State *L)
858{
859 struct listener *li;
860 int i;
861
862 li = hlua_check_listener(L, 1);
863
Willy Tarreauc95bad52016-12-22 00:13:31 +0100864 if (!li->bind_conf->frontend) {
Thierry Fournierff480422016-02-25 08:36:46 +0100865 lua_pushnil(L);
866 return 1;
867 }
868
Willy Tarreau708c4162019-10-09 10:19:16 +0200869 stats_fill_li_stats(li->bind_conf->frontend, li, STAT_SHLGNDS, stats, STATS_LEN);
Thierry Fournierff480422016-02-25 08:36:46 +0100870
871 lua_newtable(L);
872 for (i=0; i<ST_F_TOTAL_FIELDS; i++) {
Willy Tarreaueaa55372019-10-09 07:39:11 +0200873 lua_pushstring(L, stat_fields[i].name);
Thierry Fournierff480422016-02-25 08:36:46 +0100874 hlua_fcn_pushfield(L, &stats[i]);
875 lua_settable(L, -3);
876 }
877 return 1;
878
879}
880
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100881int hlua_fcn_new_server(lua_State *L, struct server *srv)
882{
Patrick Hemmera62ae7e2018-04-29 14:23:48 -0400883 char buffer[12];
884
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100885 lua_newtable(L);
886
887 /* Pop a class sesison metatable and affect it to the userdata. */
888 lua_rawgeti(L, LUA_REGISTRYINDEX, class_server_ref);
889 lua_setmetatable(L, -2);
890
891 lua_pushlightuserdata(L, srv);
892 lua_rawseti(L, -2, 0);
Patrick Hemmera62ae7e2018-04-29 14:23:48 -0400893
894 /* Add server name. */
895 lua_pushstring(L, "name");
896 lua_pushstring(L, srv->id);
897 lua_settable(L, -3);
898
899 /* Add server puid. */
900 lua_pushstring(L, "puid");
901 snprintf(buffer, sizeof(buffer), "%d", srv->puid);
902 lua_pushstring(L, buffer);
903 lua_settable(L, -3);
904
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100905 return 1;
906}
907
908static struct server *hlua_check_server(lua_State *L, int ud)
909{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200910 return hlua_checkudata(L, ud, class_server_ref);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100911}
912
913int hlua_server_get_stats(lua_State *L)
914{
915 struct server *srv;
916 int i;
917
918 srv = hlua_check_server(L, 1);
919
920 if (!srv->proxy) {
921 lua_pushnil(L);
922 return 1;
923 }
924
Willy Tarreau708c4162019-10-09 10:19:16 +0200925 stats_fill_sv_stats(srv->proxy, srv, STAT_SHLGNDS, stats, STATS_LEN);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100926
927 lua_newtable(L);
928 for (i=0; i<ST_F_TOTAL_FIELDS; i++) {
Willy Tarreaueaa55372019-10-09 07:39:11 +0200929 lua_pushstring(L, stat_fields[i].name);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100930 hlua_fcn_pushfield(L, &stats[i]);
931 lua_settable(L, -3);
932 }
933 return 1;
934
935}
936
937int hlua_server_get_addr(lua_State *L)
938{
939 struct server *srv;
940 char addr[INET6_ADDRSTRLEN];
941 luaL_Buffer b;
942
943 srv = hlua_check_server(L, 1);
944
945 luaL_buffinit(L, &b);
946
947 switch (srv->addr.ss_family) {
948 case AF_INET:
949 inet_ntop(AF_INET, &((struct sockaddr_in *)&srv->addr)->sin_addr,
950 addr, INET_ADDRSTRLEN);
951 luaL_addstring(&b, addr);
952 luaL_addstring(&b, ":");
Nenad Merdanovic38494732017-07-23 22:04:58 -0400953 snprintf(addr, INET_ADDRSTRLEN, "%d", srv->svc_port);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100954 luaL_addstring(&b, addr);
955 break;
956 case AF_INET6:
957 inet_ntop(AF_INET6, &((struct sockaddr_in6 *)&srv->addr)->sin6_addr,
Nenad Merdanovica9f04042017-07-23 22:04:59 -0400958 addr, INET6_ADDRSTRLEN);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100959 luaL_addstring(&b, addr);
960 luaL_addstring(&b, ":");
Nenad Merdanovic38494732017-07-23 22:04:58 -0400961 snprintf(addr, INET_ADDRSTRLEN, "%d", srv->svc_port);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100962 luaL_addstring(&b, addr);
963 break;
964 case AF_UNIX:
965 luaL_addstring(&b, (char *)((struct sockaddr_un *)&srv->addr)->sun_path);
966 break;
967 default:
968 luaL_addstring(&b, "<unknown>");
969 break;
970 }
971
972 luaL_pushresult(&b);
973 return 1;
974}
975
976int hlua_server_is_draining(lua_State *L)
977{
978 struct server *srv;
979
980 srv = hlua_check_server(L, 1);
981 lua_pushinteger(L, server_is_draining(srv));
982 return 1;
983}
984
Patrick Hemmer32d539f2018-04-29 14:25:46 -0400985int hlua_server_set_maxconn(lua_State *L)
986{
987 struct server *srv;
988 const char *maxconn;
989 const char *err;
990
991 srv = hlua_check_server(L, 1);
992 maxconn = luaL_checkstring(L, 2);
993
994 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
995 err = server_parse_maxconn_change_request(srv, maxconn);
996 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
997 if (!err)
998 lua_pushnil(L);
999 else
1000 hlua_pushstrippedstring(L, err);
1001 return 1;
1002}
1003
1004int hlua_server_get_maxconn(lua_State *L)
1005{
1006 struct server *srv;
1007
1008 srv = hlua_check_server(L, 1);
1009 lua_pushinteger(L, srv->maxconn);
1010 return 1;
1011}
1012
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001013int hlua_server_set_weight(lua_State *L)
1014{
1015 struct server *srv;
1016 const char *weight;
1017 const char *err;
1018
1019 srv = hlua_check_server(L, 1);
1020 weight = luaL_checkstring(L, 2);
1021
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001022 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001023 err = server_parse_weight_change_request(srv, weight);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001024 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001025 if (!err)
1026 lua_pushnil(L);
1027 else
1028 hlua_pushstrippedstring(L, err);
1029 return 1;
1030}
1031
1032int hlua_server_get_weight(lua_State *L)
1033{
1034 struct server *srv;
1035
1036 srv = hlua_check_server(L, 1);
1037 lua_pushinteger(L, srv->uweight);
1038 return 1;
1039}
1040
1041int hlua_server_set_addr(lua_State *L)
1042{
1043 struct server *srv;
1044 const char *addr;
Joseph C. Sible49bbf522020-05-04 22:20:32 -04001045 const char *port;
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001046 const char *err;
1047
1048 srv = hlua_check_server(L, 1);
1049 addr = luaL_checkstring(L, 2);
Joseph C. Sible49bbf522020-05-04 22:20:32 -04001050 if (lua_gettop(L) >= 3)
1051 port = luaL_checkstring(L, 3);
1052 else
1053 port = NULL;
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001054
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001055 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Joseph C. Sible49bbf522020-05-04 22:20:32 -04001056 err = update_server_addr_port(srv, addr, port, "Lua script");
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001057 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001058 if (!err)
1059 lua_pushnil(L);
1060 else
1061 hlua_pushstrippedstring(L, err);
1062 return 1;
1063}
1064
1065int hlua_server_shut_sess(lua_State *L)
1066{
1067 struct server *srv;
1068
1069 srv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001070 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001071 srv_shutdown_streams(srv, SF_ERR_KILLED);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001072 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001073 return 0;
1074}
1075
1076int hlua_server_set_drain(lua_State *L)
1077{
1078 struct server *srv;
1079
1080 srv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001081 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001082 srv_adm_set_drain(srv);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001083 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001084 return 0;
1085}
1086
1087int hlua_server_set_maint(lua_State *L)
1088{
1089 struct server *srv;
1090
1091 srv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001092 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001093 srv_adm_set_maint(srv);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001094 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001095 return 0;
1096}
1097
1098int hlua_server_set_ready(lua_State *L)
1099{
1100 struct server *srv;
1101
1102 srv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001103 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001104 srv_adm_set_ready(srv);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001105 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001106 return 0;
1107}
1108
1109int hlua_server_check_enable(lua_State *L)
1110{
1111 struct server *sv;
1112
1113 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001114 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001115 if (sv->check.state & CHK_ST_CONFIGURED) {
Adis Nezirovicceee9332017-07-26 09:19:06 +02001116 sv->check.state |= CHK_ST_ENABLED;
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001117 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001118 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001119 return 0;
1120}
1121
1122int hlua_server_check_disable(lua_State *L)
1123{
1124 struct server *sv;
1125
1126 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001127 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001128 if (sv->check.state & CHK_ST_CONFIGURED) {
Adis Nezirovicceee9332017-07-26 09:19:06 +02001129 sv->check.state &= ~CHK_ST_ENABLED;
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001130 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001131 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001132 return 0;
1133}
1134
1135int hlua_server_check_force_up(lua_State *L)
1136{
1137 struct server *sv;
1138
1139 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001140 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001141 if (!(sv->track)) {
1142 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02001143 srv_set_running(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001144 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001145 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001146 return 0;
1147}
1148
1149int hlua_server_check_force_nolb(lua_State *L)
1150{
1151 struct server *sv;
1152
1153 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001154 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001155 if (!(sv->track)) {
1156 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02001157 srv_set_stopping(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001158 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001159 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001160 return 0;
1161}
1162
1163int hlua_server_check_force_down(lua_State *L)
1164{
1165 struct server *sv;
1166
1167 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001168 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001169 if (!(sv->track)) {
1170 sv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02001171 srv_set_stopped(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001172 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001173 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001174 return 0;
1175}
1176
1177int hlua_server_agent_enable(lua_State *L)
1178{
1179 struct server *sv;
1180
1181 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001182 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001183 if (sv->agent.state & CHK_ST_CONFIGURED) {
1184 sv->agent.state |= CHK_ST_ENABLED;
1185 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001186 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001187 return 0;
1188}
1189
1190int hlua_server_agent_disable(lua_State *L)
1191{
1192 struct server *sv;
1193
1194 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001195 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001196 if (sv->agent.state & CHK_ST_CONFIGURED) {
1197 sv->agent.state &= ~CHK_ST_ENABLED;
1198 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001199 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001200 return 0;
1201}
1202
1203int hlua_server_agent_force_up(lua_State *L)
1204{
1205 struct server *sv;
1206
1207 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001208 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001209 if (sv->agent.state & CHK_ST_ENABLED) {
1210 sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +02001211 srv_set_running(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001212 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001213 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001214 return 0;
1215}
1216
1217int hlua_server_agent_force_down(lua_State *L)
1218{
1219 struct server *sv;
1220
1221 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001222 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001223 if (sv->agent.state & CHK_ST_ENABLED) {
1224 sv->agent.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +02001225 srv_set_stopped(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001226 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001227 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001228 return 0;
1229}
1230
Thierry Fournierf61aa632016-02-19 20:56:00 +01001231int hlua_fcn_new_proxy(lua_State *L, struct proxy *px)
1232{
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001233 struct server *srv;
Thierry Fournierff480422016-02-25 08:36:46 +01001234 struct listener *lst;
1235 int lid;
Willy Tarreau29d69802018-05-06 14:50:09 +02001236 char buffer[17];
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001237
Thierry Fournierf61aa632016-02-19 20:56:00 +01001238 lua_newtable(L);
1239
1240 /* Pop a class sesison metatable and affect it to the userdata. */
1241 lua_rawgeti(L, LUA_REGISTRYINDEX, class_proxy_ref);
1242 lua_setmetatable(L, -2);
1243
1244 lua_pushlightuserdata(L, px);
1245 lua_rawseti(L, -2, 0);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001246
Thierry FOURNIERf2bbe382017-07-24 13:59:22 +02001247 /* Add proxy name. */
1248 lua_pushstring(L, "name");
1249 lua_pushstring(L, px->id);
1250 lua_settable(L, -3);
1251
Baptiste Assmann46c72552017-10-26 21:51:58 +02001252 /* Add proxy uuid. */
1253 lua_pushstring(L, "uuid");
1254 snprintf(buffer, sizeof(buffer), "%d", px->uuid);
1255 lua_pushstring(L, buffer);
1256 lua_settable(L, -3);
1257
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001258 /* Browse and register servers. */
1259 lua_pushstring(L, "servers");
1260 lua_newtable(L);
1261 for (srv = px->srv; srv; srv = srv->next) {
1262 lua_pushstring(L, srv->id);
1263 hlua_fcn_new_server(L, srv);
1264 lua_settable(L, -3);
1265 }
1266 lua_settable(L, -3);
1267
Thierry Fournierff480422016-02-25 08:36:46 +01001268 /* Browse and register listeners. */
1269 lua_pushstring(L, "listeners");
1270 lua_newtable(L);
1271 lid = 1;
1272 list_for_each_entry(lst, &px->conf.listeners, by_fe) {
1273 if (lst->name)
1274 lua_pushstring(L, lst->name);
1275 else {
Willy Tarreau29d69802018-05-06 14:50:09 +02001276 snprintf(buffer, sizeof(buffer), "sock-%d", lid);
Thierry Fournierff480422016-02-25 08:36:46 +01001277 lid++;
1278 lua_pushstring(L, buffer);
1279 }
1280 hlua_fcn_new_listener(L, lst);
1281 lua_settable(L, -3);
1282 }
1283 lua_settable(L, -3);
1284
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001285 if (px->table && px->table->id) {
Adis Nezirovic8878f8e2018-07-13 12:18:33 +02001286 lua_pushstring(L, "stktable");
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001287 hlua_fcn_new_stktable(L, px->table);
Adis Nezirovic8878f8e2018-07-13 12:18:33 +02001288 lua_settable(L, -3);
1289 }
1290
Thierry Fournierf61aa632016-02-19 20:56:00 +01001291 return 1;
1292}
1293
1294static struct proxy *hlua_check_proxy(lua_State *L, int ud)
1295{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02001296 return hlua_checkudata(L, ud, class_proxy_ref);
Thierry Fournierf61aa632016-02-19 20:56:00 +01001297}
1298
1299int hlua_proxy_pause(lua_State *L)
1300{
1301 struct proxy *px;
1302
1303 px = hlua_check_proxy(L, 1);
1304 pause_proxy(px);
1305 return 0;
1306}
1307
1308int hlua_proxy_resume(lua_State *L)
1309{
1310 struct proxy *px;
1311
1312 px = hlua_check_proxy(L, 1);
1313 resume_proxy(px);
1314 return 0;
1315}
1316
1317int hlua_proxy_stop(lua_State *L)
1318{
1319 struct proxy *px;
1320
1321 px = hlua_check_proxy(L, 1);
1322 stop_proxy(px);
1323 return 0;
1324}
1325
1326int hlua_proxy_get_cap(lua_State *L)
1327{
1328 struct proxy *px;
1329 const char *str;
1330
1331 px = hlua_check_proxy(L, 1);
1332 str = proxy_cap_str(px->cap);
1333 lua_pushstring(L, str);
1334 return 1;
1335}
1336
1337int hlua_proxy_get_stats(lua_State *L)
1338{
1339 struct proxy *px;
1340 int i;
1341
1342 px = hlua_check_proxy(L, 1);
1343 if (px->cap & PR_CAP_BE)
Willy Tarreau708c4162019-10-09 10:19:16 +02001344 stats_fill_be_stats(px, STAT_SHLGNDS, stats, STATS_LEN);
Thierry Fournierf61aa632016-02-19 20:56:00 +01001345 else
1346 stats_fill_fe_stats(px, stats, STATS_LEN);
1347 lua_newtable(L);
1348 for (i=0; i<ST_F_TOTAL_FIELDS; i++) {
Willy Tarreaueaa55372019-10-09 07:39:11 +02001349 lua_pushstring(L, stat_fields[i].name);
Thierry Fournierf61aa632016-02-19 20:56:00 +01001350 hlua_fcn_pushfield(L, &stats[i]);
1351 lua_settable(L, -3);
1352 }
1353 return 1;
1354}
1355
1356int hlua_proxy_get_mode(lua_State *L)
1357{
1358 struct proxy *px;
1359 const char *str;
1360
1361 px = hlua_check_proxy(L, 1);
1362 str = proxy_mode_str(px->mode);
1363 lua_pushstring(L, str);
1364 return 1;
1365}
1366
1367int hlua_proxy_shut_bcksess(lua_State *L)
1368{
1369 struct proxy *px;
1370
1371 px = hlua_check_proxy(L, 1);
1372 srv_shutdown_backup_streams(px, SF_ERR_KILLED);
1373 return 0;
1374}
1375
Thierry Fournier3d4a6752016-02-19 20:53:30 +01001376int hlua_fcn_post_init(lua_State *L)
1377{
Thierry Fournierf61aa632016-02-19 20:56:00 +01001378 struct proxy *px;
1379
1380 /* get core array. */
1381 if (lua_getglobal(L, "core") != LUA_TTABLE)
1382 lua_error(L);
1383
1384 /* Create proxies entry. */
1385 lua_pushstring(L, "proxies");
1386 lua_newtable(L);
1387
1388 /* List all proxies. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001389 for (px = proxies_list; px; px = px->next) {
Thierry Fournierf61aa632016-02-19 20:56:00 +01001390 lua_pushstring(L, px->id);
1391 hlua_fcn_new_proxy(L, px);
1392 lua_settable(L, -3);
1393 }
1394
1395 /* push "proxies" in "core" */
1396 lua_settable(L, -3);
1397
Thierry FOURNIER9b82a582017-07-24 13:30:43 +02001398 /* Create proxies entry. */
1399 lua_pushstring(L, "frontends");
1400 lua_newtable(L);
1401
1402 /* List all proxies. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001403 for (px = proxies_list; px; px = px->next) {
Thierry FOURNIER9b82a582017-07-24 13:30:43 +02001404 if (!(px->cap & PR_CAP_FE))
1405 continue;
1406 lua_pushstring(L, px->id);
1407 hlua_fcn_new_proxy(L, px);
1408 lua_settable(L, -3);
1409 }
1410
1411 /* push "frontends" in "core" */
1412 lua_settable(L, -3);
1413
1414 /* Create proxies entry. */
1415 lua_pushstring(L, "backends");
1416 lua_newtable(L);
1417
1418 /* List all proxies. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01001419 for (px = proxies_list; px; px = px->next) {
Thierry FOURNIER9b82a582017-07-24 13:30:43 +02001420 if (!(px->cap & PR_CAP_BE))
1421 continue;
1422 lua_pushstring(L, px->id);
1423 hlua_fcn_new_proxy(L, px);
1424 lua_settable(L, -3);
1425 }
1426
1427 /* push "backend" in "core" */
1428 lua_settable(L, -3);
1429
Thierry Fournier3d4a6752016-02-19 20:53:30 +01001430 return 1;
1431}
1432
Thierry FOURNIER / OZON.IO8a1027a2016-11-24 20:48:38 +01001433/* This Lua function take a string, a list of separators.
1434 * It tokenize the input string using the list of separators
1435 * as separator.
1436 *
Ilya Shipitsince7b00f2020-03-23 22:28:40 +05001437 * The functionreturns a table filled with tokens.
Thierry FOURNIER / OZON.IO8a1027a2016-11-24 20:48:38 +01001438 */
1439int hlua_tokenize(lua_State *L)
1440{
1441 const char *str;
1442 const char *sep;
1443 int index;
1444 const char *token;
1445 const char *p;
1446 const char *c;
1447 int ignore_empty;
1448
1449 ignore_empty = 0;
1450
1451 str = luaL_checkstring(L, 1);
1452 sep = luaL_checkstring(L, 2);
1453 if (lua_gettop(L) == 3)
1454 ignore_empty = hlua_checkboolean(L, 3);
1455
1456 lua_newtable(L);
1457 index = 1;
1458 token = str;
1459 p = str;
1460 while(1) {
1461 for (c = sep; *c != '\0'; c++)
1462 if (*p == *c)
1463 break;
1464 if (*p == *c) {
1465 if ((!ignore_empty) || (p - token > 0)) {
1466 lua_pushlstring(L, token, p - token);
1467 lua_rawseti(L, -2, index);
1468 index++;
1469 }
1470 token = p + 1;
1471 }
1472 if (*p == '\0')
1473 break;
1474 p++;
1475 }
1476
1477 return 1;
1478}
1479
Thierry FOURNIER / OZON.IO62fec752016-11-10 20:38:11 +01001480int hlua_parse_addr(lua_State *L)
1481{
1482 struct hlua_addr *addr;
1483 const char *str = luaL_checkstring(L, 1);
1484 unsigned char mask;
1485
1486 addr = lua_newuserdata(L, sizeof(struct hlua_addr));
1487 if (!addr) {
1488 lua_pushnil(L);
1489 return 1;
1490 }
1491
1492 if (str2net(str, PAT_MF_NO_DNS, &addr->addr.v4.ip, &addr->addr.v4.mask)) {
1493 addr->type = AF_INET;
1494 return 1;
1495 }
1496
1497 if (str62net(str, &addr->addr.v6.ip, &mask)) {
1498 len2mask6(mask, &addr->addr.v6.mask);
1499 addr->type = AF_INET6;
1500 return 1;
1501 }
1502
1503 lua_pop(L, 1);
1504 lua_pushnil(L);
1505 return 1;
1506}
1507
1508int hlua_match_addr(lua_State *L)
1509{
1510 struct hlua_addr *addr1;
1511 struct hlua_addr *addr2;
1512
1513 if (!lua_isuserdata(L, 1) ||
1514 !lua_isuserdata(L, 2)) {
1515 lua_pushboolean(L, 0);
1516 return 1;
1517 }
1518
1519 addr1 = lua_touserdata(L, 1);
1520 addr2 = lua_touserdata(L, 2);
1521
1522 if (addr1->type != addr2->type) {
1523 lua_pushboolean(L, 0);
1524 return 1;
1525 }
1526
1527 if (addr1->type == AF_INET) {
1528 if ((addr1->addr.v4.ip.s_addr & addr2->addr.v4.mask.s_addr) ==
1529 (addr2->addr.v4.ip.s_addr & addr1->addr.v4.mask.s_addr)) {
1530 lua_pushboolean(L, 1);
1531 return 1;
1532 }
1533 } else {
Thierry FOURNIERde6925e2016-12-23 17:03:25 +01001534 int i;
1535
1536 for (i = 0; i < 16; i += 4) {
Willy Tarreau26474c42020-02-25 10:02:51 +01001537 if ((read_u32(&addr1->addr.v6.ip.s6_addr[i]) &
1538 read_u32(&addr2->addr.v6.mask.s6_addr[i])) !=
1539 (read_u32(&addr2->addr.v6.ip.s6_addr[i]) &
1540 read_u32(&addr1->addr.v6.mask.s6_addr[i])))
Thierry FOURNIERde6925e2016-12-23 17:03:25 +01001541 break;
1542 }
1543 if (i == 16) {
Thierry FOURNIER / OZON.IO62fec752016-11-10 20:38:11 +01001544 lua_pushboolean(L, 1);
1545 return 1;
1546 }
1547 }
1548
1549 lua_pushboolean(L, 0);
1550 return 1;
1551}
1552
Dragan Dosen26743032019-04-30 15:54:36 +02001553static struct my_regex **hlua_check_regex(lua_State *L, int ud)
Thierry FOURNIER31904272017-10-25 12:59:51 +02001554{
1555 return (hlua_checkudata(L, ud, class_regex_ref));
1556}
1557
1558static int hlua_regex_comp(struct lua_State *L)
1559{
Dragan Dosen26743032019-04-30 15:54:36 +02001560 struct my_regex **regex;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001561 const char *str;
1562 int cs;
1563 char *err;
1564
1565 str = luaL_checkstring(L, 1);
1566 luaL_argcheck(L, lua_isboolean(L, 2), 2, NULL);
1567 cs = lua_toboolean(L, 2);
1568
1569 regex = lua_newuserdata(L, sizeof(*regex));
1570
1571 err = NULL;
Dragan Dosen26743032019-04-30 15:54:36 +02001572 if (!(*regex = regex_comp(str, cs, 1, &err))) {
Thierry FOURNIER31904272017-10-25 12:59:51 +02001573 lua_pushboolean(L, 0); /* status error */
1574 lua_pushstring(L, err); /* Reason */
1575 free(err);
1576 return 2;
1577 }
1578
1579 lua_pushboolean(L, 1); /* Status ok */
1580
1581 /* Create object */
1582 lua_newtable(L);
1583 lua_pushvalue(L, -3); /* Get the userdata pointer. */
1584 lua_rawseti(L, -2, 0);
1585 lua_rawgeti(L, LUA_REGISTRYINDEX, class_regex_ref);
1586 lua_setmetatable(L, -2);
1587 return 2;
1588}
1589
1590static int hlua_regex_exec(struct lua_State *L)
1591{
Dragan Dosen26743032019-04-30 15:54:36 +02001592 struct my_regex **regex;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001593 const char *str;
1594 size_t len;
Willy Tarreau83061a82018-07-13 11:56:34 +02001595 struct buffer *tmp;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001596
1597 regex = hlua_check_regex(L, 1);
1598 str = luaL_checklstring(L, 2, &len);
1599
Dragan Dosen26743032019-04-30 15:54:36 +02001600 if (!*regex) {
1601 lua_pushboolean(L, 0);
1602 return 1;
1603 }
1604
Thierry FOURNIER7c210e62017-10-27 14:13:51 +02001605 /* Copy the string because regex_exec2 require a 'char *'
1606 * and not a 'const char *'.
1607 */
1608 tmp = get_trash_chunk();
1609 if (len >= tmp->size) {
1610 lua_pushboolean(L, 0);
1611 return 1;
1612 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001613 memcpy(tmp->area, str, len);
Thierry FOURNIER7c210e62017-10-27 14:13:51 +02001614
Dragan Dosen26743032019-04-30 15:54:36 +02001615 lua_pushboolean(L, regex_exec2(*regex, tmp->area, len));
Thierry FOURNIER31904272017-10-25 12:59:51 +02001616
1617 return 1;
1618}
1619
1620static int hlua_regex_match(struct lua_State *L)
1621{
Dragan Dosen26743032019-04-30 15:54:36 +02001622 struct my_regex **regex;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001623 const char *str;
1624 size_t len;
1625 regmatch_t pmatch[20];
1626 int ret;
1627 int i;
Willy Tarreau83061a82018-07-13 11:56:34 +02001628 struct buffer *tmp;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001629
1630 regex = hlua_check_regex(L, 1);
1631 str = luaL_checklstring(L, 2, &len);
1632
Dragan Dosen26743032019-04-30 15:54:36 +02001633 if (!*regex) {
1634 lua_pushboolean(L, 0);
1635 return 1;
1636 }
1637
Thierry FOURNIER7c210e62017-10-27 14:13:51 +02001638 /* Copy the string because regex_exec2 require a 'char *'
1639 * and not a 'const char *'.
1640 */
1641 tmp = get_trash_chunk();
1642 if (len >= tmp->size) {
1643 lua_pushboolean(L, 0);
1644 return 1;
1645 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001646 memcpy(tmp->area, str, len);
Thierry FOURNIER7c210e62017-10-27 14:13:51 +02001647
Dragan Dosen26743032019-04-30 15:54:36 +02001648 ret = regex_exec_match2(*regex, tmp->area, len, 20, pmatch, 0);
Thierry FOURNIER31904272017-10-25 12:59:51 +02001649 lua_pushboolean(L, ret);
1650 lua_newtable(L);
1651 if (ret) {
1652 for (i = 0; i < 20 && pmatch[i].rm_so != -1; i++) {
1653 lua_pushlstring(L, str + pmatch[i].rm_so, pmatch[i].rm_eo - pmatch[i].rm_so);
1654 lua_rawseti(L, -2, i + 1);
1655 }
1656 }
1657 return 2;
1658}
1659
1660static int hlua_regex_free(struct lua_State *L)
1661{
Dragan Dosen26743032019-04-30 15:54:36 +02001662 struct my_regex **regex;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001663
1664 regex = hlua_check_regex(L, 1);
Dragan Dosen26743032019-04-30 15:54:36 +02001665 regex_free(*regex);
1666 *regex = NULL;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001667 return 0;
1668}
1669
Thierry Fournierfb0b5462016-01-21 09:28:58 +01001670int hlua_fcn_reg_core_fcn(lua_State *L)
1671{
Thierry Fournier1de16592016-01-27 09:49:07 +01001672 if (!hlua_concat_init(L))
1673 return 0;
1674
Thierry Fournier4f99b272016-02-22 08:40:02 +01001675 hlua_class_function(L, "now", hlua_now);
1676 hlua_class_function(L, "http_date", hlua_http_date);
1677 hlua_class_function(L, "imf_date", hlua_imf_date);
1678 hlua_class_function(L, "rfc850_date", hlua_rfc850_date);
1679 hlua_class_function(L, "asctime_date", hlua_asctime_date);
1680 hlua_class_function(L, "concat", hlua_concat_new);
Thierry Fourniereea77c02016-03-18 08:47:13 +01001681 hlua_class_function(L, "get_info", hlua_get_info);
Thierry FOURNIER / OZON.IO62fec752016-11-10 20:38:11 +01001682 hlua_class_function(L, "parse_addr", hlua_parse_addr);
1683 hlua_class_function(L, "match_addr", hlua_match_addr);
Thierry FOURNIER / OZON.IO8a1027a2016-11-24 20:48:38 +01001684 hlua_class_function(L, "tokenize", hlua_tokenize);
Thierry Fournier4f99b272016-02-22 08:40:02 +01001685
Thierry FOURNIER31904272017-10-25 12:59:51 +02001686 /* Create regex object. */
1687 lua_newtable(L);
1688 hlua_class_function(L, "new", hlua_regex_comp);
1689
1690 lua_newtable(L); /* The metatable. */
1691 lua_pushstring(L, "__index");
1692 lua_newtable(L);
1693 hlua_class_function(L, "exec", hlua_regex_exec);
1694 hlua_class_function(L, "match", hlua_regex_match);
1695 lua_rawset(L, -3); /* -> META["__index"] = TABLE */
1696 hlua_class_function(L, "__gc", hlua_regex_free);
1697
1698 lua_pushvalue(L, -1); /* Duplicate the metatable reference. */
1699 class_regex_ref = hlua_register_metatable(L, CLASS_REGEX);
1700
1701 lua_setmetatable(L, -2);
1702 lua_setglobal(L, CLASS_REGEX); /* Create global object called Regex */
1703
Adis Nezirovic8878f8e2018-07-13 12:18:33 +02001704 /* Create stktable object. */
1705 lua_newtable(L);
1706 lua_pushstring(L, "__index");
1707 lua_newtable(L);
1708 hlua_class_function(L, "info", hlua_stktable_info);
1709 hlua_class_function(L, "lookup", hlua_stktable_lookup);
1710 hlua_class_function(L, "dump", hlua_stktable_dump);
1711 lua_settable(L, -3); /* -> META["__index"] = TABLE */
1712 class_stktable_ref = hlua_register_metatable(L, CLASS_STKTABLE);
1713
Thierry Fournierff480422016-02-25 08:36:46 +01001714 /* Create listener object. */
1715 lua_newtable(L);
1716 lua_pushstring(L, "__index");
1717 lua_newtable(L);
1718 hlua_class_function(L, "get_stats", hlua_listener_get_stats);
1719 lua_settable(L, -3); /* -> META["__index"] = TABLE */
1720 class_listener_ref = hlua_register_metatable(L, CLASS_LISTENER);
1721
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001722 /* Create server object. */
1723 lua_newtable(L);
1724 lua_pushstring(L, "__index");
1725 lua_newtable(L);
1726 hlua_class_function(L, "is_draining", hlua_server_is_draining);
Patrick Hemmer32d539f2018-04-29 14:25:46 -04001727 hlua_class_function(L, "set_maxconn", hlua_server_set_maxconn);
1728 hlua_class_function(L, "get_maxconn", hlua_server_get_maxconn);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001729 hlua_class_function(L, "set_weight", hlua_server_set_weight);
1730 hlua_class_function(L, "get_weight", hlua_server_get_weight);
1731 hlua_class_function(L, "set_addr", hlua_server_set_addr);
1732 hlua_class_function(L, "get_addr", hlua_server_get_addr);
1733 hlua_class_function(L, "get_stats", hlua_server_get_stats);
1734 hlua_class_function(L, "shut_sess", hlua_server_shut_sess);
1735 hlua_class_function(L, "set_drain", hlua_server_set_drain);
1736 hlua_class_function(L, "set_maint", hlua_server_set_maint);
1737 hlua_class_function(L, "set_ready", hlua_server_set_ready);
1738 hlua_class_function(L, "check_enable", hlua_server_check_enable);
1739 hlua_class_function(L, "check_disable", hlua_server_check_disable);
1740 hlua_class_function(L, "check_force_up", hlua_server_check_force_up);
1741 hlua_class_function(L, "check_force_nolb", hlua_server_check_force_nolb);
1742 hlua_class_function(L, "check_force_down", hlua_server_check_force_down);
1743 hlua_class_function(L, "agent_enable", hlua_server_agent_enable);
1744 hlua_class_function(L, "agent_disable", hlua_server_agent_disable);
1745 hlua_class_function(L, "agent_force_up", hlua_server_agent_force_up);
1746 hlua_class_function(L, "agent_force_down", hlua_server_agent_force_down);
1747 lua_settable(L, -3); /* -> META["__index"] = TABLE */
1748 class_server_ref = hlua_register_metatable(L, CLASS_SERVER);
1749
Thierry Fournierf61aa632016-02-19 20:56:00 +01001750 /* Create proxy object. */
1751 lua_newtable(L);
1752 lua_pushstring(L, "__index");
1753 lua_newtable(L);
1754 hlua_class_function(L, "pause", hlua_proxy_pause);
1755 hlua_class_function(L, "resume", hlua_proxy_resume);
1756 hlua_class_function(L, "stop", hlua_proxy_stop);
1757 hlua_class_function(L, "shut_bcksess", hlua_proxy_shut_bcksess);
1758 hlua_class_function(L, "get_cap", hlua_proxy_get_cap);
1759 hlua_class_function(L, "get_mode", hlua_proxy_get_mode);
1760 hlua_class_function(L, "get_stats", hlua_proxy_get_stats);
1761 lua_settable(L, -3); /* -> META["__index"] = TABLE */
1762 class_proxy_ref = hlua_register_metatable(L, CLASS_PROXY);
1763
Thierry Fournier1550d5d2016-01-21 09:35:41 +01001764 return 5;
Thierry Fournierfb0b5462016-01-21 09:28:58 +01001765}