blob: 60becb02f1489e79200f5483b51f247c7be60ad9 [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 Fournier94ed1c12016-02-24 08:06:32 +010029#include <proto/proto_http.h>
Thierry Fournierf61aa632016-02-19 20:56:00 +010030#include <proto/proxy.h>
31#include <proto/server.h>
William Lallemand9ed62032016-11-21 17:49:11 +010032#include <proto/stats.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;
Thierry Fournier1de16592016-01-27 09:49:07 +010040
Thierry Fournierf61aa632016-02-19 20:56:00 +010041#define STATS_LEN (MAX((int)ST_F_TOTAL_FIELDS, (int)INF_TOTAL_FIELDS))
Thierry Fourniereea77c02016-03-18 08:47:13 +010042
Thierry FOURNIERffbad792017-07-12 11:39:04 +020043static THREAD_LOCAL struct field stats[STATS_LEN];
Thierry Fourniereea77c02016-03-18 08:47:13 +010044
Thierry FOURNIER / OZON.IO7f3aa8b2016-11-24 20:37:38 +010045int hlua_checkboolean(lua_State *L, int index)
46{
47 if (!lua_isboolean(L, index))
48 luaL_argerror(L, index, "boolean expected");
49 return lua_toboolean(L, index);
50}
51
Thierry Fournier8b0d6e12016-03-16 18:29:13 +010052/* This function gets a struct field and convert it in Lua
53 * variable. The variable is pushed at the top of the stak.
54 */
55int hlua_fcn_pushfield(lua_State *L, struct field *field)
56{
57 /* The lua_Integer is always signed. Its length depends on
58 * compilation opions, so the followinfg code is conditionned
59 * by some macros. Windows maros are not supported.
60 * If the number cannot be represented as integer, we try to
61 * convert to float.
62 */
63 switch (field_format(field, 0)) {
64
65 case FF_EMPTY:
66 lua_pushnil(L);
67 return 1;
68
69 case FF_S32:
70 /* S32 is always supported. */
71 lua_pushinteger(L, field->u.s32);
72 return 1;
73
74 case FF_U32:
75#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))
76 /* 64 bits case, U32 is always supported */
77 lua_pushinteger(L, field->u.u32);
78#else
79 /* 32 bits case, U32 is supported until INT_MAX. */
80 if (field->u.u32 > INT_MAX)
81 lua_pushnumber(L, (lua_Number)field->u.u32);
82 else
83 lua_pushinteger(L, field->u.u32);
84#endif
85 return 1;
86
87 case FF_S64:
88#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))
89 /* 64 bits case, S64 is always supported */
90 lua_pushinteger(L, field->u.s64);
91#else
92 /* 64 bits case, S64 is supported beetween INT_MIN and INT_MAX */
93 if (field->u.s64 < INT_MIN || field->u.s64 > INT_MAX)
94 lua_pushnumber(L, (lua_Number)field->u.s64);
95 else
96 lua_pushinteger(L, (int)field->u.s64);
97#endif
98 return 1;
99
100 case FF_U64:
101#if (LUA_MAXINTEGER == LLONG_MAX || ((LUA_MAXINTEGER == LONG_MAX) && (__WORDSIZE == 64)))
102 /* 64 bits case, U64 is supported until LLONG_MAX */
103 if (field->u.u64 > LLONG_MAX)
104 lua_pushnumber(L, (lua_Number)field->u.u64);
105 else
106 lua_pushinteger(L, field->u.u64);
107#else
108 /* 64 bits case, U64 is supported until INT_MAX */
109 if (field->u.u64 > INT_MAX)
110 lua_pushnumber(L, (lua_Number)field->u.u64);
111 else
112 lua_pushinteger(L, (int)field->u.u64);
113#endif
114 return 1;
115
116 case FF_STR:
117 lua_pushstring(L, field->u.str);
118 return 1;
119
120 default:
121 break;
122 }
123
124 /* Default case, never reached. */
125 lua_pushnil(L);
126 return 1;
127}
128
Thierry Fournier94ed1c12016-02-24 08:06:32 +0100129/* Some string are started or terminated by blank chars,
130 * this function removes the spaces, tabs, \r and
131 * \n at the begin and at the end of the string "str", and
132 * push the result in the lua stack.
133 * Returns a pointer to the Lua internal copy of the string.
134 */
135const char *hlua_pushstrippedstring(lua_State *L, const char *str)
136{
137 const char *p;
138 const char *e;
139
140 for (p = str; HTTP_IS_LWS(*p); p++);
141 for (e = p + strlen(p) - 1; e > p && HTTP_IS_LWS(*e); e--);
142
143 return lua_pushlstring(L, p, e - p);
144}
145
Thierry Fournierddd89882016-02-22 19:52:08 +0100146/* The three following functions are useful for adding entries
147 * in a table. These functions takes a string and respectively an
148 * integer, a string or a function and add it to the table in the
149 * top of the stack.
150 *
151 * These functions throws an error if no more stack size is
152 * available.
153 */
154void hlua_class_const_int(lua_State *L, const char *name, int value)
155{
Thierry Fournierddd89882016-02-22 19:52:08 +0100156 lua_pushstring(L, name);
157 lua_pushinteger(L, value);
158 lua_rawset(L, -3);
159}
160void hlua_class_const_str(lua_State *L, const char *name, const char *value)
161{
Thierry Fournierddd89882016-02-22 19:52:08 +0100162 lua_pushstring(L, name);
163 lua_pushstring(L, value);
164 lua_rawset(L, -3);
165}
166void hlua_class_function(lua_State *L, const char *name, int (*function)(lua_State *L))
167{
Thierry Fournierddd89882016-02-22 19:52:08 +0100168 lua_pushstring(L, name);
169 lua_pushcclosure(L, function, 0);
170 lua_rawset(L, -3);
171}
172
173/* This function returns a string containg the HAProxy object name. */
174int hlua_dump_object(struct lua_State *L)
175{
176 const char *name = (const char *)lua_tostring(L, lua_upvalueindex(1));
177 lua_pushfstring(L, "HAProxy class %s", name);
178 return 1;
179}
180
Thierry Fournier45e78d72016-02-19 18:34:46 +0100181/* This function register a table as metatable and. It names
182 * the metatable, and returns the associated reference.
183 * The original table is poped from the top of the stack.
184 * "name" is the referenced class name.
185 */
186int hlua_register_metatable(struct lua_State *L, char *name)
187{
188 /* Check the type of the top element. it must be
189 * a table.
190 */
191 if (lua_type(L, -1) != LUA_TTABLE)
192 luaL_error(L, "hlua_register_metatable() requires a type Table "
193 "in the top of the stack");
194
195 /* Add the __tostring function which identify the
196 * created object.
197 */
198 lua_pushstring(L, "__tostring");
199 lua_pushstring(L, name);
200 lua_pushcclosure(L, hlua_dump_object, 1);
201 lua_rawset(L, -3);
202
203 /* Register a named entry for the table. The table
204 * reference is copyed first because the function
205 * lua_setfield() pop the entry.
206 */
207 lua_pushvalue(L, -1);
208 lua_setfield(L, LUA_REGISTRYINDEX, name);
209
210 /* Creates the reference of the object. The
211 * function luaL_ref pop the top of the stack.
212 */
213 return luaL_ref(L, LUA_REGISTRYINDEX);
214}
215
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100216/* Return an object of the expected type, or throws an error. */
217void *hlua_checkudata(lua_State *L, int ud, int class_ref)
218{
219 void *p;
Thierry Fournier53518272016-01-27 10:34:09 +0100220 int ret;
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100221
222 /* Check if the stack entry is an array. */
223 if (!lua_istable(L, ud))
Thierry Fournier53518272016-01-27 10:34:09 +0100224 luaL_argerror(L, ud, NULL);
225
226 /* pop the metatable of the referencecd object. */
227 if (!lua_getmetatable(L, ud))
228 luaL_argerror(L, ud, NULL);
229
230 /* pop the expected metatable. */
231 lua_rawgeti(L, LUA_REGISTRYINDEX, class_ref);
232
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100233 /* Check if the metadata have the expected type. */
Thierry Fournier53518272016-01-27 10:34:09 +0100234 ret = lua_rawequal(L, -1, -2);
235 lua_pop(L, 2);
236 if (!ret)
237 luaL_argerror(L, ud, NULL);
238
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100239 /* Push on the stack at the entry [0] of the table. */
240 lua_rawgeti(L, ud, 0);
Thierry Fournier53518272016-01-27 10:34:09 +0100241
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100242 /* Check if this entry is userdata. */
243 p = lua_touserdata(L, -1);
244 if (!p)
Thierry Fournier53518272016-01-27 10:34:09 +0100245 luaL_argerror(L, ud, NULL);
246
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100247 /* Remove the entry returned by lua_rawgeti(). */
248 lua_pop(L, 1);
Thierry Fournier53518272016-01-27 10:34:09 +0100249
Thierry Fournier9e7e3ea2016-01-27 09:55:30 +0100250 /* Return the associated struct. */
251 return p;
252}
253
Thierry Fournierb1f46562016-01-21 09:46:15 +0100254/* This function return the current date at epoch format in milliseconds. */
255int hlua_now(lua_State *L)
256{
257 lua_newtable(L);
258 lua_pushstring(L, "sec");
259 lua_pushinteger(L, now.tv_sec);
260 lua_rawset(L, -3);
261 lua_pushstring(L, "usec");
262 lua_pushinteger(L, now.tv_usec);
263 lua_rawset(L, -3);
264 return 1;
265}
266
Thierry Fournier1550d5d2016-01-21 09:35:41 +0100267/* This functions expects a Lua string as HTTP date, parse it and
268 * returns an integer containing the epoch format of the date, or
269 * nil if the parsing fails.
270 */
271static int hlua_parse_date(lua_State *L, int (*fcn)(const char *, int, struct tm*))
272{
273 const char *str;
274 size_t len;
275 struct tm tm;
276 time_t time;
277
278 str = luaL_checklstring(L, 1, &len);
279
280 if (!fcn(str, len, &tm)) {
281 lua_pushnil(L);
282 return 1;
283 }
284
285 /* This function considers the content of the broken-down time
286 * is exprimed in the UTC timezone. timegm don't care about
287 * the gnu variable tm_gmtoff. If gmtoff is set, or if you know
288 * the timezone from the broken-down time, it must be fixed
289 * after the conversion.
290 */
Willy Tarreauabd9bb22017-07-19 19:08:48 +0200291 time = my_timegm(&tm);
Thierry Fournier1550d5d2016-01-21 09:35:41 +0100292 if (time == -1) {
293 lua_pushnil(L);
294 return 1;
295 }
296
297 lua_pushinteger(L, (int)time);
298 return 1;
299}
300static int hlua_http_date(lua_State *L)
301{
302 return hlua_parse_date(L, parse_http_date);
303}
304static int hlua_imf_date(lua_State *L)
305{
306 return hlua_parse_date(L, parse_imf_date);
307}
308static int hlua_rfc850_date(lua_State *L)
309{
310 return hlua_parse_date(L, parse_rfc850_date);
311}
312static int hlua_asctime_date(lua_State *L)
313{
314 return hlua_parse_date(L, parse_asctime_date);
315}
316
Thierry Fourniereea77c02016-03-18 08:47:13 +0100317static int hlua_get_info(lua_State *L)
318{
319 int i;
320
321 stats_fill_info(stats, STATS_LEN);
322
323 lua_newtable(L);
324 for (i=0; i<INF_TOTAL_FIELDS; i++) {
325 lua_pushstring(L, info_field_names[i]);
326 hlua_fcn_pushfield(L, &stats[i]);
327 lua_settable(L, -3);
328 }
329 return 1;
330}
331
Thierry Fournier49d48422016-02-19 12:09:29 +0100332static struct hlua_concat *hlua_check_concat(lua_State *L, int ud)
Thierry Fournier1de16592016-01-27 09:49:07 +0100333{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200334 return (hlua_checkudata(L, ud, class_concat_ref));
Thierry Fournier1de16592016-01-27 09:49:07 +0100335}
336
337static int hlua_concat_add(lua_State *L)
338{
Thierry Fournier49d48422016-02-19 12:09:29 +0100339 struct hlua_concat *b;
340 char *buffer;
341 char *new;
Thierry Fournier1de16592016-01-27 09:49:07 +0100342 const char *str;
343 size_t l;
344
345 /* First arg must be a concat object. */
346 b = hlua_check_concat(L, 1);
347
348 /* Second arg must be a string. */
349 str = luaL_checklstring(L, 2, &l);
350
Thierry Fournier49d48422016-02-19 12:09:29 +0100351 /* Get the buffer. */
352 lua_rawgeti(L, 1, 1);
353 buffer = lua_touserdata(L, -1);
354 lua_pop(L, 1);
355
356 /* Update the buffer size if it s required. The old buffer
357 * is crushed by the new in the object array, so it will
358 * be deleted by the GC.
359 * Note that in the first loop, the "new" variable is only
360 * used as a flag.
361 */
362 new = NULL;
363 while (b->size - b->len < l) {
364 b->size += HLUA_CONCAT_BLOCSZ;
365 new = buffer;
366 }
367 if (new) {
368 new = lua_newuserdata(L, b->size);
369 memcpy(new, buffer, b->len);
370 lua_rawseti(L, 1, 1);
371 buffer = new;
372 }
373
374 /* Copy string, and update metadata. */
375 memcpy(buffer + b->len, str, l);
376 b->len += l;
Thierry Fournier1de16592016-01-27 09:49:07 +0100377 return 0;
378}
379
380static int hlua_concat_dump(lua_State *L)
381{
Thierry Fournier49d48422016-02-19 12:09:29 +0100382 struct hlua_concat *b;
383 char *buffer;
Thierry Fournier1de16592016-01-27 09:49:07 +0100384
385 /* First arg must be a concat object. */
386 b = hlua_check_concat(L, 1);
387
Thierry Fournier49d48422016-02-19 12:09:29 +0100388 /* Get the buffer. */
389 lua_rawgeti(L, 1, 1);
390 buffer = lua_touserdata(L, -1);
391 lua_pop(L, 1);
392
Thierry Fournier1de16592016-01-27 09:49:07 +0100393 /* Push the soncatenated strng in the stack. */
Thierry Fournier49d48422016-02-19 12:09:29 +0100394 lua_pushlstring(L, buffer, b->len);
Thierry Fournier1de16592016-01-27 09:49:07 +0100395 return 1;
396}
397
398int hlua_concat_new(lua_State *L)
399{
Thierry Fournier49d48422016-02-19 12:09:29 +0100400 struct hlua_concat *b;
Thierry Fournier1de16592016-01-27 09:49:07 +0100401
402 lua_newtable(L);
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200403 b = lua_newuserdata(L, sizeof(*b));
Thierry Fournier49d48422016-02-19 12:09:29 +0100404 b->size = HLUA_CONCAT_BLOCSZ;
405 b->len = 0;
Thierry Fournier1de16592016-01-27 09:49:07 +0100406 lua_rawseti(L, -2, 0);
Thierry Fournier49d48422016-02-19 12:09:29 +0100407 lua_newuserdata(L, HLUA_CONCAT_BLOCSZ);
408 lua_rawseti(L, -2, 1);
Thierry Fournier1de16592016-01-27 09:49:07 +0100409
410 lua_rawgeti(L, LUA_REGISTRYINDEX, class_concat_ref);
411 lua_setmetatable(L, -2);
412
Thierry Fournier1de16592016-01-27 09:49:07 +0100413 return 1;
414}
415
416static int concat_tostring(lua_State *L)
417{
418 const void *ptr = lua_topointer(L, 1);
419 lua_pushfstring(L, "Concat object: %p", ptr);
420 return 1;
421}
422
423static int hlua_concat_init(lua_State *L)
424{
425 /* Creates the buffered concat object. */
426 lua_newtable(L);
427
428 lua_pushstring(L, "__tostring");
429 lua_pushcclosure(L, concat_tostring, 0);
430 lua_settable(L, -3);
431
432 lua_pushstring(L, "__index"); /* Creates the index entry. */
433 lua_newtable(L); /* The "__index" content. */
434
435 lua_pushstring(L, "add");
436 lua_pushcclosure(L, hlua_concat_add, 0);
437 lua_settable(L, -3);
438
439 lua_pushstring(L, "dump");
440 lua_pushcclosure(L, hlua_concat_dump, 0);
441 lua_settable(L, -3);
442
443 lua_settable(L, -3); /* Sets the __index entry. */
444 class_concat_ref = luaL_ref(L, LUA_REGISTRYINDEX);
445
446 return 1;
447}
448
Thierry Fournierff480422016-02-25 08:36:46 +0100449int hlua_fcn_new_listener(lua_State *L, struct listener *lst)
450{
451 lua_newtable(L);
452
453 /* Pop a class sesison metatable and affect it to the userdata. */
454 lua_rawgeti(L, LUA_REGISTRYINDEX, class_listener_ref);
455 lua_setmetatable(L, -2);
456
457 lua_pushlightuserdata(L, lst);
458 lua_rawseti(L, -2, 0);
459 return 1;
460}
461
462static struct listener *hlua_check_listener(lua_State *L, int ud)
463{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200464 return hlua_checkudata(L, ud, class_listener_ref);
Thierry Fournierff480422016-02-25 08:36:46 +0100465}
466
467int hlua_listener_get_stats(lua_State *L)
468{
469 struct listener *li;
470 int i;
471
472 li = hlua_check_listener(L, 1);
473
Willy Tarreauc95bad52016-12-22 00:13:31 +0100474 if (!li->bind_conf->frontend) {
Thierry Fournierff480422016-02-25 08:36:46 +0100475 lua_pushnil(L);
476 return 1;
477 }
478
Willy Tarreauc95bad52016-12-22 00:13:31 +0100479 stats_fill_li_stats(li->bind_conf->frontend, li, ST_SHLGNDS, stats, STATS_LEN);
Thierry Fournierff480422016-02-25 08:36:46 +0100480
481 lua_newtable(L);
482 for (i=0; i<ST_F_TOTAL_FIELDS; i++) {
483 lua_pushstring(L, stat_field_names[i]);
484 hlua_fcn_pushfield(L, &stats[i]);
485 lua_settable(L, -3);
486 }
487 return 1;
488
489}
490
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100491int hlua_fcn_new_server(lua_State *L, struct server *srv)
492{
493 lua_newtable(L);
494
495 /* Pop a class sesison metatable and affect it to the userdata. */
496 lua_rawgeti(L, LUA_REGISTRYINDEX, class_server_ref);
497 lua_setmetatable(L, -2);
498
499 lua_pushlightuserdata(L, srv);
500 lua_rawseti(L, -2, 0);
501 return 1;
502}
503
504static struct server *hlua_check_server(lua_State *L, int ud)
505{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200506 return hlua_checkudata(L, ud, class_server_ref);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100507}
508
509int hlua_server_get_stats(lua_State *L)
510{
511 struct server *srv;
512 int i;
513
514 srv = hlua_check_server(L, 1);
515
516 if (!srv->proxy) {
517 lua_pushnil(L);
518 return 1;
519 }
520
521 stats_fill_sv_stats(srv->proxy, srv, ST_SHLGNDS, stats, STATS_LEN);
522
523 lua_newtable(L);
524 for (i=0; i<ST_F_TOTAL_FIELDS; i++) {
525 lua_pushstring(L, stat_field_names[i]);
526 hlua_fcn_pushfield(L, &stats[i]);
527 lua_settable(L, -3);
528 }
529 return 1;
530
531}
532
533int hlua_server_get_addr(lua_State *L)
534{
535 struct server *srv;
536 char addr[INET6_ADDRSTRLEN];
537 luaL_Buffer b;
538
539 srv = hlua_check_server(L, 1);
540
541 luaL_buffinit(L, &b);
542
543 switch (srv->addr.ss_family) {
544 case AF_INET:
545 inet_ntop(AF_INET, &((struct sockaddr_in *)&srv->addr)->sin_addr,
546 addr, INET_ADDRSTRLEN);
547 luaL_addstring(&b, addr);
548 luaL_addstring(&b, ":");
Nenad Merdanovic38494732017-07-23 22:04:58 -0400549 snprintf(addr, INET_ADDRSTRLEN, "%d", srv->svc_port);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100550 luaL_addstring(&b, addr);
551 break;
552 case AF_INET6:
553 inet_ntop(AF_INET6, &((struct sockaddr_in6 *)&srv->addr)->sin6_addr,
Nenad Merdanovica9f04042017-07-23 22:04:59 -0400554 addr, INET6_ADDRSTRLEN);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100555 luaL_addstring(&b, addr);
556 luaL_addstring(&b, ":");
Nenad Merdanovic38494732017-07-23 22:04:58 -0400557 snprintf(addr, INET_ADDRSTRLEN, "%d", srv->svc_port);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100558 luaL_addstring(&b, addr);
559 break;
560 case AF_UNIX:
561 luaL_addstring(&b, (char *)((struct sockaddr_un *)&srv->addr)->sun_path);
562 break;
563 default:
564 luaL_addstring(&b, "<unknown>");
565 break;
566 }
567
568 luaL_pushresult(&b);
569 return 1;
570}
571
572int hlua_server_is_draining(lua_State *L)
573{
574 struct server *srv;
575
576 srv = hlua_check_server(L, 1);
577 lua_pushinteger(L, server_is_draining(srv));
578 return 1;
579}
580
581int hlua_server_set_weight(lua_State *L)
582{
583 struct server *srv;
584 const char *weight;
585 const char *err;
586
587 srv = hlua_check_server(L, 1);
588 weight = luaL_checkstring(L, 2);
589
590 err = server_parse_weight_change_request(srv, weight);
591 if (!err)
592 lua_pushnil(L);
593 else
594 hlua_pushstrippedstring(L, err);
595 return 1;
596}
597
598int hlua_server_get_weight(lua_State *L)
599{
600 struct server *srv;
601
602 srv = hlua_check_server(L, 1);
603 lua_pushinteger(L, srv->uweight);
604 return 1;
605}
606
607int hlua_server_set_addr(lua_State *L)
608{
609 struct server *srv;
610 const char *addr;
611 const char *err;
612
613 srv = hlua_check_server(L, 1);
614 addr = luaL_checkstring(L, 2);
615
616 err = server_parse_addr_change_request(srv, addr, "Lua script");
617 if (!err)
618 lua_pushnil(L);
619 else
620 hlua_pushstrippedstring(L, err);
621 return 1;
622}
623
624int hlua_server_shut_sess(lua_State *L)
625{
626 struct server *srv;
627
628 srv = hlua_check_server(L, 1);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200629 SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100630 srv_shutdown_streams(srv, SF_ERR_KILLED);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200631 SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100632 return 0;
633}
634
635int hlua_server_set_drain(lua_State *L)
636{
637 struct server *srv;
638
639 srv = hlua_check_server(L, 1);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200640 SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100641 srv_adm_set_drain(srv);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200642 SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100643 return 0;
644}
645
646int hlua_server_set_maint(lua_State *L)
647{
648 struct server *srv;
649
650 srv = hlua_check_server(L, 1);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200651 SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100652 srv_adm_set_maint(srv);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200653 SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100654 return 0;
655}
656
657int hlua_server_set_ready(lua_State *L)
658{
659 struct server *srv;
660
661 srv = hlua_check_server(L, 1);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200662 SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100663 srv_adm_set_ready(srv);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200664 SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100665 return 0;
666}
667
668int hlua_server_check_enable(lua_State *L)
669{
670 struct server *sv;
671
672 sv = hlua_check_server(L, 1);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200673 SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100674 if (sv->check.state & CHK_ST_CONFIGURED) {
Adis Nezirovicceee9332017-07-26 09:19:06 +0200675 sv->check.state |= CHK_ST_ENABLED;
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100676 }
Emeric Brun9f0b4582017-10-23 14:39:51 +0200677 SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100678 return 0;
679}
680
681int hlua_server_check_disable(lua_State *L)
682{
683 struct server *sv;
684
685 sv = hlua_check_server(L, 1);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200686 SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100687 if (sv->check.state & CHK_ST_CONFIGURED) {
Adis Nezirovicceee9332017-07-26 09:19:06 +0200688 sv->check.state &= ~CHK_ST_ENABLED;
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100689 }
Emeric Brun9f0b4582017-10-23 14:39:51 +0200690 SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100691 return 0;
692}
693
694int hlua_server_check_force_up(lua_State *L)
695{
696 struct server *sv;
697
698 sv = hlua_check_server(L, 1);
699 if (!(sv->track)) {
Emeric Brun9f0b4582017-10-23 14:39:51 +0200700 SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100701 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +0200702 srv_set_running(sv, "changed from Lua script", NULL);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200703 SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100704 }
705 return 0;
706}
707
708int hlua_server_check_force_nolb(lua_State *L)
709{
710 struct server *sv;
711
712 sv = hlua_check_server(L, 1);
713 if (!(sv->track)) {
Emeric Brun9f0b4582017-10-23 14:39:51 +0200714 SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100715 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +0200716 srv_set_stopping(sv, "changed from Lua script", NULL);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200717 SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100718 }
719 return 0;
720}
721
722int hlua_server_check_force_down(lua_State *L)
723{
724 struct server *sv;
725
726 sv = hlua_check_server(L, 1);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200727 SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100728 if (!(sv->track)) {
729 sv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +0200730 srv_set_stopped(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100731 }
Emeric Brun9f0b4582017-10-23 14:39:51 +0200732 SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100733 return 0;
734}
735
736int hlua_server_agent_enable(lua_State *L)
737{
738 struct server *sv;
739
740 sv = hlua_check_server(L, 1);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200741 SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100742 if (sv->agent.state & CHK_ST_CONFIGURED) {
743 sv->agent.state |= CHK_ST_ENABLED;
744 }
Emeric Brun9f0b4582017-10-23 14:39:51 +0200745 SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100746 return 0;
747}
748
749int hlua_server_agent_disable(lua_State *L)
750{
751 struct server *sv;
752
753 sv = hlua_check_server(L, 1);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200754 SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100755 if (sv->agent.state & CHK_ST_CONFIGURED) {
756 sv->agent.state &= ~CHK_ST_ENABLED;
757 }
Emeric Brun9f0b4582017-10-23 14:39:51 +0200758 SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100759 return 0;
760}
761
762int hlua_server_agent_force_up(lua_State *L)
763{
764 struct server *sv;
765
766 sv = hlua_check_server(L, 1);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200767 SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100768 if (sv->agent.state & CHK_ST_ENABLED) {
769 sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +0200770 srv_set_running(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100771 }
Emeric Brun9f0b4582017-10-23 14:39:51 +0200772 SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100773 return 0;
774}
775
776int hlua_server_agent_force_down(lua_State *L)
777{
778 struct server *sv;
779
780 sv = hlua_check_server(L, 1);
Emeric Brun9f0b4582017-10-23 14:39:51 +0200781 SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100782 if (sv->agent.state & CHK_ST_ENABLED) {
783 sv->agent.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +0200784 srv_set_stopped(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100785 }
Emeric Brun9f0b4582017-10-23 14:39:51 +0200786 SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100787 return 0;
788}
789
Thierry Fournierf61aa632016-02-19 20:56:00 +0100790int hlua_fcn_new_proxy(lua_State *L, struct proxy *px)
791{
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100792 struct server *srv;
Thierry Fournierff480422016-02-25 08:36:46 +0100793 struct listener *lst;
794 int lid;
795 char buffer[10];
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100796
Thierry Fournierf61aa632016-02-19 20:56:00 +0100797 lua_newtable(L);
798
799 /* Pop a class sesison metatable and affect it to the userdata. */
800 lua_rawgeti(L, LUA_REGISTRYINDEX, class_proxy_ref);
801 lua_setmetatable(L, -2);
802
803 lua_pushlightuserdata(L, px);
804 lua_rawseti(L, -2, 0);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100805
Thierry FOURNIERf2bbe382017-07-24 13:59:22 +0200806 /* Add proxy name. */
807 lua_pushstring(L, "name");
808 lua_pushstring(L, px->id);
809 lua_settable(L, -3);
810
Baptiste Assmann46c72552017-10-26 21:51:58 +0200811 /* Add proxy uuid. */
812 lua_pushstring(L, "uuid");
813 snprintf(buffer, sizeof(buffer), "%d", px->uuid);
814 lua_pushstring(L, buffer);
815 lua_settable(L, -3);
816
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100817 /* Browse and register servers. */
818 lua_pushstring(L, "servers");
819 lua_newtable(L);
820 for (srv = px->srv; srv; srv = srv->next) {
821 lua_pushstring(L, srv->id);
822 hlua_fcn_new_server(L, srv);
823 lua_settable(L, -3);
824 }
825 lua_settable(L, -3);
826
Thierry Fournierff480422016-02-25 08:36:46 +0100827 /* Browse and register listeners. */
828 lua_pushstring(L, "listeners");
829 lua_newtable(L);
830 lid = 1;
831 list_for_each_entry(lst, &px->conf.listeners, by_fe) {
832 if (lst->name)
833 lua_pushstring(L, lst->name);
834 else {
835 snprintf(buffer, 10, "sock-%d", lid);
836 lid++;
837 lua_pushstring(L, buffer);
838 }
839 hlua_fcn_new_listener(L, lst);
840 lua_settable(L, -3);
841 }
842 lua_settable(L, -3);
843
Thierry Fournierf61aa632016-02-19 20:56:00 +0100844 return 1;
845}
846
847static struct proxy *hlua_check_proxy(lua_State *L, int ud)
848{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200849 return hlua_checkudata(L, ud, class_proxy_ref);
Thierry Fournierf61aa632016-02-19 20:56:00 +0100850}
851
852int hlua_proxy_pause(lua_State *L)
853{
854 struct proxy *px;
855
856 px = hlua_check_proxy(L, 1);
857 pause_proxy(px);
858 return 0;
859}
860
861int hlua_proxy_resume(lua_State *L)
862{
863 struct proxy *px;
864
865 px = hlua_check_proxy(L, 1);
866 resume_proxy(px);
867 return 0;
868}
869
870int hlua_proxy_stop(lua_State *L)
871{
872 struct proxy *px;
873
874 px = hlua_check_proxy(L, 1);
875 stop_proxy(px);
876 return 0;
877}
878
879int hlua_proxy_get_cap(lua_State *L)
880{
881 struct proxy *px;
882 const char *str;
883
884 px = hlua_check_proxy(L, 1);
885 str = proxy_cap_str(px->cap);
886 lua_pushstring(L, str);
887 return 1;
888}
889
890int hlua_proxy_get_stats(lua_State *L)
891{
892 struct proxy *px;
893 int i;
894
895 px = hlua_check_proxy(L, 1);
896 if (px->cap & PR_CAP_BE)
897 stats_fill_be_stats(px, ST_SHLGNDS, stats, STATS_LEN);
898 else
899 stats_fill_fe_stats(px, stats, STATS_LEN);
900 lua_newtable(L);
901 for (i=0; i<ST_F_TOTAL_FIELDS; i++) {
902 lua_pushstring(L, stat_field_names[i]);
903 hlua_fcn_pushfield(L, &stats[i]);
904 lua_settable(L, -3);
905 }
906 return 1;
907}
908
909int hlua_proxy_get_mode(lua_State *L)
910{
911 struct proxy *px;
912 const char *str;
913
914 px = hlua_check_proxy(L, 1);
915 str = proxy_mode_str(px->mode);
916 lua_pushstring(L, str);
917 return 1;
918}
919
920int hlua_proxy_shut_bcksess(lua_State *L)
921{
922 struct proxy *px;
923
924 px = hlua_check_proxy(L, 1);
925 srv_shutdown_backup_streams(px, SF_ERR_KILLED);
926 return 0;
927}
928
Thierry Fournier3d4a6752016-02-19 20:53:30 +0100929int hlua_fcn_post_init(lua_State *L)
930{
Thierry Fournierf61aa632016-02-19 20:56:00 +0100931 struct proxy *px;
932
933 /* get core array. */
934 if (lua_getglobal(L, "core") != LUA_TTABLE)
935 lua_error(L);
936
937 /* Create proxies entry. */
938 lua_pushstring(L, "proxies");
939 lua_newtable(L);
940
941 /* List all proxies. */
942 for (px = proxy; px; px = px->next) {
943 lua_pushstring(L, px->id);
944 hlua_fcn_new_proxy(L, px);
945 lua_settable(L, -3);
946 }
947
948 /* push "proxies" in "core" */
949 lua_settable(L, -3);
950
Thierry FOURNIER9b82a582017-07-24 13:30:43 +0200951 /* Create proxies entry. */
952 lua_pushstring(L, "frontends");
953 lua_newtable(L);
954
955 /* List all proxies. */
956 for (px = proxy; px; px = px->next) {
957 if (!(px->cap & PR_CAP_FE))
958 continue;
959 lua_pushstring(L, px->id);
960 hlua_fcn_new_proxy(L, px);
961 lua_settable(L, -3);
962 }
963
964 /* push "frontends" in "core" */
965 lua_settable(L, -3);
966
967 /* Create proxies entry. */
968 lua_pushstring(L, "backends");
969 lua_newtable(L);
970
971 /* List all proxies. */
972 for (px = proxy; px; px = px->next) {
973 if (!(px->cap & PR_CAP_BE))
974 continue;
975 lua_pushstring(L, px->id);
976 hlua_fcn_new_proxy(L, px);
977 lua_settable(L, -3);
978 }
979
980 /* push "backend" in "core" */
981 lua_settable(L, -3);
982
Thierry Fournier3d4a6752016-02-19 20:53:30 +0100983 return 1;
984}
985
Thierry FOURNIER / OZON.IO8a1027a2016-11-24 20:48:38 +0100986/* This Lua function take a string, a list of separators.
987 * It tokenize the input string using the list of separators
988 * as separator.
989 *
990 * The functionreturns a tablle filled with tokens.
991 */
992int hlua_tokenize(lua_State *L)
993{
994 const char *str;
995 const char *sep;
996 int index;
997 const char *token;
998 const char *p;
999 const char *c;
1000 int ignore_empty;
1001
1002 ignore_empty = 0;
1003
1004 str = luaL_checkstring(L, 1);
1005 sep = luaL_checkstring(L, 2);
1006 if (lua_gettop(L) == 3)
1007 ignore_empty = hlua_checkboolean(L, 3);
1008
1009 lua_newtable(L);
1010 index = 1;
1011 token = str;
1012 p = str;
1013 while(1) {
1014 for (c = sep; *c != '\0'; c++)
1015 if (*p == *c)
1016 break;
1017 if (*p == *c) {
1018 if ((!ignore_empty) || (p - token > 0)) {
1019 lua_pushlstring(L, token, p - token);
1020 lua_rawseti(L, -2, index);
1021 index++;
1022 }
1023 token = p + 1;
1024 }
1025 if (*p == '\0')
1026 break;
1027 p++;
1028 }
1029
1030 return 1;
1031}
1032
Thierry FOURNIER / OZON.IO62fec752016-11-10 20:38:11 +01001033int hlua_parse_addr(lua_State *L)
1034{
1035 struct hlua_addr *addr;
1036 const char *str = luaL_checkstring(L, 1);
1037 unsigned char mask;
1038
1039 addr = lua_newuserdata(L, sizeof(struct hlua_addr));
1040 if (!addr) {
1041 lua_pushnil(L);
1042 return 1;
1043 }
1044
1045 if (str2net(str, PAT_MF_NO_DNS, &addr->addr.v4.ip, &addr->addr.v4.mask)) {
1046 addr->type = AF_INET;
1047 return 1;
1048 }
1049
1050 if (str62net(str, &addr->addr.v6.ip, &mask)) {
1051 len2mask6(mask, &addr->addr.v6.mask);
1052 addr->type = AF_INET6;
1053 return 1;
1054 }
1055
1056 lua_pop(L, 1);
1057 lua_pushnil(L);
1058 return 1;
1059}
1060
1061int hlua_match_addr(lua_State *L)
1062{
1063 struct hlua_addr *addr1;
1064 struct hlua_addr *addr2;
1065
1066 if (!lua_isuserdata(L, 1) ||
1067 !lua_isuserdata(L, 2)) {
1068 lua_pushboolean(L, 0);
1069 return 1;
1070 }
1071
1072 addr1 = lua_touserdata(L, 1);
1073 addr2 = lua_touserdata(L, 2);
1074
1075 if (addr1->type != addr2->type) {
1076 lua_pushboolean(L, 0);
1077 return 1;
1078 }
1079
1080 if (addr1->type == AF_INET) {
1081 if ((addr1->addr.v4.ip.s_addr & addr2->addr.v4.mask.s_addr) ==
1082 (addr2->addr.v4.ip.s_addr & addr1->addr.v4.mask.s_addr)) {
1083 lua_pushboolean(L, 1);
1084 return 1;
1085 }
1086 } else {
Thierry FOURNIERde6925e2016-12-23 17:03:25 +01001087 int i;
1088
1089 for (i = 0; i < 16; i += 4) {
1090 if ((*(uint32_t *)&addr1->addr.v6.ip.s6_addr[i] &
1091 *(uint32_t *)&addr2->addr.v6.mask.s6_addr[i]) !=
1092 (*(uint32_t *)&addr2->addr.v6.ip.s6_addr[i] &
1093 *(uint32_t *)&addr1->addr.v6.mask.s6_addr[i]))
1094 break;
1095 }
1096 if (i == 16) {
Thierry FOURNIER / OZON.IO62fec752016-11-10 20:38:11 +01001097 lua_pushboolean(L, 1);
1098 return 1;
1099 }
1100 }
1101
1102 lua_pushboolean(L, 0);
1103 return 1;
1104}
1105
Thierry FOURNIER31904272017-10-25 12:59:51 +02001106static struct my_regex *hlua_check_regex(lua_State *L, int ud)
1107{
1108 return (hlua_checkudata(L, ud, class_regex_ref));
1109}
1110
1111static int hlua_regex_comp(struct lua_State *L)
1112{
1113 struct my_regex *regex;
1114 const char *str;
1115 int cs;
1116 char *err;
1117
1118 str = luaL_checkstring(L, 1);
1119 luaL_argcheck(L, lua_isboolean(L, 2), 2, NULL);
1120 cs = lua_toboolean(L, 2);
1121
1122 regex = lua_newuserdata(L, sizeof(*regex));
1123
1124 err = NULL;
1125 if (!regex_comp(str, regex, cs, 1, &err)) {
1126 lua_pushboolean(L, 0); /* status error */
1127 lua_pushstring(L, err); /* Reason */
1128 free(err);
1129 return 2;
1130 }
1131
1132 lua_pushboolean(L, 1); /* Status ok */
1133
1134 /* Create object */
1135 lua_newtable(L);
1136 lua_pushvalue(L, -3); /* Get the userdata pointer. */
1137 lua_rawseti(L, -2, 0);
1138 lua_rawgeti(L, LUA_REGISTRYINDEX, class_regex_ref);
1139 lua_setmetatable(L, -2);
1140 return 2;
1141}
1142
1143static int hlua_regex_exec(struct lua_State *L)
1144{
1145 struct my_regex *regex;
1146 const char *str;
1147 size_t len;
Thierry FOURNIER7c210e62017-10-27 14:13:51 +02001148 struct chunk *tmp;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001149
1150 regex = hlua_check_regex(L, 1);
1151 str = luaL_checklstring(L, 2, &len);
1152
Thierry FOURNIER7c210e62017-10-27 14:13:51 +02001153 /* Copy the string because regex_exec2 require a 'char *'
1154 * and not a 'const char *'.
1155 */
1156 tmp = get_trash_chunk();
1157 if (len >= tmp->size) {
1158 lua_pushboolean(L, 0);
1159 return 1;
1160 }
1161 memcpy(tmp->str, str, len);
1162
1163 lua_pushboolean(L, regex_exec2(regex, tmp->str, len));
Thierry FOURNIER31904272017-10-25 12:59:51 +02001164
1165 return 1;
1166}
1167
1168static int hlua_regex_match(struct lua_State *L)
1169{
1170 struct my_regex *regex;
1171 const char *str;
1172 size_t len;
1173 regmatch_t pmatch[20];
1174 int ret;
1175 int i;
Thierry FOURNIER7c210e62017-10-27 14:13:51 +02001176 struct chunk *tmp;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001177
1178 regex = hlua_check_regex(L, 1);
1179 str = luaL_checklstring(L, 2, &len);
1180
Thierry FOURNIER7c210e62017-10-27 14:13:51 +02001181 /* Copy the string because regex_exec2 require a 'char *'
1182 * and not a 'const char *'.
1183 */
1184 tmp = get_trash_chunk();
1185 if (len >= tmp->size) {
1186 lua_pushboolean(L, 0);
1187 return 1;
1188 }
1189 memcpy(tmp->str, str, len);
1190
1191 ret = regex_exec_match2(regex, tmp->str, len, 20, pmatch, 0);
Thierry FOURNIER31904272017-10-25 12:59:51 +02001192 lua_pushboolean(L, ret);
1193 lua_newtable(L);
1194 if (ret) {
1195 for (i = 0; i < 20 && pmatch[i].rm_so != -1; i++) {
1196 lua_pushlstring(L, str + pmatch[i].rm_so, pmatch[i].rm_eo - pmatch[i].rm_so);
1197 lua_rawseti(L, -2, i + 1);
1198 }
1199 }
1200 return 2;
1201}
1202
1203static int hlua_regex_free(struct lua_State *L)
1204{
1205 struct my_regex *regex;
1206
1207 regex = hlua_check_regex(L, 1);
1208 regex_free(regex);
1209 return 0;
1210}
1211
Thierry Fournierfb0b5462016-01-21 09:28:58 +01001212int hlua_fcn_reg_core_fcn(lua_State *L)
1213{
Thierry Fournier1de16592016-01-27 09:49:07 +01001214 if (!hlua_concat_init(L))
1215 return 0;
1216
Thierry Fournier4f99b272016-02-22 08:40:02 +01001217 hlua_class_function(L, "now", hlua_now);
1218 hlua_class_function(L, "http_date", hlua_http_date);
1219 hlua_class_function(L, "imf_date", hlua_imf_date);
1220 hlua_class_function(L, "rfc850_date", hlua_rfc850_date);
1221 hlua_class_function(L, "asctime_date", hlua_asctime_date);
1222 hlua_class_function(L, "concat", hlua_concat_new);
Thierry Fourniereea77c02016-03-18 08:47:13 +01001223 hlua_class_function(L, "get_info", hlua_get_info);
Thierry FOURNIER / OZON.IO62fec752016-11-10 20:38:11 +01001224 hlua_class_function(L, "parse_addr", hlua_parse_addr);
1225 hlua_class_function(L, "match_addr", hlua_match_addr);
Thierry FOURNIER / OZON.IO8a1027a2016-11-24 20:48:38 +01001226 hlua_class_function(L, "tokenize", hlua_tokenize);
Thierry Fournier4f99b272016-02-22 08:40:02 +01001227
Thierry FOURNIER31904272017-10-25 12:59:51 +02001228 /* Create regex object. */
1229 lua_newtable(L);
1230 hlua_class_function(L, "new", hlua_regex_comp);
1231
1232 lua_newtable(L); /* The metatable. */
1233 lua_pushstring(L, "__index");
1234 lua_newtable(L);
1235 hlua_class_function(L, "exec", hlua_regex_exec);
1236 hlua_class_function(L, "match", hlua_regex_match);
1237 lua_rawset(L, -3); /* -> META["__index"] = TABLE */
1238 hlua_class_function(L, "__gc", hlua_regex_free);
1239
1240 lua_pushvalue(L, -1); /* Duplicate the metatable reference. */
1241 class_regex_ref = hlua_register_metatable(L, CLASS_REGEX);
1242
1243 lua_setmetatable(L, -2);
1244 lua_setglobal(L, CLASS_REGEX); /* Create global object called Regex */
1245
Thierry Fournierff480422016-02-25 08:36:46 +01001246 /* Create listener object. */
1247 lua_newtable(L);
1248 lua_pushstring(L, "__index");
1249 lua_newtable(L);
1250 hlua_class_function(L, "get_stats", hlua_listener_get_stats);
1251 lua_settable(L, -3); /* -> META["__index"] = TABLE */
1252 class_listener_ref = hlua_register_metatable(L, CLASS_LISTENER);
1253
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001254 /* Create server object. */
1255 lua_newtable(L);
1256 lua_pushstring(L, "__index");
1257 lua_newtable(L);
1258 hlua_class_function(L, "is_draining", hlua_server_is_draining);
1259 hlua_class_function(L, "set_weight", hlua_server_set_weight);
1260 hlua_class_function(L, "get_weight", hlua_server_get_weight);
1261 hlua_class_function(L, "set_addr", hlua_server_set_addr);
1262 hlua_class_function(L, "get_addr", hlua_server_get_addr);
1263 hlua_class_function(L, "get_stats", hlua_server_get_stats);
1264 hlua_class_function(L, "shut_sess", hlua_server_shut_sess);
1265 hlua_class_function(L, "set_drain", hlua_server_set_drain);
1266 hlua_class_function(L, "set_maint", hlua_server_set_maint);
1267 hlua_class_function(L, "set_ready", hlua_server_set_ready);
1268 hlua_class_function(L, "check_enable", hlua_server_check_enable);
1269 hlua_class_function(L, "check_disable", hlua_server_check_disable);
1270 hlua_class_function(L, "check_force_up", hlua_server_check_force_up);
1271 hlua_class_function(L, "check_force_nolb", hlua_server_check_force_nolb);
1272 hlua_class_function(L, "check_force_down", hlua_server_check_force_down);
1273 hlua_class_function(L, "agent_enable", hlua_server_agent_enable);
1274 hlua_class_function(L, "agent_disable", hlua_server_agent_disable);
1275 hlua_class_function(L, "agent_force_up", hlua_server_agent_force_up);
1276 hlua_class_function(L, "agent_force_down", hlua_server_agent_force_down);
1277 lua_settable(L, -3); /* -> META["__index"] = TABLE */
1278 class_server_ref = hlua_register_metatable(L, CLASS_SERVER);
1279
Thierry Fournierf61aa632016-02-19 20:56:00 +01001280 /* Create proxy object. */
1281 lua_newtable(L);
1282 lua_pushstring(L, "__index");
1283 lua_newtable(L);
1284 hlua_class_function(L, "pause", hlua_proxy_pause);
1285 hlua_class_function(L, "resume", hlua_proxy_resume);
1286 hlua_class_function(L, "stop", hlua_proxy_stop);
1287 hlua_class_function(L, "shut_bcksess", hlua_proxy_shut_bcksess);
1288 hlua_class_function(L, "get_cap", hlua_proxy_get_cap);
1289 hlua_class_function(L, "get_mode", hlua_proxy_get_mode);
1290 hlua_class_function(L, "get_stats", hlua_proxy_get_stats);
1291 lua_settable(L, -3); /* -> META["__index"] = TABLE */
1292 class_proxy_ref = hlua_register_metatable(L, CLASS_PROXY);
1293
Thierry Fournier1550d5d2016-01-21 09:35:41 +01001294 return 5;
Thierry Fournierfb0b5462016-01-21 09:28:58 +01001295}