blob: a8d53d45b7d1ede813b17d8b77e34feb3be05e33 [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
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100590 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100591 err = server_parse_weight_change_request(srv, weight);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100592 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100593 if (!err)
594 lua_pushnil(L);
595 else
596 hlua_pushstrippedstring(L, err);
597 return 1;
598}
599
600int hlua_server_get_weight(lua_State *L)
601{
602 struct server *srv;
603
604 srv = hlua_check_server(L, 1);
605 lua_pushinteger(L, srv->uweight);
606 return 1;
607}
608
609int hlua_server_set_addr(lua_State *L)
610{
611 struct server *srv;
612 const char *addr;
613 const char *err;
614
615 srv = hlua_check_server(L, 1);
616 addr = luaL_checkstring(L, 2);
617
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100618 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100619 err = server_parse_addr_change_request(srv, addr, "Lua script");
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100620 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100621 if (!err)
622 lua_pushnil(L);
623 else
624 hlua_pushstrippedstring(L, err);
625 return 1;
626}
627
628int hlua_server_shut_sess(lua_State *L)
629{
630 struct server *srv;
631
632 srv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100633 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100634 srv_shutdown_streams(srv, SF_ERR_KILLED);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100635 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100636 return 0;
637}
638
639int hlua_server_set_drain(lua_State *L)
640{
641 struct server *srv;
642
643 srv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100644 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100645 srv_adm_set_drain(srv);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100646 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100647 return 0;
648}
649
650int hlua_server_set_maint(lua_State *L)
651{
652 struct server *srv;
653
654 srv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100655 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100656 srv_adm_set_maint(srv);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100657 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100658 return 0;
659}
660
661int hlua_server_set_ready(lua_State *L)
662{
663 struct server *srv;
664
665 srv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100666 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100667 srv_adm_set_ready(srv);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100668 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100669 return 0;
670}
671
672int hlua_server_check_enable(lua_State *L)
673{
674 struct server *sv;
675
676 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100677 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100678 if (sv->check.state & CHK_ST_CONFIGURED) {
Adis Nezirovicceee9332017-07-26 09:19:06 +0200679 sv->check.state |= CHK_ST_ENABLED;
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100680 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100681 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100682 return 0;
683}
684
685int hlua_server_check_disable(lua_State *L)
686{
687 struct server *sv;
688
689 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100690 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100691 if (sv->check.state & CHK_ST_CONFIGURED) {
Adis Nezirovicceee9332017-07-26 09:19:06 +0200692 sv->check.state &= ~CHK_ST_ENABLED;
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100693 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100694 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100695 return 0;
696}
697
698int hlua_server_check_force_up(lua_State *L)
699{
700 struct server *sv;
701
702 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100703 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100704 if (!(sv->track)) {
705 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +0200706 srv_set_running(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100707 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100708 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100709 return 0;
710}
711
712int hlua_server_check_force_nolb(lua_State *L)
713{
714 struct server *sv;
715
716 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100717 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100718 if (!(sv->track)) {
719 sv->check.health = sv->check.rise + sv->check.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +0200720 srv_set_stopping(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100721 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100722 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100723 return 0;
724}
725
726int hlua_server_check_force_down(lua_State *L)
727{
728 struct server *sv;
729
730 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100731 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100732 if (!(sv->track)) {
733 sv->check.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +0200734 srv_set_stopped(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100735 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100736 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100737 return 0;
738}
739
740int hlua_server_agent_enable(lua_State *L)
741{
742 struct server *sv;
743
744 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100745 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100746 if (sv->agent.state & CHK_ST_CONFIGURED) {
747 sv->agent.state |= CHK_ST_ENABLED;
748 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100749 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100750 return 0;
751}
752
753int hlua_server_agent_disable(lua_State *L)
754{
755 struct server *sv;
756
757 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100758 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100759 if (sv->agent.state & CHK_ST_CONFIGURED) {
760 sv->agent.state &= ~CHK_ST_ENABLED;
761 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100762 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100763 return 0;
764}
765
766int hlua_server_agent_force_up(lua_State *L)
767{
768 struct server *sv;
769
770 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100771 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100772 if (sv->agent.state & CHK_ST_ENABLED) {
773 sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
Emeric Brun5a133512017-10-19 14:42:30 +0200774 srv_set_running(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100775 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100776 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100777 return 0;
778}
779
780int hlua_server_agent_force_down(lua_State *L)
781{
782 struct server *sv;
783
784 sv = hlua_check_server(L, 1);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100785 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100786 if (sv->agent.state & CHK_ST_ENABLED) {
787 sv->agent.health = 0;
Emeric Brun5a133512017-10-19 14:42:30 +0200788 srv_set_stopped(sv, "changed from Lua script", NULL);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100789 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100790 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100791 return 0;
792}
793
Thierry Fournierf61aa632016-02-19 20:56:00 +0100794int hlua_fcn_new_proxy(lua_State *L, struct proxy *px)
795{
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100796 struct server *srv;
Thierry Fournierff480422016-02-25 08:36:46 +0100797 struct listener *lst;
798 int lid;
799 char buffer[10];
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100800
Thierry Fournierf61aa632016-02-19 20:56:00 +0100801 lua_newtable(L);
802
803 /* Pop a class sesison metatable and affect it to the userdata. */
804 lua_rawgeti(L, LUA_REGISTRYINDEX, class_proxy_ref);
805 lua_setmetatable(L, -2);
806
807 lua_pushlightuserdata(L, px);
808 lua_rawseti(L, -2, 0);
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100809
Thierry FOURNIERf2bbe382017-07-24 13:59:22 +0200810 /* Add proxy name. */
811 lua_pushstring(L, "name");
812 lua_pushstring(L, px->id);
813 lua_settable(L, -3);
814
Baptiste Assmann46c72552017-10-26 21:51:58 +0200815 /* Add proxy uuid. */
816 lua_pushstring(L, "uuid");
817 snprintf(buffer, sizeof(buffer), "%d", px->uuid);
818 lua_pushstring(L, buffer);
819 lua_settable(L, -3);
820
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +0100821 /* Browse and register servers. */
822 lua_pushstring(L, "servers");
823 lua_newtable(L);
824 for (srv = px->srv; srv; srv = srv->next) {
825 lua_pushstring(L, srv->id);
826 hlua_fcn_new_server(L, srv);
827 lua_settable(L, -3);
828 }
829 lua_settable(L, -3);
830
Thierry Fournierff480422016-02-25 08:36:46 +0100831 /* Browse and register listeners. */
832 lua_pushstring(L, "listeners");
833 lua_newtable(L);
834 lid = 1;
835 list_for_each_entry(lst, &px->conf.listeners, by_fe) {
836 if (lst->name)
837 lua_pushstring(L, lst->name);
838 else {
839 snprintf(buffer, 10, "sock-%d", lid);
840 lid++;
841 lua_pushstring(L, buffer);
842 }
843 hlua_fcn_new_listener(L, lst);
844 lua_settable(L, -3);
845 }
846 lua_settable(L, -3);
847
Thierry Fournierf61aa632016-02-19 20:56:00 +0100848 return 1;
849}
850
851static struct proxy *hlua_check_proxy(lua_State *L, int ud)
852{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +0200853 return hlua_checkudata(L, ud, class_proxy_ref);
Thierry Fournierf61aa632016-02-19 20:56:00 +0100854}
855
856int hlua_proxy_pause(lua_State *L)
857{
858 struct proxy *px;
859
860 px = hlua_check_proxy(L, 1);
861 pause_proxy(px);
862 return 0;
863}
864
865int hlua_proxy_resume(lua_State *L)
866{
867 struct proxy *px;
868
869 px = hlua_check_proxy(L, 1);
870 resume_proxy(px);
871 return 0;
872}
873
874int hlua_proxy_stop(lua_State *L)
875{
876 struct proxy *px;
877
878 px = hlua_check_proxy(L, 1);
879 stop_proxy(px);
880 return 0;
881}
882
883int hlua_proxy_get_cap(lua_State *L)
884{
885 struct proxy *px;
886 const char *str;
887
888 px = hlua_check_proxy(L, 1);
889 str = proxy_cap_str(px->cap);
890 lua_pushstring(L, str);
891 return 1;
892}
893
894int hlua_proxy_get_stats(lua_State *L)
895{
896 struct proxy *px;
897 int i;
898
899 px = hlua_check_proxy(L, 1);
900 if (px->cap & PR_CAP_BE)
901 stats_fill_be_stats(px, ST_SHLGNDS, stats, STATS_LEN);
902 else
903 stats_fill_fe_stats(px, stats, STATS_LEN);
904 lua_newtable(L);
905 for (i=0; i<ST_F_TOTAL_FIELDS; i++) {
906 lua_pushstring(L, stat_field_names[i]);
907 hlua_fcn_pushfield(L, &stats[i]);
908 lua_settable(L, -3);
909 }
910 return 1;
911}
912
913int hlua_proxy_get_mode(lua_State *L)
914{
915 struct proxy *px;
916 const char *str;
917
918 px = hlua_check_proxy(L, 1);
919 str = proxy_mode_str(px->mode);
920 lua_pushstring(L, str);
921 return 1;
922}
923
924int hlua_proxy_shut_bcksess(lua_State *L)
925{
926 struct proxy *px;
927
928 px = hlua_check_proxy(L, 1);
929 srv_shutdown_backup_streams(px, SF_ERR_KILLED);
930 return 0;
931}
932
Thierry Fournier3d4a6752016-02-19 20:53:30 +0100933int hlua_fcn_post_init(lua_State *L)
934{
Thierry Fournierf61aa632016-02-19 20:56:00 +0100935 struct proxy *px;
936
937 /* get core array. */
938 if (lua_getglobal(L, "core") != LUA_TTABLE)
939 lua_error(L);
940
941 /* Create proxies entry. */
942 lua_pushstring(L, "proxies");
943 lua_newtable(L);
944
945 /* List all proxies. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100946 for (px = proxies_list; px; px = px->next) {
Thierry Fournierf61aa632016-02-19 20:56:00 +0100947 lua_pushstring(L, px->id);
948 hlua_fcn_new_proxy(L, px);
949 lua_settable(L, -3);
950 }
951
952 /* push "proxies" in "core" */
953 lua_settable(L, -3);
954
Thierry FOURNIER9b82a582017-07-24 13:30:43 +0200955 /* Create proxies entry. */
956 lua_pushstring(L, "frontends");
957 lua_newtable(L);
958
959 /* List all proxies. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100960 for (px = proxies_list; px; px = px->next) {
Thierry FOURNIER9b82a582017-07-24 13:30:43 +0200961 if (!(px->cap & PR_CAP_FE))
962 continue;
963 lua_pushstring(L, px->id);
964 hlua_fcn_new_proxy(L, px);
965 lua_settable(L, -3);
966 }
967
968 /* push "frontends" in "core" */
969 lua_settable(L, -3);
970
971 /* Create proxies entry. */
972 lua_pushstring(L, "backends");
973 lua_newtable(L);
974
975 /* List all proxies. */
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100976 for (px = proxies_list; px; px = px->next) {
Thierry FOURNIER9b82a582017-07-24 13:30:43 +0200977 if (!(px->cap & PR_CAP_BE))
978 continue;
979 lua_pushstring(L, px->id);
980 hlua_fcn_new_proxy(L, px);
981 lua_settable(L, -3);
982 }
983
984 /* push "backend" in "core" */
985 lua_settable(L, -3);
986
Thierry Fournier3d4a6752016-02-19 20:53:30 +0100987 return 1;
988}
989
Thierry FOURNIER / OZON.IO8a1027a2016-11-24 20:48:38 +0100990/* This Lua function take a string, a list of separators.
991 * It tokenize the input string using the list of separators
992 * as separator.
993 *
994 * The functionreturns a tablle filled with tokens.
995 */
996int hlua_tokenize(lua_State *L)
997{
998 const char *str;
999 const char *sep;
1000 int index;
1001 const char *token;
1002 const char *p;
1003 const char *c;
1004 int ignore_empty;
1005
1006 ignore_empty = 0;
1007
1008 str = luaL_checkstring(L, 1);
1009 sep = luaL_checkstring(L, 2);
1010 if (lua_gettop(L) == 3)
1011 ignore_empty = hlua_checkboolean(L, 3);
1012
1013 lua_newtable(L);
1014 index = 1;
1015 token = str;
1016 p = str;
1017 while(1) {
1018 for (c = sep; *c != '\0'; c++)
1019 if (*p == *c)
1020 break;
1021 if (*p == *c) {
1022 if ((!ignore_empty) || (p - token > 0)) {
1023 lua_pushlstring(L, token, p - token);
1024 lua_rawseti(L, -2, index);
1025 index++;
1026 }
1027 token = p + 1;
1028 }
1029 if (*p == '\0')
1030 break;
1031 p++;
1032 }
1033
1034 return 1;
1035}
1036
Thierry FOURNIER / OZON.IO62fec752016-11-10 20:38:11 +01001037int hlua_parse_addr(lua_State *L)
1038{
1039 struct hlua_addr *addr;
1040 const char *str = luaL_checkstring(L, 1);
1041 unsigned char mask;
1042
1043 addr = lua_newuserdata(L, sizeof(struct hlua_addr));
1044 if (!addr) {
1045 lua_pushnil(L);
1046 return 1;
1047 }
1048
1049 if (str2net(str, PAT_MF_NO_DNS, &addr->addr.v4.ip, &addr->addr.v4.mask)) {
1050 addr->type = AF_INET;
1051 return 1;
1052 }
1053
1054 if (str62net(str, &addr->addr.v6.ip, &mask)) {
1055 len2mask6(mask, &addr->addr.v6.mask);
1056 addr->type = AF_INET6;
1057 return 1;
1058 }
1059
1060 lua_pop(L, 1);
1061 lua_pushnil(L);
1062 return 1;
1063}
1064
1065int hlua_match_addr(lua_State *L)
1066{
1067 struct hlua_addr *addr1;
1068 struct hlua_addr *addr2;
1069
1070 if (!lua_isuserdata(L, 1) ||
1071 !lua_isuserdata(L, 2)) {
1072 lua_pushboolean(L, 0);
1073 return 1;
1074 }
1075
1076 addr1 = lua_touserdata(L, 1);
1077 addr2 = lua_touserdata(L, 2);
1078
1079 if (addr1->type != addr2->type) {
1080 lua_pushboolean(L, 0);
1081 return 1;
1082 }
1083
1084 if (addr1->type == AF_INET) {
1085 if ((addr1->addr.v4.ip.s_addr & addr2->addr.v4.mask.s_addr) ==
1086 (addr2->addr.v4.ip.s_addr & addr1->addr.v4.mask.s_addr)) {
1087 lua_pushboolean(L, 1);
1088 return 1;
1089 }
1090 } else {
Thierry FOURNIERde6925e2016-12-23 17:03:25 +01001091 int i;
1092
1093 for (i = 0; i < 16; i += 4) {
1094 if ((*(uint32_t *)&addr1->addr.v6.ip.s6_addr[i] &
1095 *(uint32_t *)&addr2->addr.v6.mask.s6_addr[i]) !=
1096 (*(uint32_t *)&addr2->addr.v6.ip.s6_addr[i] &
1097 *(uint32_t *)&addr1->addr.v6.mask.s6_addr[i]))
1098 break;
1099 }
1100 if (i == 16) {
Thierry FOURNIER / OZON.IO62fec752016-11-10 20:38:11 +01001101 lua_pushboolean(L, 1);
1102 return 1;
1103 }
1104 }
1105
1106 lua_pushboolean(L, 0);
1107 return 1;
1108}
1109
Thierry FOURNIER31904272017-10-25 12:59:51 +02001110static struct my_regex *hlua_check_regex(lua_State *L, int ud)
1111{
1112 return (hlua_checkudata(L, ud, class_regex_ref));
1113}
1114
1115static int hlua_regex_comp(struct lua_State *L)
1116{
1117 struct my_regex *regex;
1118 const char *str;
1119 int cs;
1120 char *err;
1121
1122 str = luaL_checkstring(L, 1);
1123 luaL_argcheck(L, lua_isboolean(L, 2), 2, NULL);
1124 cs = lua_toboolean(L, 2);
1125
1126 regex = lua_newuserdata(L, sizeof(*regex));
1127
1128 err = NULL;
1129 if (!regex_comp(str, regex, cs, 1, &err)) {
1130 lua_pushboolean(L, 0); /* status error */
1131 lua_pushstring(L, err); /* Reason */
1132 free(err);
1133 return 2;
1134 }
1135
1136 lua_pushboolean(L, 1); /* Status ok */
1137
1138 /* Create object */
1139 lua_newtable(L);
1140 lua_pushvalue(L, -3); /* Get the userdata pointer. */
1141 lua_rawseti(L, -2, 0);
1142 lua_rawgeti(L, LUA_REGISTRYINDEX, class_regex_ref);
1143 lua_setmetatable(L, -2);
1144 return 2;
1145}
1146
1147static int hlua_regex_exec(struct lua_State *L)
1148{
1149 struct my_regex *regex;
1150 const char *str;
1151 size_t len;
Thierry FOURNIER7c210e62017-10-27 14:13:51 +02001152 struct chunk *tmp;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001153
1154 regex = hlua_check_regex(L, 1);
1155 str = luaL_checklstring(L, 2, &len);
1156
Thierry FOURNIER7c210e62017-10-27 14:13:51 +02001157 /* Copy the string because regex_exec2 require a 'char *'
1158 * and not a 'const char *'.
1159 */
1160 tmp = get_trash_chunk();
1161 if (len >= tmp->size) {
1162 lua_pushboolean(L, 0);
1163 return 1;
1164 }
1165 memcpy(tmp->str, str, len);
1166
1167 lua_pushboolean(L, regex_exec2(regex, tmp->str, len));
Thierry FOURNIER31904272017-10-25 12:59:51 +02001168
1169 return 1;
1170}
1171
1172static int hlua_regex_match(struct lua_State *L)
1173{
1174 struct my_regex *regex;
1175 const char *str;
1176 size_t len;
1177 regmatch_t pmatch[20];
1178 int ret;
1179 int i;
Thierry FOURNIER7c210e62017-10-27 14:13:51 +02001180 struct chunk *tmp;
Thierry FOURNIER31904272017-10-25 12:59:51 +02001181
1182 regex = hlua_check_regex(L, 1);
1183 str = luaL_checklstring(L, 2, &len);
1184
Thierry FOURNIER7c210e62017-10-27 14:13:51 +02001185 /* Copy the string because regex_exec2 require a 'char *'
1186 * and not a 'const char *'.
1187 */
1188 tmp = get_trash_chunk();
1189 if (len >= tmp->size) {
1190 lua_pushboolean(L, 0);
1191 return 1;
1192 }
1193 memcpy(tmp->str, str, len);
1194
1195 ret = regex_exec_match2(regex, tmp->str, len, 20, pmatch, 0);
Thierry FOURNIER31904272017-10-25 12:59:51 +02001196 lua_pushboolean(L, ret);
1197 lua_newtable(L);
1198 if (ret) {
1199 for (i = 0; i < 20 && pmatch[i].rm_so != -1; i++) {
1200 lua_pushlstring(L, str + pmatch[i].rm_so, pmatch[i].rm_eo - pmatch[i].rm_so);
1201 lua_rawseti(L, -2, i + 1);
1202 }
1203 }
1204 return 2;
1205}
1206
1207static int hlua_regex_free(struct lua_State *L)
1208{
1209 struct my_regex *regex;
1210
1211 regex = hlua_check_regex(L, 1);
1212 regex_free(regex);
1213 return 0;
1214}
1215
Thierry Fournierfb0b5462016-01-21 09:28:58 +01001216int hlua_fcn_reg_core_fcn(lua_State *L)
1217{
Thierry Fournier1de16592016-01-27 09:49:07 +01001218 if (!hlua_concat_init(L))
1219 return 0;
1220
Thierry Fournier4f99b272016-02-22 08:40:02 +01001221 hlua_class_function(L, "now", hlua_now);
1222 hlua_class_function(L, "http_date", hlua_http_date);
1223 hlua_class_function(L, "imf_date", hlua_imf_date);
1224 hlua_class_function(L, "rfc850_date", hlua_rfc850_date);
1225 hlua_class_function(L, "asctime_date", hlua_asctime_date);
1226 hlua_class_function(L, "concat", hlua_concat_new);
Thierry Fourniereea77c02016-03-18 08:47:13 +01001227 hlua_class_function(L, "get_info", hlua_get_info);
Thierry FOURNIER / OZON.IO62fec752016-11-10 20:38:11 +01001228 hlua_class_function(L, "parse_addr", hlua_parse_addr);
1229 hlua_class_function(L, "match_addr", hlua_match_addr);
Thierry FOURNIER / OZON.IO8a1027a2016-11-24 20:48:38 +01001230 hlua_class_function(L, "tokenize", hlua_tokenize);
Thierry Fournier4f99b272016-02-22 08:40:02 +01001231
Thierry FOURNIER31904272017-10-25 12:59:51 +02001232 /* Create regex object. */
1233 lua_newtable(L);
1234 hlua_class_function(L, "new", hlua_regex_comp);
1235
1236 lua_newtable(L); /* The metatable. */
1237 lua_pushstring(L, "__index");
1238 lua_newtable(L);
1239 hlua_class_function(L, "exec", hlua_regex_exec);
1240 hlua_class_function(L, "match", hlua_regex_match);
1241 lua_rawset(L, -3); /* -> META["__index"] = TABLE */
1242 hlua_class_function(L, "__gc", hlua_regex_free);
1243
1244 lua_pushvalue(L, -1); /* Duplicate the metatable reference. */
1245 class_regex_ref = hlua_register_metatable(L, CLASS_REGEX);
1246
1247 lua_setmetatable(L, -2);
1248 lua_setglobal(L, CLASS_REGEX); /* Create global object called Regex */
1249
Thierry Fournierff480422016-02-25 08:36:46 +01001250 /* Create listener object. */
1251 lua_newtable(L);
1252 lua_pushstring(L, "__index");
1253 lua_newtable(L);
1254 hlua_class_function(L, "get_stats", hlua_listener_get_stats);
1255 lua_settable(L, -3); /* -> META["__index"] = TABLE */
1256 class_listener_ref = hlua_register_metatable(L, CLASS_LISTENER);
1257
Thierry Fournierf2fdc9d2016-02-22 08:21:39 +01001258 /* Create server object. */
1259 lua_newtable(L);
1260 lua_pushstring(L, "__index");
1261 lua_newtable(L);
1262 hlua_class_function(L, "is_draining", hlua_server_is_draining);
1263 hlua_class_function(L, "set_weight", hlua_server_set_weight);
1264 hlua_class_function(L, "get_weight", hlua_server_get_weight);
1265 hlua_class_function(L, "set_addr", hlua_server_set_addr);
1266 hlua_class_function(L, "get_addr", hlua_server_get_addr);
1267 hlua_class_function(L, "get_stats", hlua_server_get_stats);
1268 hlua_class_function(L, "shut_sess", hlua_server_shut_sess);
1269 hlua_class_function(L, "set_drain", hlua_server_set_drain);
1270 hlua_class_function(L, "set_maint", hlua_server_set_maint);
1271 hlua_class_function(L, "set_ready", hlua_server_set_ready);
1272 hlua_class_function(L, "check_enable", hlua_server_check_enable);
1273 hlua_class_function(L, "check_disable", hlua_server_check_disable);
1274 hlua_class_function(L, "check_force_up", hlua_server_check_force_up);
1275 hlua_class_function(L, "check_force_nolb", hlua_server_check_force_nolb);
1276 hlua_class_function(L, "check_force_down", hlua_server_check_force_down);
1277 hlua_class_function(L, "agent_enable", hlua_server_agent_enable);
1278 hlua_class_function(L, "agent_disable", hlua_server_agent_disable);
1279 hlua_class_function(L, "agent_force_up", hlua_server_agent_force_up);
1280 hlua_class_function(L, "agent_force_down", hlua_server_agent_force_down);
1281 lua_settable(L, -3); /* -> META["__index"] = TABLE */
1282 class_server_ref = hlua_register_metatable(L, CLASS_SERVER);
1283
Thierry Fournierf61aa632016-02-19 20:56:00 +01001284 /* Create proxy object. */
1285 lua_newtable(L);
1286 lua_pushstring(L, "__index");
1287 lua_newtable(L);
1288 hlua_class_function(L, "pause", hlua_proxy_pause);
1289 hlua_class_function(L, "resume", hlua_proxy_resume);
1290 hlua_class_function(L, "stop", hlua_proxy_stop);
1291 hlua_class_function(L, "shut_bcksess", hlua_proxy_shut_bcksess);
1292 hlua_class_function(L, "get_cap", hlua_proxy_get_cap);
1293 hlua_class_function(L, "get_mode", hlua_proxy_get_mode);
1294 hlua_class_function(L, "get_stats", hlua_proxy_get_stats);
1295 lua_settable(L, -3); /* -> META["__index"] = TABLE */
1296 class_proxy_ref = hlua_register_metatable(L, CLASS_PROXY);
1297
Thierry Fournier1550d5d2016-01-21 09:35:41 +01001298 return 5;
Thierry Fournierfb0b5462016-01-21 09:28:58 +01001299}