blob: 5cbfcfef9e9200c3e94a7c8d9d91640b8c08e3f6 [file] [log] [blame]
Thierry Fourniere726b142016-02-11 17:57:57 +01001/*
2 * Lua unsafe core engine
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
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010013#include <sys/socket.h>
14
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +010015#include <ctype.h>
Thierry FOURNIERbabae282015-09-17 11:36:37 +020016#include <setjmp.h>
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +010017
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +010018#include <lauxlib.h>
19#include <lua.h>
20#include <lualib.h>
21
Thierry FOURNIER463119c2015-03-10 00:35:36 +010022#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 503
23#error "Requires Lua 5.3 or later."
Cyril Bontédc0306e2015-03-02 00:08:40 +010024#endif
25
Thierry FOURNIER380d0932015-01-23 14:27:52 +010026#include <ebpttree.h>
27
28#include <common/cfgparse.h>
29
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010030#include <types/connection.h>
Thierry FOURNIER380d0932015-01-23 14:27:52 +010031#include <types/hlua.h>
32#include <types/proxy.h>
33
Thierry FOURNIER55da1652015-01-23 11:36:30 +010034#include <proto/arg.h>
Willy Tarreau8a8d83b2015-04-13 13:24:54 +020035#include <proto/applet.h>
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010036#include <proto/channel.h>
Thierry FOURNIER9a819e72015-02-16 20:22:55 +010037#include <proto/hdr_idx.h>
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +010038#include <proto/hlua.h>
Thierry Fournierfb0b5462016-01-21 09:28:58 +010039#include <proto/hlua_fcn.h>
Thierry FOURNIER3def3932015-04-07 11:27:54 +020040#include <proto/map.h>
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010041#include <proto/obj_type.h>
Thierry FOURNIER83758bb2015-02-04 13:21:04 +010042#include <proto/pattern.h>
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +010043#include <proto/payload.h>
44#include <proto/proto_http.h>
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +010045#include <proto/proto_tcp.h>
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010046#include <proto/raw_sock.h>
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +010047#include <proto/sample.h>
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010048#include <proto/server.h>
Willy Tarreaufeb76402015-04-03 14:10:06 +020049#include <proto/session.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020050#include <proto/stream.h>
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010051#include <proto/ssl_sock.h>
52#include <proto/stream_interface.h>
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +010053#include <proto/task.h>
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +020054#include <proto/vars.h>
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +010055
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +010056/* Lua uses longjmp to perform yield or throwing errors. This
57 * macro is used only for identifying the function that can
58 * not return because a longjmp is executed.
59 * __LJMP marks a prototype of hlua file that can use longjmp.
60 * WILL_LJMP() marks an lua function that will use longjmp.
61 * MAY_LJMP() marks an lua function that may use longjmp.
62 */
63#define __LJMP
64#define WILL_LJMP(func) func
65#define MAY_LJMP(func) func
66
Thierry FOURNIERbabae282015-09-17 11:36:37 +020067/* This couple of function executes securely some Lua calls outside of
68 * the lua runtime environment. Each Lua call can return a longjmp
69 * if it encounter a memory error.
70 *
71 * Lua documentation extract:
72 *
73 * If an error happens outside any protected environment, Lua calls
74 * a panic function (see lua_atpanic) and then calls abort, thus
75 * exiting the host application. Your panic function can avoid this
76 * exit by never returning (e.g., doing a long jump to your own
77 * recovery point outside Lua).
78 *
79 * The panic function runs as if it were a message handler (see
80 * §2.3); in particular, the error message is at the top of the
81 * stack. However, there is no guarantee about stack space. To push
82 * anything on the stack, the panic function must first check the
83 * available space (see §4.2).
84 *
85 * We must check all the Lua entry point. This includes:
86 * - The include/proto/hlua.h exported functions
87 * - the task wrapper function
88 * - The action wrapper function
89 * - The converters wrapper function
90 * - The sample-fetch wrapper functions
91 *
92 * It is tolerated that the initilisation function returns an abort.
93 * Before each Lua abort, an error message is writed on stderr.
94 *
95 * The macro SET_SAFE_LJMP initialise the longjmp. The Macro
96 * RESET_SAFE_LJMP reset the longjmp. These function must be macro
97 * because they must be exists in the program stack when the longjmp
98 * is called.
99 */
100jmp_buf safe_ljmp_env;
101static int hlua_panic_safe(lua_State *L) { return 0; }
102static int hlua_panic_ljmp(lua_State *L) { longjmp(safe_ljmp_env, 1); }
103
104#define SET_SAFE_LJMP(__L) \
105 ({ \
106 int ret; \
107 if (setjmp(safe_ljmp_env) != 0) { \
108 lua_atpanic(__L, hlua_panic_safe); \
109 ret = 0; \
110 } else { \
111 lua_atpanic(__L, hlua_panic_ljmp); \
112 ret = 1; \
113 } \
114 ret; \
115 })
116
117/* If we are the last function catching Lua errors, we
118 * must reset the panic function.
119 */
120#define RESET_SAFE_LJMP(__L) \
121 do { \
122 lua_atpanic(__L, hlua_panic_safe); \
123 } while(0)
124
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200125/* Applet status flags */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200126#define APPLET_DONE 0x01 /* applet processing is done. */
127#define APPLET_100C 0x02 /* 100 continue expected. */
128#define APPLET_HDR_SENT 0x04 /* Response header sent. */
129#define APPLET_CHUNKED 0x08 /* Use transfer encoding chunked. */
130#define APPLET_LAST_CHK 0x10 /* Last chunk sent. */
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +0100131#define APPLET_HTTP11 0x20 /* Last chunk sent. */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200132
133#define HTTP_100C "HTTP/1.1 100 Continue\r\n\r\n"
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200134
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100135/* The main Lua execution context. */
136struct hlua gL;
137
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100138/* This is the memory pool containing all the signal structs. These
139 * struct are used to store each requiered signal between two tasks.
140 */
141struct pool_head *pool2_hlua_com;
142
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +0100143/* Used for Socket connection. */
144static struct proxy socket_proxy;
145static struct server socket_tcp;
146#ifdef USE_OPENSSL
147static struct server socket_ssl;
148#endif
149
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +0100150/* List head of the function called at the initialisation time. */
151struct list hlua_init_functions = LIST_HEAD_INIT(hlua_init_functions);
152
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +0100153/* The following variables contains the reference of the different
154 * Lua classes. These references are useful for identify metadata
155 * associated with an object.
156 */
Thierry FOURNIER65f34c62015-02-16 20:11:43 +0100157static int class_txn_ref;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +0100158static int class_socket_ref;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +0100159static int class_channel_ref;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +0100160static int class_fetches_ref;
Thierry FOURNIER594afe72015-03-10 23:58:30 +0100161static int class_converters_ref;
Thierry FOURNIER08504f42015-03-16 14:17:08 +0100162static int class_http_ref;
Thierry FOURNIER3def3932015-04-07 11:27:54 +0200163static int class_map_ref;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200164static int class_applet_tcp_ref;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200165static int class_applet_http_ref;
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +0100166
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100167/* Global Lua execution timeout. By default Lua, execution linked
Willy Tarreau87b09662015-04-03 00:22:06 +0200168 * with stream (actions, sample-fetches and converters) have a
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100169 * short timeout. Lua linked with tasks doesn't have a timeout
170 * because a task may remain alive during all the haproxy execution.
171 */
172static unsigned int hlua_timeout_session = 4000; /* session timeout. */
173static unsigned int hlua_timeout_task = TICK_ETERNITY; /* task timeout. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200174static unsigned int hlua_timeout_applet = 4000; /* applet timeout. */
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100175
Thierry FOURNIERee9f8022015-03-03 17:37:37 +0100176/* Interrupts the Lua processing each "hlua_nb_instruction" instructions.
177 * it is used for preventing infinite loops.
178 *
179 * I test the scheer with an infinite loop containing one incrementation
180 * and one test. I run this loop between 10 seconds, I raise a ceil of
181 * 710M loops from one interrupt each 9000 instructions, so I fix the value
182 * to one interrupt each 10 000 instructions.
183 *
184 * configured | Number of
185 * instructions | loops executed
186 * between two | in milions
187 * forced yields |
188 * ---------------+---------------
189 * 10 | 160
190 * 500 | 670
191 * 1000 | 680
192 * 5000 | 700
193 * 7000 | 700
194 * 8000 | 700
195 * 9000 | 710 <- ceil
196 * 10000 | 710
197 * 100000 | 710
198 * 1000000 | 710
199 *
200 */
201static unsigned int hlua_nb_instruction = 10000;
202
Willy Tarreau32f61e22015-03-18 17:54:59 +0100203/* Descriptor for the memory allocation state. If limit is not null, it will
204 * be enforced on any memory allocation.
205 */
206struct hlua_mem_allocator {
207 size_t allocated;
208 size_t limit;
209};
210
211static struct hlua_mem_allocator hlua_global_allocator;
212
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200213static const char error_500[] =
214 "HTTP/1.0 500 Server Error\r\n"
215 "Cache-Control: no-cache\r\n"
216 "Connection: close\r\n"
217 "Content-Type: text/html\r\n"
218 "\r\n"
219 "<html><body><h1>500 Server Error</h1>\nAn internal server error occured.\n</body></html>\n";
220
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100221/* These functions converts types between HAProxy internal args or
222 * sample and LUA types. Another function permits to check if the
223 * LUA stack contains arguments according with an required ARG_T
224 * format.
225 */
226static int hlua_arg2lua(lua_State *L, const struct arg *arg);
227static int hlua_lua2arg(lua_State *L, int ud, struct arg *arg);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100228__LJMP static int hlua_lua2arg_check(lua_State *L, int first, struct arg *argp,
David Carlier0c437f42016-04-27 16:21:56 +0100229 uint64_t mask, struct proxy *p);
Willy Tarreau5eadada2015-03-10 17:28:54 +0100230static int hlua_smp2lua(lua_State *L, struct sample *smp);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100231static int hlua_smp2lua_str(lua_State *L, struct sample *smp);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100232static int hlua_lua2smp(lua_State *L, int ud, struct sample *smp);
233
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200234__LJMP static int hlua_http_get_headers(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg);
235
Thierry FOURNIER23bc3752015-09-11 19:15:43 +0200236#define SEND_ERR(__be, __fmt, __args...) \
237 do { \
238 send_log(__be, LOG_ERR, __fmt, ## __args); \
239 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) \
240 Alert(__fmt, ## __args); \
241 } while (0)
242
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100243/* Used to check an Lua function type in the stack. It creates and
244 * returns a reference of the function. This function throws an
245 * error if the rgument is not a "function".
246 */
247__LJMP unsigned int hlua_checkfunction(lua_State *L, int argno)
248{
249 if (!lua_isfunction(L, argno)) {
250 const char *msg = lua_pushfstring(L, "function expected, got %s", luaL_typename(L, -1));
251 WILL_LJMP(luaL_argerror(L, argno, msg));
252 }
253 lua_pushvalue(L, argno);
254 return luaL_ref(L, LUA_REGISTRYINDEX);
255}
256
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200257/* Return the string that is of the top of the stack. */
258const char *hlua_get_top_error_string(lua_State *L)
259{
260 if (lua_gettop(L) < 1)
261 return "unknown error";
262 if (lua_type(L, -1) != LUA_TSTRING)
263 return "unknown error";
264 return lua_tostring(L, -1);
265}
266
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100267/* This function check the number of arguments available in the
268 * stack. If the number of arguments available is not the same
269 * then <nb> an error is throwed.
270 */
271__LJMP static inline void check_args(lua_State *L, int nb, char *fcn)
272{
273 if (lua_gettop(L) == nb)
274 return;
275 WILL_LJMP(luaL_error(L, "'%s' needs %d arguments", fcn, nb));
276}
277
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100278/* This fucntion push an error string prefixed by the file name
279 * and the line number where the error is encountered.
280 */
281static int hlua_pusherror(lua_State *L, const char *fmt, ...)
282{
283 va_list argp;
284 va_start(argp, fmt);
285 luaL_where(L, 1);
286 lua_pushvfstring(L, fmt, argp);
287 va_end(argp);
288 lua_concat(L, 2);
289 return 1;
290}
291
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100292/* This function register a new signal. "lua" is the current lua
293 * execution context. It contains a pointer to the associated task.
294 * "link" is a list head attached to an other task that must be wake
295 * the lua task if an event occurs. This is useful with external
296 * events like TCP I/O or sleep functions. This funcion allocate
297 * memory for the signal.
298 */
299static int hlua_com_new(struct hlua *lua, struct list *link)
300{
301 struct hlua_com *com = pool_alloc2(pool2_hlua_com);
302 if (!com)
303 return 0;
304 LIST_ADDQ(&lua->com, &com->purge_me);
305 LIST_ADDQ(link, &com->wake_me);
306 com->task = lua->task;
307 return 1;
308}
309
310/* This function purge all the pending signals when the LUA execution
311 * is finished. This prevent than a coprocess try to wake a deleted
312 * task. This function remove the memory associated to the signal.
313 */
314static void hlua_com_purge(struct hlua *lua)
315{
316 struct hlua_com *com, *back;
317
318 /* Delete all pending communication signals. */
319 list_for_each_entry_safe(com, back, &lua->com, purge_me) {
320 LIST_DEL(&com->purge_me);
321 LIST_DEL(&com->wake_me);
322 pool_free2(pool2_hlua_com, com);
323 }
324}
325
326/* This function sends signals. It wakes all the tasks attached
327 * to a list head, and remove the signal, and free the used
328 * memory.
329 */
330static void hlua_com_wake(struct list *wake)
331{
332 struct hlua_com *com, *back;
333
334 /* Wake task and delete all pending communication signals. */
335 list_for_each_entry_safe(com, back, wake, wake_me) {
336 LIST_DEL(&com->purge_me);
337 LIST_DEL(&com->wake_me);
338 task_wakeup(com->task, TASK_WOKEN_MSG);
339 pool_free2(pool2_hlua_com, com);
340 }
341}
342
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100343/* This functions is used with sample fetch and converters. It
344 * converts the HAProxy configuration argument in a lua stack
345 * values.
346 *
347 * It takes an array of "arg", and each entry of the array is
348 * converted and pushed in the LUA stack.
349 */
350static int hlua_arg2lua(lua_State *L, const struct arg *arg)
351{
352 switch (arg->type) {
353 case ARGT_SINT:
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100354 case ARGT_TIME:
355 case ARGT_SIZE:
Thierry FOURNIERf90838b2015-03-06 13:48:32 +0100356 lua_pushinteger(L, arg->data.sint);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100357 break;
358
359 case ARGT_STR:
360 lua_pushlstring(L, arg->data.str.str, arg->data.str.len);
361 break;
362
363 case ARGT_IPV4:
364 case ARGT_IPV6:
365 case ARGT_MSK4:
366 case ARGT_MSK6:
367 case ARGT_FE:
368 case ARGT_BE:
369 case ARGT_TAB:
370 case ARGT_SRV:
371 case ARGT_USR:
372 case ARGT_MAP:
373 default:
374 lua_pushnil(L);
375 break;
376 }
377 return 1;
378}
379
380/* This function take one entrie in an LUA stack at the index "ud",
381 * and try to convert it in an HAProxy argument entry. This is useful
382 * with sample fetch wrappers. The input arguments are gived to the
383 * lua wrapper and converted as arg list by thi function.
384 */
385static int hlua_lua2arg(lua_State *L, int ud, struct arg *arg)
386{
387 switch (lua_type(L, ud)) {
388
389 case LUA_TNUMBER:
390 case LUA_TBOOLEAN:
391 arg->type = ARGT_SINT;
392 arg->data.sint = lua_tointeger(L, ud);
393 break;
394
395 case LUA_TSTRING:
396 arg->type = ARGT_STR;
397 arg->data.str.str = (char *)lua_tolstring(L, ud, (size_t *)&arg->data.str.len);
398 break;
399
400 case LUA_TUSERDATA:
401 case LUA_TNIL:
402 case LUA_TTABLE:
403 case LUA_TFUNCTION:
404 case LUA_TTHREAD:
405 case LUA_TLIGHTUSERDATA:
406 arg->type = ARGT_SINT;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +0200407 arg->data.sint = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100408 break;
409 }
410 return 1;
411}
412
413/* the following functions are used to convert a struct sample
414 * in Lua type. This useful to convert the return of the
415 * fetchs or converters.
416 */
Willy Tarreau5eadada2015-03-10 17:28:54 +0100417static int hlua_smp2lua(lua_State *L, struct sample *smp)
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100418{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200419 switch (smp->data.type) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100420 case SMP_T_SINT:
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100421 case SMP_T_BOOL:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200422 lua_pushinteger(L, smp->data.u.sint);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100423 break;
424
425 case SMP_T_BIN:
426 case SMP_T_STR:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200427 lua_pushlstring(L, smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100428 break;
429
430 case SMP_T_METH:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200431 switch (smp->data.u.meth.meth) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100432 case HTTP_METH_OPTIONS: lua_pushstring(L, "OPTIONS"); break;
433 case HTTP_METH_GET: lua_pushstring(L, "GET"); break;
434 case HTTP_METH_HEAD: lua_pushstring(L, "HEAD"); break;
435 case HTTP_METH_POST: lua_pushstring(L, "POST"); break;
436 case HTTP_METH_PUT: lua_pushstring(L, "PUT"); break;
437 case HTTP_METH_DELETE: lua_pushstring(L, "DELETE"); break;
438 case HTTP_METH_TRACE: lua_pushstring(L, "TRACE"); break;
439 case HTTP_METH_CONNECT: lua_pushstring(L, "CONNECT"); break;
440 case HTTP_METH_OTHER:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200441 lua_pushlstring(L, smp->data.u.meth.str.str, smp->data.u.meth.str.len);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100442 break;
443 default:
444 lua_pushnil(L);
445 break;
446 }
447 break;
448
449 case SMP_T_IPV4:
450 case SMP_T_IPV6:
451 case SMP_T_ADDR: /* This type is never used to qualify a sample. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200452 if (sample_casts[smp->data.type][SMP_T_STR] &&
453 sample_casts[smp->data.type][SMP_T_STR](smp))
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200454 lua_pushlstring(L, smp->data.u.str.str, smp->data.u.str.len);
Willy Tarreau5eadada2015-03-10 17:28:54 +0100455 else
456 lua_pushnil(L);
457 break;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100458 default:
459 lua_pushnil(L);
460 break;
461 }
462 return 1;
463}
464
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100465/* the following functions are used to convert a struct sample
466 * in Lua strings. This is useful to convert the return of the
467 * fetchs or converters.
468 */
469static int hlua_smp2lua_str(lua_State *L, struct sample *smp)
470{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200471 switch (smp->data.type) {
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100472
473 case SMP_T_BIN:
474 case SMP_T_STR:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200475 lua_pushlstring(L, smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100476 break;
477
478 case SMP_T_METH:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200479 switch (smp->data.u.meth.meth) {
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100480 case HTTP_METH_OPTIONS: lua_pushstring(L, "OPTIONS"); break;
481 case HTTP_METH_GET: lua_pushstring(L, "GET"); break;
482 case HTTP_METH_HEAD: lua_pushstring(L, "HEAD"); break;
483 case HTTP_METH_POST: lua_pushstring(L, "POST"); break;
484 case HTTP_METH_PUT: lua_pushstring(L, "PUT"); break;
485 case HTTP_METH_DELETE: lua_pushstring(L, "DELETE"); break;
486 case HTTP_METH_TRACE: lua_pushstring(L, "TRACE"); break;
487 case HTTP_METH_CONNECT: lua_pushstring(L, "CONNECT"); break;
488 case HTTP_METH_OTHER:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200489 lua_pushlstring(L, smp->data.u.meth.str.str, smp->data.u.meth.str.len);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100490 break;
491 default:
492 lua_pushstring(L, "");
493 break;
494 }
495 break;
496
497 case SMP_T_SINT:
498 case SMP_T_BOOL:
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100499 case SMP_T_IPV4:
500 case SMP_T_IPV6:
501 case SMP_T_ADDR: /* This type is never used to qualify a sample. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200502 if (sample_casts[smp->data.type][SMP_T_STR] &&
503 sample_casts[smp->data.type][SMP_T_STR](smp))
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200504 lua_pushlstring(L, smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100505 else
506 lua_pushstring(L, "");
507 break;
508 default:
509 lua_pushstring(L, "");
510 break;
511 }
512 return 1;
513}
514
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100515/* the following functions are used to convert an Lua type in a
516 * struct sample. This is useful to provide data from a converter
517 * to the LUA code.
518 */
519static int hlua_lua2smp(lua_State *L, int ud, struct sample *smp)
520{
521 switch (lua_type(L, ud)) {
522
523 case LUA_TNUMBER:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200524 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200525 smp->data.u.sint = lua_tointeger(L, ud);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100526 break;
527
528
529 case LUA_TBOOLEAN:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200530 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200531 smp->data.u.sint = lua_toboolean(L, ud);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100532 break;
533
534 case LUA_TSTRING:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200535 smp->data.type = SMP_T_STR;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100536 smp->flags |= SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200537 smp->data.u.str.str = (char *)lua_tolstring(L, ud, (size_t *)&smp->data.u.str.len);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100538 break;
539
540 case LUA_TUSERDATA:
541 case LUA_TNIL:
542 case LUA_TTABLE:
543 case LUA_TFUNCTION:
544 case LUA_TTHREAD:
545 case LUA_TLIGHTUSERDATA:
Thierry FOURNIER93405e12015-08-26 14:19:03 +0200546 case LUA_TNONE:
547 default:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200548 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200549 smp->data.u.sint = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100550 break;
551 }
552 return 1;
553}
554
555/* This function check the "argp" builded by another conversion function
556 * is in accord with the expected argp defined by the "mask". The fucntion
557 * returns true or false. It can be adjust the types if there compatibles.
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100558 *
559 * This function assumes thant the argp argument contains ARGM_NBARGS + 1
560 * entries.
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100561 */
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100562__LJMP int hlua_lua2arg_check(lua_State *L, int first, struct arg *argp,
David Carlier0c437f42016-04-27 16:21:56 +0100563 uint64_t mask, struct proxy *p)
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100564{
565 int min_arg;
566 int idx;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100567 struct proxy *px;
568 char *sname, *pname;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100569
570 idx = 0;
571 min_arg = ARGM(mask);
572 mask >>= ARGM_BITS;
573
574 while (1) {
575
576 /* Check oversize. */
577 if (idx >= ARGM_NBARGS && argp[idx].type != ARGT_STOP) {
Cyril Bonté577a36a2015-03-02 00:08:38 +0100578 WILL_LJMP(luaL_argerror(L, first + idx, "Malformed argument mask"));
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100579 }
580
581 /* Check for mandatory arguments. */
582 if (argp[idx].type == ARGT_STOP) {
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100583 if (idx < min_arg) {
584
585 /* If miss other argument than the first one, we return an error. */
586 if (idx > 0)
587 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
588
589 /* If first argument have a certain type, some default values
590 * may be used. See the function smp_resolve_args().
591 */
592 switch (mask & ARGT_MASK) {
593
594 case ARGT_FE:
595 if (!(p->cap & PR_CAP_FE))
596 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
597 argp[idx].data.prx = p;
598 argp[idx].type = ARGT_FE;
599 argp[idx+1].type = ARGT_STOP;
600 break;
601
602 case ARGT_BE:
603 if (!(p->cap & PR_CAP_BE))
604 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
605 argp[idx].data.prx = p;
606 argp[idx].type = ARGT_BE;
607 argp[idx+1].type = ARGT_STOP;
608 break;
609
610 case ARGT_TAB:
611 argp[idx].data.prx = p;
612 argp[idx].type = ARGT_TAB;
613 argp[idx+1].type = ARGT_STOP;
614 break;
615
616 default:
617 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
618 break;
619 }
620 }
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100621 return 0;
622 }
623
624 /* Check for exceed the number of requiered argument. */
625 if ((mask & ARGT_MASK) == ARGT_STOP &&
626 argp[idx].type != ARGT_STOP) {
627 WILL_LJMP(luaL_argerror(L, first + idx, "Last argument expected"));
628 }
629
630 if ((mask & ARGT_MASK) == ARGT_STOP &&
631 argp[idx].type == ARGT_STOP) {
632 return 0;
633 }
634
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100635 /* Convert some argument types. */
636 switch (mask & ARGT_MASK) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100637 case ARGT_SINT:
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100638 if (argp[idx].type != ARGT_SINT)
639 WILL_LJMP(luaL_argerror(L, first + idx, "integer expected"));
640 argp[idx].type = ARGT_SINT;
641 break;
642
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100643 case ARGT_TIME:
644 if (argp[idx].type != ARGT_SINT)
645 WILL_LJMP(luaL_argerror(L, first + idx, "integer expected"));
Thierry FOURNIER29176f32015-07-07 00:41:29 +0200646 argp[idx].type = ARGT_TIME;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100647 break;
648
649 case ARGT_SIZE:
650 if (argp[idx].type != ARGT_SINT)
651 WILL_LJMP(luaL_argerror(L, first + idx, "integer expected"));
Thierry FOURNIER29176f32015-07-07 00:41:29 +0200652 argp[idx].type = ARGT_SIZE;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100653 break;
654
655 case ARGT_FE:
656 if (argp[idx].type != ARGT_STR)
657 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
658 memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
659 trash.str[argp[idx].data.str.len] = 0;
Willy Tarreau9e0bb102015-05-26 11:24:42 +0200660 argp[idx].data.prx = proxy_fe_by_name(trash.str);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100661 if (!argp[idx].data.prx)
662 WILL_LJMP(luaL_argerror(L, first + idx, "frontend doesn't exist"));
663 argp[idx].type = ARGT_FE;
664 break;
665
666 case ARGT_BE:
667 if (argp[idx].type != ARGT_STR)
668 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
669 memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
670 trash.str[argp[idx].data.str.len] = 0;
Willy Tarreau9e0bb102015-05-26 11:24:42 +0200671 argp[idx].data.prx = proxy_be_by_name(trash.str);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100672 if (!argp[idx].data.prx)
673 WILL_LJMP(luaL_argerror(L, first + idx, "backend doesn't exist"));
674 argp[idx].type = ARGT_BE;
675 break;
676
677 case ARGT_TAB:
678 if (argp[idx].type != ARGT_STR)
679 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
680 memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
681 trash.str[argp[idx].data.str.len] = 0;
Willy Tarreaue2dc1fa2015-05-26 12:08:07 +0200682 argp[idx].data.prx = proxy_tbl_by_name(trash.str);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100683 if (!argp[idx].data.prx)
684 WILL_LJMP(luaL_argerror(L, first + idx, "table doesn't exist"));
685 argp[idx].type = ARGT_TAB;
686 break;
687
688 case ARGT_SRV:
689 if (argp[idx].type != ARGT_STR)
690 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
691 memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
692 trash.str[argp[idx].data.str.len] = 0;
693 sname = strrchr(trash.str, '/');
694 if (sname) {
695 *sname++ = '\0';
696 pname = trash.str;
Willy Tarreau9e0bb102015-05-26 11:24:42 +0200697 px = proxy_be_by_name(pname);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100698 if (!px)
699 WILL_LJMP(luaL_argerror(L, first + idx, "backend doesn't exist"));
700 }
701 else {
702 sname = trash.str;
703 px = p;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100704 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100705 argp[idx].data.srv = findserver(px, sname);
706 if (!argp[idx].data.srv)
707 WILL_LJMP(luaL_argerror(L, first + idx, "server doesn't exist"));
708 argp[idx].type = ARGT_SRV;
709 break;
710
711 case ARGT_IPV4:
712 memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
713 trash.str[argp[idx].data.str.len] = 0;
714 if (inet_pton(AF_INET, trash.str, &argp[idx].data.ipv4))
715 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv4 address"));
716 argp[idx].type = ARGT_IPV4;
717 break;
718
719 case ARGT_MSK4:
720 memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
721 trash.str[argp[idx].data.str.len] = 0;
722 if (!str2mask(trash.str, &argp[idx].data.ipv4))
723 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv4 mask"));
724 argp[idx].type = ARGT_MSK4;
725 break;
726
727 case ARGT_IPV6:
728 memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
729 trash.str[argp[idx].data.str.len] = 0;
730 if (inet_pton(AF_INET6, trash.str, &argp[idx].data.ipv6))
731 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv6 address"));
732 argp[idx].type = ARGT_IPV6;
733 break;
734
735 case ARGT_MSK6:
736 case ARGT_MAP:
737 case ARGT_REG:
738 case ARGT_USR:
739 WILL_LJMP(luaL_argerror(L, first + idx, "type not yet supported"));
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100740 break;
741 }
742
743 /* Check for type of argument. */
744 if ((mask & ARGT_MASK) != argp[idx].type) {
745 const char *msg = lua_pushfstring(L, "'%s' expected, got '%s'",
746 arg_type_names[(mask & ARGT_MASK)],
747 arg_type_names[argp[idx].type & ARGT_MASK]);
748 WILL_LJMP(luaL_argerror(L, first + idx, msg));
749 }
750
751 /* Next argument. */
752 mask >>= ARGT_BITS;
753 idx++;
754 }
755}
756
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100757/*
758 * The following functions are used to make correspondance between the the
759 * executed lua pointer and the "struct hlua *" that contain the context.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100760 *
761 * - hlua_gethlua : return the hlua context associated with an lua_State.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100762 * - hlua_sethlua : create the association between hlua context and lua_state.
763 */
764static inline struct hlua *hlua_gethlua(lua_State *L)
765{
Thierry FOURNIER38c5fd62015-03-10 02:40:29 +0100766 struct hlua **hlua = lua_getextraspace(L);
767 return *hlua;
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100768}
769static inline void hlua_sethlua(struct hlua *hlua)
770{
Thierry FOURNIER38c5fd62015-03-10 02:40:29 +0100771 struct hlua **hlua_store = lua_getextraspace(hlua->T);
772 *hlua_store = hlua;
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100773}
774
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100775/* This function is used to send logs. It try to send on screen (stderr)
776 * and on the default syslog server.
777 */
778static inline void hlua_sendlog(struct proxy *px, int level, const char *msg)
779{
780 struct tm tm;
781 char *p;
782
783 /* Cleanup the log message. */
784 p = trash.str;
785 for (; *msg != '\0'; msg++, p++) {
Thierry FOURNIERccf00632015-09-16 12:47:03 +0200786 if (p >= trash.str + trash.size - 1) {
787 /* Break the message if exceed the buffer size. */
788 *(p-4) = ' ';
789 *(p-3) = '.';
790 *(p-2) = '.';
791 *(p-1) = '.';
792 break;
793 }
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100794 if (isprint(*msg))
795 *p = *msg;
796 else
797 *p = '.';
798 }
799 *p = '\0';
800
Thierry FOURNIER5554e292015-09-09 11:21:37 +0200801 send_log(px, level, "%s\n", trash.str);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100802 if (!(global.mode & MODE_QUIET) || (global.mode & (MODE_VERBOSE | MODE_STARTING))) {
Willy Tarreaua678b432015-08-28 10:14:59 +0200803 get_localtime(date.tv_sec, &tm);
804 fprintf(stderr, "[%s] %03d/%02d%02d%02d (%d) : %s\n",
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100805 log_levels[level], tm.tm_yday, tm.tm_hour, tm.tm_min, tm.tm_sec,
806 (int)getpid(), trash.str);
807 fflush(stderr);
808 }
809}
810
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100811/* This function just ensure that the yield will be always
812 * returned with a timeout and permit to set some flags
813 */
814__LJMP void hlua_yieldk(lua_State *L, int nresults, int ctx,
Thierry FOURNIERf90838b2015-03-06 13:48:32 +0100815 lua_KFunction k, int timeout, unsigned int flags)
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100816{
817 struct hlua *hlua = hlua_gethlua(L);
818
819 /* Set the wake timeout. If timeout is required, we set
820 * the expiration time.
821 */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +0200822 hlua->wake_time = timeout;
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100823
Thierry FOURNIER4abd3ae2015-03-03 17:29:06 +0100824 hlua->flags |= flags;
825
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100826 /* Process the yield. */
827 WILL_LJMP(lua_yieldk(L, nresults, ctx, k));
828}
829
Willy Tarreau87b09662015-04-03 00:22:06 +0200830/* This function initialises the Lua environment stored in the stream.
831 * It must be called at the start of the stream. This function creates
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100832 * an LUA coroutine. It can not be use to crete the main LUA context.
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200833 *
834 * This function is particular. it initialises a new Lua thread. If the
835 * initialisation fails (example: out of memory error), the lua function
836 * throws an error (longjmp).
837 *
838 * This function manipulates two Lua stack: the main and the thread. Only
839 * the main stack can fail. The thread is not manipulated. This function
840 * MUST NOT manipulate the created thread stack state, because is not
841 * proctected agains error throwed by the thread stack.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100842 */
843int hlua_ctx_init(struct hlua *lua, struct task *task)
844{
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200845 if (!SET_SAFE_LJMP(gL.T)) {
846 lua->Tref = LUA_REFNIL;
847 return 0;
848 }
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100849 lua->Mref = LUA_REFNIL;
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +0100850 lua->flags = 0;
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100851 LIST_INIT(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100852 lua->T = lua_newthread(gL.T);
853 if (!lua->T) {
854 lua->Tref = LUA_REFNIL;
855 return 0;
856 }
857 hlua_sethlua(lua);
858 lua->Tref = luaL_ref(gL.T, LUA_REGISTRYINDEX);
859 lua->task = task;
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200860 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100861 return 1;
862}
863
Willy Tarreau87b09662015-04-03 00:22:06 +0200864/* Used to destroy the Lua coroutine when the attached stream or task
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100865 * is destroyed. The destroy also the memory context. The struct "lua"
866 * is not freed.
867 */
868void hlua_ctx_destroy(struct hlua *lua)
869{
Thierry FOURNIERa718b292015-03-04 16:48:34 +0100870 if (!lua->T)
871 return;
872
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100873 /* Purge all the pending signals. */
874 hlua_com_purge(lua);
875
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100876 luaL_unref(lua->T, LUA_REGISTRYINDEX, lua->Mref);
877 luaL_unref(gL.T, LUA_REGISTRYINDEX, lua->Tref);
Thierry FOURNIER5a50a852015-09-23 16:59:28 +0200878
879 /* Forces a garbage collecting process. If the Lua program is finished
880 * without error, we run the GC on the thread pointer. Its freed all
881 * the unused memory.
882 * If the thread is finnish with an error or is currently yielded,
883 * it seems that the GC applied on the thread doesn't clean anything,
884 * so e run the GC on the main thread.
885 * NOTE: maybe this action locks all the Lua threads untiml the en of
886 * the garbage collection.
887 */
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +0200888 if (lua->flags & HLUA_MUST_GC) {
889 lua_gc(lua->T, LUA_GCCOLLECT, 0);
890 if (lua_status(lua->T) != LUA_OK)
891 lua_gc(gL.T, LUA_GCCOLLECT, 0);
892 }
Thierry FOURNIER5a50a852015-09-23 16:59:28 +0200893
Thierry FOURNIERa7b536b2015-09-21 22:50:24 +0200894 lua->T = NULL;
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100895}
896
897/* This function is used to restore the Lua context when a coroutine
898 * fails. This function copy the common memory between old coroutine
899 * and the new coroutine. The old coroutine is destroyed, and its
900 * replaced by the new coroutine.
901 * If the flag "keep_msg" is set, the last entry of the old is assumed
902 * as string error message and it is copied in the new stack.
903 */
904static int hlua_ctx_renew(struct hlua *lua, int keep_msg)
905{
906 lua_State *T;
907 int new_ref;
908
909 /* Renew the main LUA stack doesn't have sense. */
910 if (lua == &gL)
911 return 0;
912
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100913 /* New Lua coroutine. */
914 T = lua_newthread(gL.T);
915 if (!T)
916 return 0;
917
918 /* Copy last error message. */
919 if (keep_msg)
920 lua_xmove(lua->T, T, 1);
921
922 /* Copy data between the coroutines. */
923 lua_rawgeti(lua->T, LUA_REGISTRYINDEX, lua->Mref);
924 lua_xmove(lua->T, T, 1);
925 new_ref = luaL_ref(T, LUA_REGISTRYINDEX); /* Valur poped. */
926
927 /* Destroy old data. */
928 luaL_unref(lua->T, LUA_REGISTRYINDEX, lua->Mref);
929
930 /* The thread is garbage collected by Lua. */
931 luaL_unref(gL.T, LUA_REGISTRYINDEX, lua->Tref);
932
933 /* Fill the struct with the new coroutine values. */
934 lua->Mref = new_ref;
935 lua->T = T;
936 lua->Tref = luaL_ref(gL.T, LUA_REGISTRYINDEX);
937
938 /* Set context. */
939 hlua_sethlua(lua);
940
941 return 1;
942}
943
Thierry FOURNIERee9f8022015-03-03 17:37:37 +0100944void hlua_hook(lua_State *L, lua_Debug *ar)
945{
Thierry FOURNIERcae49c92015-03-06 14:05:24 +0100946 struct hlua *hlua = hlua_gethlua(L);
947
948 /* Lua cannot yield when its returning from a function,
949 * so, we can fix the interrupt hook to 1 instruction,
950 * expecting that the function is finnished.
951 */
952 if (lua_gethookmask(L) & LUA_MASKRET) {
953 lua_sethook(hlua->T, hlua_hook, LUA_MASKCOUNT, 1);
954 return;
955 }
956
957 /* restore the interrupt condition. */
958 lua_sethook(hlua->T, hlua_hook, LUA_MASKCOUNT, hlua_nb_instruction);
959
960 /* If we interrupt the Lua processing in yieldable state, we yield.
961 * If the state is not yieldable, trying yield causes an error.
962 */
963 if (lua_isyieldable(L))
964 WILL_LJMP(hlua_yieldk(L, 0, 0, NULL, TICK_ETERNITY, HLUA_CTRLYIELD));
965
Thierry FOURNIERa85cfb12015-03-13 14:50:06 +0100966 /* If we cannot yield, update the clock and check the timeout. */
967 tv_update_date(0, 1);
Thierry FOURNIER10770fa2015-09-29 01:59:42 +0200968 hlua->run_time += now_ms - hlua->start_time;
969 if (hlua->max_time && hlua->run_time >= hlua->max_time) {
Thierry FOURNIERcae49c92015-03-06 14:05:24 +0100970 lua_pushfstring(L, "execution timeout");
971 WILL_LJMP(lua_error(L));
972 }
973
Thierry FOURNIER10770fa2015-09-29 01:59:42 +0200974 /* Update the start time. */
975 hlua->start_time = now_ms;
976
Thierry FOURNIERcae49c92015-03-06 14:05:24 +0100977 /* Try to interrupt the process at the end of the current
978 * unyieldable function.
979 */
980 lua_sethook(hlua->T, hlua_hook, LUA_MASKRET|LUA_MASKCOUNT, hlua_nb_instruction);
Thierry FOURNIERee9f8022015-03-03 17:37:37 +0100981}
982
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100983/* This function start or resumes the Lua stack execution. If the flag
984 * "yield_allowed" if no set and the LUA stack execution returns a yield
985 * The function return an error.
986 *
987 * The function can returns 4 values:
988 * - HLUA_E_OK : The execution is terminated without any errors.
989 * - HLUA_E_AGAIN : The execution must continue at the next associated
990 * task wakeup.
991 * - HLUA_E_ERRMSG : An error has occured, an error message is set in
992 * the top of the stack.
993 * - HLUA_E_ERR : An error has occured without error message.
994 *
995 * If an error occured, the stack is renewed and it is ready to run new
996 * LUA code.
997 */
998static enum hlua_exec hlua_ctx_resume(struct hlua *lua, int yield_allowed)
999{
1000 int ret;
1001 const char *msg;
1002
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001003 /* Initialise run time counter. */
1004 if (!HLUA_IS_RUNNING(lua))
1005 lua->run_time = 0;
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001006
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001007resume_execution:
1008
1009 /* This hook interrupts the Lua processing each 'hlua_nb_instruction'
1010 * instructions. it is used for preventing infinite loops.
1011 */
1012 lua_sethook(lua->T, hlua_hook, LUA_MASKCOUNT, hlua_nb_instruction);
1013
Thierry FOURNIER1bfc09b2015-03-05 17:10:14 +01001014 /* Remove all flags except the running flags. */
Thierry FOURNIER2f3867f2015-09-28 01:02:01 +02001015 HLUA_SET_RUN(lua);
1016 HLUA_CLR_CTRLYIELD(lua);
1017 HLUA_CLR_WAKERESWR(lua);
1018 HLUA_CLR_WAKEREQWR(lua);
Thierry FOURNIER1bfc09b2015-03-05 17:10:14 +01001019
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001020 /* Update the start time. */
1021 lua->start_time = now_ms;
1022
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001023 /* Call the function. */
1024 ret = lua_resume(lua->T, gL.T, lua->nargs);
1025 switch (ret) {
1026
1027 case LUA_OK:
1028 ret = HLUA_E_OK;
1029 break;
1030
1031 case LUA_YIELD:
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001032 /* Check if the execution timeout is expired. It it is the case, we
1033 * break the Lua execution.
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001034 */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001035 tv_update_date(0, 1);
1036 lua->run_time += now_ms - lua->start_time;
1037 if (lua->max_time && lua->run_time > lua->max_time) {
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001038 lua_settop(lua->T, 0); /* Empty the stack. */
1039 if (!lua_checkstack(lua->T, 1)) {
1040 ret = HLUA_E_ERR;
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001041 break;
1042 }
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001043 lua_pushfstring(lua->T, "execution timeout");
1044 ret = HLUA_E_ERRMSG;
1045 break;
1046 }
1047 /* Process the forced yield. if the general yield is not allowed or
1048 * if no task were associated this the current Lua execution
1049 * coroutine, we resume the execution. Else we want to return in the
1050 * scheduler and we want to be waked up again, to continue the
1051 * current Lua execution. So we schedule our own task.
1052 */
1053 if (HLUA_IS_CTRLYIELDING(lua)) {
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001054 if (!yield_allowed || !lua->task)
1055 goto resume_execution;
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001056 task_wakeup(lua->task, TASK_WOKEN_MSG);
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001057 }
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001058 if (!yield_allowed) {
1059 lua_settop(lua->T, 0); /* Empty the stack. */
1060 if (!lua_checkstack(lua->T, 1)) {
1061 ret = HLUA_E_ERR;
1062 break;
1063 }
1064 lua_pushfstring(lua->T, "yield not allowed");
1065 ret = HLUA_E_ERRMSG;
1066 break;
1067 }
1068 ret = HLUA_E_AGAIN;
1069 break;
1070
1071 case LUA_ERRRUN:
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001072
1073 /* Special exit case. The traditionnal exit is returned as an error
1074 * because the errors ares the only one mean to return immediately
1075 * from and lua execution.
1076 */
1077 if (lua->flags & HLUA_EXIT) {
1078 ret = HLUA_E_OK;
Thierry FOURNIERe1587b32015-08-28 09:54:13 +02001079 hlua_ctx_renew(lua, 0);
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001080 break;
1081 }
1082
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001083 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001084 if (!lua_checkstack(lua->T, 1)) {
1085 ret = HLUA_E_ERR;
1086 break;
1087 }
1088 msg = lua_tostring(lua->T, -1);
1089 lua_settop(lua->T, 0); /* Empty the stack. */
1090 lua_pop(lua->T, 1);
1091 if (msg)
1092 lua_pushfstring(lua->T, "runtime error: %s", msg);
1093 else
1094 lua_pushfstring(lua->T, "unknown runtime error");
1095 ret = HLUA_E_ERRMSG;
1096 break;
1097
1098 case LUA_ERRMEM:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001099 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001100 lua_settop(lua->T, 0); /* Empty the stack. */
1101 if (!lua_checkstack(lua->T, 1)) {
1102 ret = HLUA_E_ERR;
1103 break;
1104 }
1105 lua_pushfstring(lua->T, "out of memory error");
1106 ret = HLUA_E_ERRMSG;
1107 break;
1108
1109 case LUA_ERRERR:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001110 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001111 if (!lua_checkstack(lua->T, 1)) {
1112 ret = HLUA_E_ERR;
1113 break;
1114 }
1115 msg = lua_tostring(lua->T, -1);
1116 lua_settop(lua->T, 0); /* Empty the stack. */
1117 lua_pop(lua->T, 1);
1118 if (msg)
1119 lua_pushfstring(lua->T, "message handler error: %s", msg);
1120 else
1121 lua_pushfstring(lua->T, "message handler error");
1122 ret = HLUA_E_ERRMSG;
1123 break;
1124
1125 default:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001126 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001127 lua_settop(lua->T, 0); /* Empty the stack. */
1128 if (!lua_checkstack(lua->T, 1)) {
1129 ret = HLUA_E_ERR;
1130 break;
1131 }
1132 lua_pushfstring(lua->T, "unknonwn error");
1133 ret = HLUA_E_ERRMSG;
1134 break;
1135 }
1136
Thierry FOURNIER6ab4d8e2015-09-27 22:17:19 +02001137 /* This GC permits to destroy some object when a Lua timeout strikes. */
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +02001138 if (lua->flags & HLUA_MUST_GC &&
1139 ret != HLUA_E_AGAIN)
Thierry FOURNIER6ab4d8e2015-09-27 22:17:19 +02001140 lua_gc(lua->T, LUA_GCCOLLECT, 0);
1141
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001142 switch (ret) {
1143 case HLUA_E_AGAIN:
1144 break;
1145
1146 case HLUA_E_ERRMSG:
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +01001147 hlua_com_purge(lua);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001148 hlua_ctx_renew(lua, 1);
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001149 HLUA_CLR_RUN(lua);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001150 break;
1151
1152 case HLUA_E_ERR:
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001153 HLUA_CLR_RUN(lua);
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +01001154 hlua_com_purge(lua);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001155 hlua_ctx_renew(lua, 0);
1156 break;
1157
1158 case HLUA_E_OK:
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001159 HLUA_CLR_RUN(lua);
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +01001160 hlua_com_purge(lua);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001161 break;
1162 }
1163
1164 return ret;
1165}
1166
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001167/* This function exit the current code. */
1168__LJMP static int hlua_done(lua_State *L)
1169{
1170 struct hlua *hlua = hlua_gethlua(L);
1171
1172 hlua->flags |= HLUA_EXIT;
1173 WILL_LJMP(lua_error(L));
1174
1175 return 0;
1176}
1177
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001178/* This function is an LUA binding. It provides a function
1179 * for deleting ACL from a referenced ACL file.
1180 */
1181__LJMP static int hlua_del_acl(lua_State *L)
1182{
1183 const char *name;
1184 const char *key;
1185 struct pat_ref *ref;
1186
1187 MAY_LJMP(check_args(L, 2, "del_acl"));
1188
1189 name = MAY_LJMP(luaL_checkstring(L, 1));
1190 key = MAY_LJMP(luaL_checkstring(L, 2));
1191
1192 ref = pat_ref_lookup(name);
1193 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001194 WILL_LJMP(luaL_error(L, "'del_acl': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001195
1196 pat_ref_delete(ref, key);
1197 return 0;
1198}
1199
1200/* This function is an LUA binding. It provides a function
1201 * for deleting map entry from a referenced map file.
1202 */
1203static int hlua_del_map(lua_State *L)
1204{
1205 const char *name;
1206 const char *key;
1207 struct pat_ref *ref;
1208
1209 MAY_LJMP(check_args(L, 2, "del_map"));
1210
1211 name = MAY_LJMP(luaL_checkstring(L, 1));
1212 key = MAY_LJMP(luaL_checkstring(L, 2));
1213
1214 ref = pat_ref_lookup(name);
1215 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001216 WILL_LJMP(luaL_error(L, "'del_map': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001217
1218 pat_ref_delete(ref, key);
1219 return 0;
1220}
1221
1222/* This function is an LUA binding. It provides a function
1223 * for adding ACL pattern from a referenced ACL file.
1224 */
1225static int hlua_add_acl(lua_State *L)
1226{
1227 const char *name;
1228 const char *key;
1229 struct pat_ref *ref;
1230
1231 MAY_LJMP(check_args(L, 2, "add_acl"));
1232
1233 name = MAY_LJMP(luaL_checkstring(L, 1));
1234 key = MAY_LJMP(luaL_checkstring(L, 2));
1235
1236 ref = pat_ref_lookup(name);
1237 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001238 WILL_LJMP(luaL_error(L, "'add_acl': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001239
1240 if (pat_ref_find_elt(ref, key) == NULL)
1241 pat_ref_add(ref, key, NULL, NULL);
1242 return 0;
1243}
1244
1245/* This function is an LUA binding. It provides a function
1246 * for setting map pattern and sample from a referenced map
1247 * file.
1248 */
1249static int hlua_set_map(lua_State *L)
1250{
1251 const char *name;
1252 const char *key;
1253 const char *value;
1254 struct pat_ref *ref;
1255
1256 MAY_LJMP(check_args(L, 3, "set_map"));
1257
1258 name = MAY_LJMP(luaL_checkstring(L, 1));
1259 key = MAY_LJMP(luaL_checkstring(L, 2));
1260 value = MAY_LJMP(luaL_checkstring(L, 3));
1261
1262 ref = pat_ref_lookup(name);
1263 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001264 WILL_LJMP(luaL_error(L, "'set_map': unknown map file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001265
1266 if (pat_ref_find_elt(ref, key) != NULL)
1267 pat_ref_set(ref, key, value, NULL);
1268 else
1269 pat_ref_add(ref, key, value, NULL);
1270 return 0;
1271}
1272
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01001273/* A class is a lot of memory that contain data. This data can be a table,
1274 * an integer or user data. This data is associated with a metatable. This
1275 * metatable have an original version registred in the global context with
1276 * the name of the object (_G[<name>] = <metable> ).
1277 *
1278 * A metable is a table that modify the standard behavior of a standard
1279 * access to the associated data. The entries of this new metatable are
1280 * defined as is:
1281 *
1282 * http://lua-users.org/wiki/MetatableEvents
1283 *
1284 * __index
1285 *
1286 * we access an absent field in a table, the result is nil. This is
1287 * true, but it is not the whole truth. Actually, such access triggers
1288 * the interpreter to look for an __index metamethod: If there is no
1289 * such method, as usually happens, then the access results in nil;
1290 * otherwise, the metamethod will provide the result.
1291 *
1292 * Control 'prototype' inheritance. When accessing "myTable[key]" and
1293 * the key does not appear in the table, but the metatable has an __index
1294 * property:
1295 *
1296 * - if the value is a function, the function is called, passing in the
1297 * table and the key; the return value of that function is returned as
1298 * the result.
1299 *
1300 * - if the value is another table, the value of the key in that table is
1301 * asked for and returned (and if it doesn't exist in that table, but that
1302 * table's metatable has an __index property, then it continues on up)
1303 *
1304 * - Use "rawget(myTable,key)" to skip this metamethod.
1305 *
1306 * http://www.lua.org/pil/13.4.1.html
1307 *
1308 * __newindex
1309 *
1310 * Like __index, but control property assignment.
1311 *
1312 * __mode - Control weak references. A string value with one or both
1313 * of the characters 'k' and 'v' which specifies that the the
1314 * keys and/or values in the table are weak references.
1315 *
1316 * __call - Treat a table like a function. When a table is followed by
1317 * parenthesis such as "myTable( 'foo' )" and the metatable has
1318 * a __call key pointing to a function, that function is invoked
1319 * (passing any specified arguments) and the return value is
1320 * returned.
1321 *
1322 * __metatable - Hide the metatable. When "getmetatable( myTable )" is
1323 * called, if the metatable for myTable has a __metatable
1324 * key, the value of that key is returned instead of the
1325 * actual metatable.
1326 *
1327 * __tostring - Control string representation. When the builtin
1328 * "tostring( myTable )" function is called, if the metatable
1329 * for myTable has a __tostring property set to a function,
1330 * that function is invoked (passing myTable to it) and the
1331 * return value is used as the string representation.
1332 *
1333 * __len - Control table length. When the table length is requested using
1334 * the length operator ( '#' ), if the metatable for myTable has
1335 * a __len key pointing to a function, that function is invoked
1336 * (passing myTable to it) and the return value used as the value
1337 * of "#myTable".
1338 *
1339 * __gc - Userdata finalizer code. When userdata is set to be garbage
1340 * collected, if the metatable has a __gc field pointing to a
1341 * function, that function is first invoked, passing the userdata
1342 * to it. The __gc metamethod is not called for tables.
1343 * (See http://lua-users.org/lists/lua-l/2006-11/msg00508.html)
1344 *
1345 * Special metamethods for redefining standard operators:
1346 * http://www.lua.org/pil/13.1.html
1347 *
1348 * __add "+"
1349 * __sub "-"
1350 * __mul "*"
1351 * __div "/"
1352 * __unm "!"
1353 * __pow "^"
1354 * __concat ".."
1355 *
1356 * Special methods for redfining standar relations
1357 * http://www.lua.org/pil/13.2.html
1358 *
1359 * __eq "=="
1360 * __lt "<"
1361 * __le "<="
1362 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001363
1364/*
1365 *
1366 *
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001367 * Class Map
1368 *
1369 *
1370 */
1371
1372/* Returns a struct hlua_map if the stack entry "ud" is
1373 * a class session, otherwise it throws an error.
1374 */
1375__LJMP static struct map_descriptor *hlua_checkmap(lua_State *L, int ud)
1376{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02001377 return MAY_LJMP(hlua_checkudata(L, ud, class_map_ref));
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001378}
1379
1380/* This function is the map constructor. It don't need
1381 * the class Map object. It creates and return a new Map
1382 * object. It must be called only during "body" or "init"
1383 * context because it process some filesystem accesses.
1384 */
1385__LJMP static int hlua_map_new(struct lua_State *L)
1386{
1387 const char *fn;
1388 int match = PAT_MATCH_STR;
1389 struct sample_conv conv;
1390 const char *file = "";
1391 int line = 0;
1392 lua_Debug ar;
1393 char *err = NULL;
1394 struct arg args[2];
1395
1396 if (lua_gettop(L) < 1 || lua_gettop(L) > 2)
1397 WILL_LJMP(luaL_error(L, "'new' needs at least 1 argument."));
1398
1399 fn = MAY_LJMP(luaL_checkstring(L, 1));
1400
1401 if (lua_gettop(L) >= 2) {
1402 match = MAY_LJMP(luaL_checkinteger(L, 2));
1403 if (match < 0 || match >= PAT_MATCH_NUM)
1404 WILL_LJMP(luaL_error(L, "'new' needs a valid match method."));
1405 }
1406
1407 /* Get Lua filename and line number. */
1408 if (lua_getstack(L, 1, &ar)) { /* check function at level */
1409 lua_getinfo(L, "Sl", &ar); /* get info about it */
1410 if (ar.currentline > 0) { /* is there info? */
1411 file = ar.short_src;
1412 line = ar.currentline;
1413 }
1414 }
1415
1416 /* fill fake sample_conv struct. */
1417 conv.kw = ""; /* unused. */
1418 conv.process = NULL; /* unused. */
1419 conv.arg_mask = 0; /* unused. */
1420 conv.val_args = NULL; /* unused. */
1421 conv.out_type = SMP_T_STR;
1422 conv.private = (void *)(long)match;
1423 switch (match) {
1424 case PAT_MATCH_STR: conv.in_type = SMP_T_STR; break;
1425 case PAT_MATCH_BEG: conv.in_type = SMP_T_STR; break;
1426 case PAT_MATCH_SUB: conv.in_type = SMP_T_STR; break;
1427 case PAT_MATCH_DIR: conv.in_type = SMP_T_STR; break;
1428 case PAT_MATCH_DOM: conv.in_type = SMP_T_STR; break;
1429 case PAT_MATCH_END: conv.in_type = SMP_T_STR; break;
1430 case PAT_MATCH_REG: conv.in_type = SMP_T_STR; break;
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001431 case PAT_MATCH_INT: conv.in_type = SMP_T_SINT; break;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001432 case PAT_MATCH_IP: conv.in_type = SMP_T_ADDR; break;
1433 default:
1434 WILL_LJMP(luaL_error(L, "'new' doesn't support this match mode."));
1435 }
1436
1437 /* fill fake args. */
1438 args[0].type = ARGT_STR;
1439 args[0].data.str.str = (char *)fn;
1440 args[1].type = ARGT_STOP;
1441
1442 /* load the map. */
1443 if (!sample_load_map(args, &conv, file, line, &err)) {
1444 /* error case: we cant use luaL_error because we must
1445 * free the err variable.
1446 */
1447 luaL_where(L, 1);
1448 lua_pushfstring(L, "'new': %s.", err);
1449 lua_concat(L, 2);
1450 free(err);
1451 WILL_LJMP(lua_error(L));
1452 }
1453
1454 /* create the lua object. */
1455 lua_newtable(L);
1456 lua_pushlightuserdata(L, args[0].data.map);
1457 lua_rawseti(L, -2, 0);
1458
1459 /* Pop a class Map metatable and affect it to the userdata. */
1460 lua_rawgeti(L, LUA_REGISTRYINDEX, class_map_ref);
1461 lua_setmetatable(L, -2);
1462
1463
1464 return 1;
1465}
1466
1467__LJMP static inline int _hlua_map_lookup(struct lua_State *L, int str)
1468{
1469 struct map_descriptor *desc;
1470 struct pattern *pat;
1471 struct sample smp;
1472
1473 MAY_LJMP(check_args(L, 2, "lookup"));
1474 desc = MAY_LJMP(hlua_checkmap(L, 1));
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001475 if (desc->pat.expect_type == SMP_T_SINT) {
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001476 smp.data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001477 smp.data.u.sint = MAY_LJMP(luaL_checkinteger(L, 2));
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001478 }
1479 else {
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001480 smp.data.type = SMP_T_STR;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001481 smp.flags = SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001482 smp.data.u.str.str = (char *)MAY_LJMP(luaL_checklstring(L, 2, (size_t *)&smp.data.u.str.len));
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001483 }
1484
1485 pat = pattern_exec_match(&desc->pat, &smp, 1);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001486 if (!pat || !pat->data) {
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001487 if (str)
1488 lua_pushstring(L, "");
1489 else
1490 lua_pushnil(L);
1491 return 1;
1492 }
1493
1494 /* The Lua pattern must return a string, so we can't check the returned type */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001495 lua_pushlstring(L, pat->data->u.str.str, pat->data->u.str.len);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001496 return 1;
1497}
1498
1499__LJMP static int hlua_map_lookup(struct lua_State *L)
1500{
1501 return _hlua_map_lookup(L, 0);
1502}
1503
1504__LJMP static int hlua_map_slookup(struct lua_State *L)
1505{
1506 return _hlua_map_lookup(L, 1);
1507}
1508
1509/*
1510 *
1511 *
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001512 * Class Socket
1513 *
1514 *
1515 */
1516
1517__LJMP static struct hlua_socket *hlua_checksocket(lua_State *L, int ud)
1518{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02001519 return MAY_LJMP(hlua_checkudata(L, ud, class_socket_ref));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001520}
1521
1522/* This function is the handler called for each I/O on the established
1523 * connection. It is used for notify space avalaible to send or data
1524 * received.
1525 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02001526static void hlua_socket_handler(struct appctx *appctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001527{
Willy Tarreau00a37f02015-04-13 12:05:19 +02001528 struct stream_interface *si = appctx->owner;
Willy Tarreau50fe03b2014-11-28 13:59:31 +01001529 struct connection *c = objt_conn(si_opposite(si)->end);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001530
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001531 /* If the connection object is not avalaible, close all the
1532 * streams and wakeup everithing waiting for.
1533 */
1534 if (!c) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001535 si_shutw(si);
1536 si_shutr(si);
Willy Tarreau2bb4a962014-11-28 11:11:05 +01001537 si_ic(si)->flags |= CF_READ_NULL;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001538 hlua_com_wake(&appctx->ctx.hlua.wake_on_read);
1539 hlua_com_wake(&appctx->ctx.hlua.wake_on_write);
Willy Tarreaud4da1962015-04-20 01:31:23 +02001540 return;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001541 }
1542
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001543 /* If we cant write, wakeup the pending write signals. */
1544 if (channel_output_closed(si_ic(si)))
1545 hlua_com_wake(&appctx->ctx.hlua.wake_on_write);
1546
1547 /* If we cant read, wakeup the pending read signals. */
1548 if (channel_input_closed(si_oc(si)))
1549 hlua_com_wake(&appctx->ctx.hlua.wake_on_read);
1550
Thierry FOURNIER316e3192015-09-04 18:25:53 +02001551 /* if the connection is not estabkished, inform the stream that we want
1552 * to be notified whenever the connection completes.
1553 */
1554 if (!(c->flags & CO_FL_CONNECTED)) {
1555 si_applet_cant_get(si);
1556 si_applet_cant_put(si);
Willy Tarreaud4da1962015-04-20 01:31:23 +02001557 return;
Thierry FOURNIER316e3192015-09-04 18:25:53 +02001558 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001559
1560 /* This function is called after the connect. */
1561 appctx->ctx.hlua.connected = 1;
1562
1563 /* Wake the tasks which wants to write if the buffer have avalaible space. */
Thierry FOURNIEReba6f642015-09-26 22:01:07 +02001564 if (channel_may_recv(si_ic(si)))
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001565 hlua_com_wake(&appctx->ctx.hlua.wake_on_write);
1566
1567 /* Wake the tasks which wants to read if the buffer contains data. */
Thierry FOURNIEReba6f642015-09-26 22:01:07 +02001568 if (!channel_is_empty(si_oc(si)))
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001569 hlua_com_wake(&appctx->ctx.hlua.wake_on_read);
1570}
1571
Willy Tarreau87b09662015-04-03 00:22:06 +02001572/* This function is called when the "struct stream" is destroyed.
1573 * Remove the link from the object to this stream.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001574 * Wake all the pending signals.
1575 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02001576static void hlua_socket_release(struct appctx *appctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001577{
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001578 /* Remove my link in the original object. */
1579 if (appctx->ctx.hlua.socket)
1580 appctx->ctx.hlua.socket->s = NULL;
1581
1582 /* Wake all the task waiting for me. */
1583 hlua_com_wake(&appctx->ctx.hlua.wake_on_read);
1584 hlua_com_wake(&appctx->ctx.hlua.wake_on_write);
1585}
1586
1587/* If the garbage collectio of the object is launch, nobody
Willy Tarreau87b09662015-04-03 00:22:06 +02001588 * uses this object. If the stream does not exists, just quit.
1589 * Send the shutdown signal to the stream. In some cases,
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001590 * pending signal can rest in the read and write lists. destroy
1591 * it.
1592 */
1593__LJMP static int hlua_socket_gc(lua_State *L)
1594{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001595 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001596 struct appctx *appctx;
1597
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001598 MAY_LJMP(check_args(L, 1, "__gc"));
1599
1600 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001601 if (!socket->s)
1602 return 0;
1603
Willy Tarreau87b09662015-04-03 00:22:06 +02001604 /* Remove all reference between the Lua stack and the coroutine stream. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001605 appctx = objt_appctx(socket->s->si[0].end);
Willy Tarreaue7dff022015-04-03 01:14:29 +02001606 stream_shutdown(socket->s, SF_ERR_KILLED);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001607 socket->s = NULL;
1608 appctx->ctx.hlua.socket = NULL;
1609
1610 return 0;
1611}
1612
1613/* The close function send shutdown signal and break the
Willy Tarreau87b09662015-04-03 00:22:06 +02001614 * links between the stream and the object.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001615 */
1616__LJMP static int hlua_socket_close(lua_State *L)
1617{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001618 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001619 struct appctx *appctx;
1620
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001621 MAY_LJMP(check_args(L, 1, "close"));
1622
1623 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001624 if (!socket->s)
1625 return 0;
1626
Willy Tarreau87b09662015-04-03 00:22:06 +02001627 /* Close the stream and remove the associated stop task. */
Willy Tarreaue7dff022015-04-03 01:14:29 +02001628 stream_shutdown(socket->s, SF_ERR_KILLED);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001629 appctx = objt_appctx(socket->s->si[0].end);
1630 appctx->ctx.hlua.socket = NULL;
1631 socket->s = NULL;
1632
1633 return 0;
1634}
1635
1636/* This Lua function assumes that the stack contain three parameters.
1637 * 1 - USERDATA containing a struct socket
1638 * 2 - INTEGER with values of the macro defined below
1639 * If the integer is -1, we must read at most one line.
1640 * If the integer is -2, we ust read all the data until the
1641 * end of the stream.
1642 * If the integer is positive value, we must read a number of
1643 * bytes corresponding to this value.
1644 */
1645#define HLSR_READ_LINE (-1)
1646#define HLSR_READ_ALL (-2)
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001647__LJMP static int hlua_socket_receive_yield(struct lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001648{
1649 struct hlua_socket *socket = MAY_LJMP(hlua_checksocket(L, 1));
1650 int wanted = lua_tointeger(L, 2);
1651 struct hlua *hlua = hlua_gethlua(L);
1652 struct appctx *appctx;
1653 int len;
1654 int nblk;
1655 char *blk1;
1656 int len1;
1657 char *blk2;
1658 int len2;
Thierry FOURNIER00543922015-03-09 18:35:06 +01001659 int skip_at_end = 0;
Willy Tarreau81389672015-03-10 12:03:52 +01001660 struct channel *oc;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001661
1662 /* Check if this lua stack is schedulable. */
1663 if (!hlua || !hlua->task)
1664 WILL_LJMP(luaL_error(L, "The 'receive' function is only allowed in "
1665 "'frontend', 'backend' or 'task'"));
1666
1667 /* check for connection closed. If some data where read, return it. */
1668 if (!socket->s)
1669 goto connection_closed;
1670
Willy Tarreau94aa6172015-03-13 14:19:06 +01001671 oc = &socket->s->res;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001672 if (wanted == HLSR_READ_LINE) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001673 /* Read line. */
Willy Tarreau81389672015-03-10 12:03:52 +01001674 nblk = bo_getline_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001675 if (nblk < 0) /* Connection close. */
1676 goto connection_closed;
1677 if (nblk == 0) /* No data avalaible. */
1678 goto connection_empty;
Thierry FOURNIER00543922015-03-09 18:35:06 +01001679
1680 /* remove final \r\n. */
1681 if (nblk == 1) {
1682 if (blk1[len1-1] == '\n') {
1683 len1--;
1684 skip_at_end++;
1685 if (blk1[len1-1] == '\r') {
1686 len1--;
1687 skip_at_end++;
1688 }
1689 }
1690 }
1691 else {
1692 if (blk2[len2-1] == '\n') {
1693 len2--;
1694 skip_at_end++;
1695 if (blk2[len2-1] == '\r') {
1696 len2--;
1697 skip_at_end++;
1698 }
1699 }
1700 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001701 }
1702
1703 else if (wanted == HLSR_READ_ALL) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001704 /* Read all the available data. */
Willy Tarreau81389672015-03-10 12:03:52 +01001705 nblk = bo_getblk_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001706 if (nblk < 0) /* Connection close. */
1707 goto connection_closed;
1708 if (nblk == 0) /* No data avalaible. */
1709 goto connection_empty;
1710 }
1711
1712 else {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001713 /* Read a block of data. */
Willy Tarreau81389672015-03-10 12:03:52 +01001714 nblk = bo_getblk_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001715 if (nblk < 0) /* Connection close. */
1716 goto connection_closed;
1717 if (nblk == 0) /* No data avalaible. */
1718 goto connection_empty;
1719
1720 if (len1 > wanted) {
1721 nblk = 1;
1722 len1 = wanted;
1723 } if (nblk == 2 && len1 + len2 > wanted)
1724 len2 = wanted - len1;
1725 }
1726
1727 len = len1;
1728
1729 luaL_addlstring(&socket->b, blk1, len1);
1730 if (nblk == 2) {
1731 len += len2;
1732 luaL_addlstring(&socket->b, blk2, len2);
1733 }
1734
1735 /* Consume data. */
Willy Tarreau81389672015-03-10 12:03:52 +01001736 bo_skip(oc, len + skip_at_end);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001737
1738 /* Don't wait anything. */
Willy Tarreaude70fa12015-09-26 11:25:05 +02001739 stream_int_notify(&socket->s->si[0]);
1740 stream_int_update_applet(&socket->s->si[0]);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001741
1742 /* If the pattern reclaim to read all the data
1743 * in the connection, got out.
1744 */
1745 if (wanted == HLSR_READ_ALL)
1746 goto connection_empty;
1747 else if (wanted >= 0 && len < wanted)
1748 goto connection_empty;
1749
1750 /* Return result. */
1751 luaL_pushresult(&socket->b);
1752 return 1;
1753
1754connection_closed:
1755
1756 /* If the buffer containds data. */
1757 if (socket->b.n > 0) {
1758 luaL_pushresult(&socket->b);
1759 return 1;
1760 }
1761 lua_pushnil(L);
1762 lua_pushstring(L, "connection closed.");
1763 return 2;
1764
1765connection_empty:
1766
1767 appctx = objt_appctx(socket->s->si[0].end);
1768 if (!hlua_com_new(hlua, &appctx->ctx.hlua.wake_on_read))
1769 WILL_LJMP(luaL_error(L, "out of memory"));
Thierry FOURNIER4abd3ae2015-03-03 17:29:06 +01001770 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_receive_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001771 return 0;
1772}
1773
1774/* This Lus function gets two parameters. The first one can be string
1775 * or a number. If the string is "*l", the user require one line. If
1776 * the string is "*a", the user require all the content of the stream.
1777 * If the value is a number, the user require a number of bytes equal
1778 * to the value. The default value is "*l" (a line).
1779 *
1780 * This paraeter with a variable type is converted in integer. This
1781 * integer takes this values:
1782 * -1 : read a line
1783 * -2 : read all the stream
1784 * >0 : amount if bytes.
1785 *
1786 * The second parameter is optinal. It contains a string that must be
1787 * concatenated with the read data.
1788 */
1789__LJMP static int hlua_socket_receive(struct lua_State *L)
1790{
1791 int wanted = HLSR_READ_LINE;
1792 const char *pattern;
1793 int type;
1794 char *error;
1795 size_t len;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001796 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001797
1798 if (lua_gettop(L) < 1 || lua_gettop(L) > 3)
1799 WILL_LJMP(luaL_error(L, "The 'receive' function requires between 1 and 3 arguments."));
1800
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001801 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001802
1803 /* check for pattern. */
1804 if (lua_gettop(L) >= 2) {
1805 type = lua_type(L, 2);
1806 if (type == LUA_TSTRING) {
1807 pattern = lua_tostring(L, 2);
1808 if (strcmp(pattern, "*a") == 0)
1809 wanted = HLSR_READ_ALL;
1810 else if (strcmp(pattern, "*l") == 0)
1811 wanted = HLSR_READ_LINE;
1812 else {
1813 wanted = strtoll(pattern, &error, 10);
1814 if (*error != '\0')
1815 WILL_LJMP(luaL_error(L, "Unsupported pattern."));
1816 }
1817 }
1818 else if (type == LUA_TNUMBER) {
1819 wanted = lua_tointeger(L, 2);
1820 if (wanted < 0)
1821 WILL_LJMP(luaL_error(L, "Unsupported size."));
1822 }
1823 }
1824
1825 /* Set pattern. */
1826 lua_pushinteger(L, wanted);
1827 lua_replace(L, 2);
1828
1829 /* init bufffer, and fiil it wih prefix. */
1830 luaL_buffinit(L, &socket->b);
1831
1832 /* Check prefix. */
1833 if (lua_gettop(L) >= 3) {
1834 if (lua_type(L, 3) != LUA_TSTRING)
1835 WILL_LJMP(luaL_error(L, "Expect a 'string' for the prefix"));
1836 pattern = lua_tolstring(L, 3, &len);
1837 luaL_addlstring(&socket->b, pattern, len);
1838 }
1839
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001840 return __LJMP(hlua_socket_receive_yield(L, 0, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001841}
1842
1843/* Write the Lua input string in the output buffer.
1844 * This fucntion returns a yield if no space are available.
1845 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001846static int hlua_socket_write_yield(struct lua_State *L,int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001847{
1848 struct hlua_socket *socket;
1849 struct hlua *hlua = hlua_gethlua(L);
1850 struct appctx *appctx;
1851 size_t buf_len;
1852 const char *buf;
1853 int len;
1854 int send_len;
1855 int sent;
1856
1857 /* Check if this lua stack is schedulable. */
1858 if (!hlua || !hlua->task)
1859 WILL_LJMP(luaL_error(L, "The 'write' function is only allowed in "
1860 "'frontend', 'backend' or 'task'"));
1861
1862 /* Get object */
1863 socket = MAY_LJMP(hlua_checksocket(L, 1));
1864 buf = MAY_LJMP(luaL_checklstring(L, 2, &buf_len));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001865 sent = MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001866
1867 /* Check for connection close. */
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01001868 if (!socket->s || channel_output_closed(&socket->s->req)) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001869 lua_pushinteger(L, -1);
1870 return 1;
1871 }
1872
1873 /* Update the input buffer data. */
1874 buf += sent;
1875 send_len = buf_len - sent;
1876
1877 /* All the data are sent. */
1878 if (sent >= buf_len)
1879 return 1; /* Implicitly return the length sent. */
1880
Thierry FOURNIER486d52a2015-03-09 17:51:43 +01001881 /* Check if the buffer is avalaible because HAProxy doesn't allocate
1882 * the request buffer if its not required.
1883 */
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01001884 if (socket->s->req.buf->size == 0) {
Willy Tarreau87b09662015-04-03 00:22:06 +02001885 if (!stream_alloc_recv_buffer(&socket->s->req)) {
Willy Tarreau350f4872014-11-28 14:42:25 +01001886 socket->s->si[0].flags |= SI_FL_WAIT_ROOM;
Thierry FOURNIER486d52a2015-03-09 17:51:43 +01001887 goto hlua_socket_write_yield_return;
1888 }
1889 }
1890
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001891 /* Check for avalaible space. */
Willy Tarreau94aa6172015-03-13 14:19:06 +01001892 len = buffer_total_space(socket->s->req.buf);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001893 if (len <= 0)
1894 goto hlua_socket_write_yield_return;
1895
1896 /* send data */
1897 if (len < send_len)
1898 send_len = len;
Willy Tarreau94aa6172015-03-13 14:19:06 +01001899 len = bi_putblk(&socket->s->req, buf+sent, send_len);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001900
1901 /* "Not enough space" (-1), "Buffer too little to contain
1902 * the data" (-2) are not expected because the available length
1903 * is tested.
1904 * Other unknown error are also not expected.
1905 */
1906 if (len <= 0) {
Willy Tarreaubc18da12015-03-13 14:00:47 +01001907 if (len == -1)
Willy Tarreau94aa6172015-03-13 14:19:06 +01001908 socket->s->req.flags |= CF_WAKE_WRITE;
Willy Tarreaubc18da12015-03-13 14:00:47 +01001909
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001910 MAY_LJMP(hlua_socket_close(L));
1911 lua_pop(L, 1);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001912 lua_pushinteger(L, -1);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001913 return 1;
1914 }
1915
1916 /* update buffers. */
Willy Tarreaude70fa12015-09-26 11:25:05 +02001917 stream_int_notify(&socket->s->si[0]);
1918 stream_int_update_applet(&socket->s->si[0]);
1919
Willy Tarreau94aa6172015-03-13 14:19:06 +01001920 socket->s->req.rex = TICK_ETERNITY;
1921 socket->s->res.wex = TICK_ETERNITY;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001922
1923 /* Update length sent. */
1924 lua_pop(L, 1);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001925 lua_pushinteger(L, sent + len);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001926
1927 /* All the data buffer is sent ? */
1928 if (sent + len >= buf_len)
1929 return 1;
1930
1931hlua_socket_write_yield_return:
1932 appctx = objt_appctx(socket->s->si[0].end);
1933 if (!hlua_com_new(hlua, &appctx->ctx.hlua.wake_on_write))
1934 WILL_LJMP(luaL_error(L, "out of memory"));
Thierry FOURNIER4abd3ae2015-03-03 17:29:06 +01001935 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_write_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001936 return 0;
1937}
1938
1939/* This function initiate the send of data. It just check the input
1940 * parameters and push an integer in the Lua stack that contain the
1941 * amount of data writed in the buffer. This is used by the function
1942 * "hlua_socket_write_yield" that can yield.
1943 *
1944 * The Lua function gets between 3 and 4 parameters. The first one is
1945 * the associated object. The second is a string buffer. The third is
1946 * a facultative integer that represents where is the buffer position
1947 * of the start of the data that can send. The first byte is the
1948 * position "1". The default value is "1". The fourth argument is a
1949 * facultative integer that represents where is the buffer position
1950 * of the end of the data that can send. The default is the last byte.
1951 */
1952static int hlua_socket_send(struct lua_State *L)
1953{
1954 int i;
1955 int j;
1956 const char *buf;
1957 size_t buf_len;
1958
1959 /* Check number of arguments. */
1960 if (lua_gettop(L) < 2 || lua_gettop(L) > 4)
1961 WILL_LJMP(luaL_error(L, "'send' needs between 2 and 4 arguments"));
1962
1963 /* Get the string. */
1964 buf = MAY_LJMP(luaL_checklstring(L, 2, &buf_len));
1965
1966 /* Get and check j. */
1967 if (lua_gettop(L) == 4) {
1968 j = MAY_LJMP(luaL_checkinteger(L, 4));
1969 if (j < 0)
1970 j = buf_len + j + 1;
1971 if (j > buf_len)
1972 j = buf_len + 1;
1973 lua_pop(L, 1);
1974 }
1975 else
1976 j = buf_len;
1977
1978 /* Get and check i. */
1979 if (lua_gettop(L) == 3) {
1980 i = MAY_LJMP(luaL_checkinteger(L, 3));
1981 if (i < 0)
1982 i = buf_len + i + 1;
1983 if (i > buf_len)
1984 i = buf_len + 1;
1985 lua_pop(L, 1);
1986 } else
1987 i = 1;
1988
1989 /* Check bth i and j. */
1990 if (i > j) {
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001991 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001992 return 1;
1993 }
1994 if (i == 0 && j == 0) {
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001995 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001996 return 1;
1997 }
1998 if (i == 0)
1999 i = 1;
2000 if (j == 0)
2001 j = 1;
2002
2003 /* Pop the string. */
2004 lua_pop(L, 1);
2005
2006 /* Update the buffer length. */
2007 buf += i - 1;
2008 buf_len = j - i + 1;
2009 lua_pushlstring(L, buf, buf_len);
2010
2011 /* This unsigned is used to remember the amount of sent data. */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002012 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002013
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002014 return MAY_LJMP(hlua_socket_write_yield(L, 0, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002015}
2016
Willy Tarreau22b0a682015-06-17 19:43:49 +02002017#define SOCKET_INFO_MAX_LEN sizeof("[0000:0000:0000:0000:0000:0000:0000:0000]:12345")
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002018__LJMP static inline int hlua_socket_info(struct lua_State *L, struct sockaddr_storage *addr)
2019{
2020 static char buffer[SOCKET_INFO_MAX_LEN];
2021 int ret;
2022 int len;
2023 char *p;
2024
2025 ret = addr_to_str(addr, buffer+1, SOCKET_INFO_MAX_LEN-1);
2026 if (ret <= 0) {
2027 lua_pushnil(L);
2028 return 1;
2029 }
2030
2031 if (ret == AF_UNIX) {
2032 lua_pushstring(L, buffer+1);
2033 return 1;
2034 }
2035 else if (ret == AF_INET6) {
2036 buffer[0] = '[';
2037 len = strlen(buffer);
2038 buffer[len] = ']';
2039 len++;
2040 buffer[len] = ':';
2041 len++;
2042 p = buffer;
2043 }
2044 else if (ret == AF_INET) {
2045 p = buffer + 1;
2046 len = strlen(p);
2047 p[len] = ':';
2048 len++;
2049 }
2050 else {
2051 lua_pushnil(L);
2052 return 1;
2053 }
2054
2055 if (port_to_str(addr, p + len, SOCKET_INFO_MAX_LEN-1 - len) <= 0) {
2056 lua_pushnil(L);
2057 return 1;
2058 }
2059
2060 lua_pushstring(L, p);
2061 return 1;
2062}
2063
2064/* Returns information about the peer of the connection. */
2065__LJMP static int hlua_socket_getpeername(struct lua_State *L)
2066{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002067 struct hlua_socket *socket;
2068 struct connection *conn;
2069
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002070 MAY_LJMP(check_args(L, 1, "getpeername"));
2071
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002072 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002073
2074 /* Check if the tcp object is avalaible. */
2075 if (!socket->s) {
2076 lua_pushnil(L);
2077 return 1;
2078 }
2079
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002080 conn = objt_conn(socket->s->si[1].end);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002081 if (!conn) {
2082 lua_pushnil(L);
2083 return 1;
2084 }
2085
2086 if (!(conn->flags & CO_FL_ADDR_TO_SET)) {
2087 unsigned int salen = sizeof(conn->addr.to);
2088 if (getpeername(conn->t.sock.fd, (struct sockaddr *)&conn->addr.to, &salen) == -1) {
2089 lua_pushnil(L);
2090 return 1;
2091 }
2092 conn->flags |= CO_FL_ADDR_TO_SET;
2093 }
2094
2095 return MAY_LJMP(hlua_socket_info(L, &conn->addr.to));
2096}
2097
2098/* Returns information about my connection side. */
2099static int hlua_socket_getsockname(struct lua_State *L)
2100{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002101 struct hlua_socket *socket;
2102 struct connection *conn;
2103
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002104 MAY_LJMP(check_args(L, 1, "getsockname"));
2105
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002106 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002107
2108 /* Check if the tcp object is avalaible. */
2109 if (!socket->s) {
2110 lua_pushnil(L);
2111 return 1;
2112 }
2113
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002114 conn = objt_conn(socket->s->si[1].end);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002115 if (!conn) {
2116 lua_pushnil(L);
2117 return 1;
2118 }
2119
2120 if (!(conn->flags & CO_FL_ADDR_FROM_SET)) {
2121 unsigned int salen = sizeof(conn->addr.from);
2122 if (getsockname(conn->t.sock.fd, (struct sockaddr *)&conn->addr.from, &salen) == -1) {
2123 lua_pushnil(L);
2124 return 1;
2125 }
2126 conn->flags |= CO_FL_ADDR_FROM_SET;
2127 }
2128
2129 return hlua_socket_info(L, &conn->addr.from);
2130}
2131
2132/* This struct define the applet. */
Willy Tarreau30576452015-04-13 13:50:30 +02002133static struct applet update_applet = {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002134 .obj_type = OBJ_TYPE_APPLET,
2135 .name = "<LUA_TCP>",
2136 .fct = hlua_socket_handler,
2137 .release = hlua_socket_release,
2138};
2139
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002140__LJMP static int hlua_socket_connect_yield(struct lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002141{
2142 struct hlua_socket *socket = MAY_LJMP(hlua_checksocket(L, 1));
2143 struct hlua *hlua = hlua_gethlua(L);
2144 struct appctx *appctx;
2145
2146 /* Check for connection close. */
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01002147 if (!hlua || !socket->s || channel_output_closed(&socket->s->req)) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002148 lua_pushnil(L);
2149 lua_pushstring(L, "Can't connect");
2150 return 2;
2151 }
2152
2153 appctx = objt_appctx(socket->s->si[0].end);
2154
2155 /* Check for connection established. */
2156 if (appctx->ctx.hlua.connected) {
2157 lua_pushinteger(L, 1);
2158 return 1;
2159 }
2160
2161 if (!hlua_com_new(hlua, &appctx->ctx.hlua.wake_on_write))
2162 WILL_LJMP(luaL_error(L, "out of memory error"));
Thierry FOURNIER4abd3ae2015-03-03 17:29:06 +01002163 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_connect_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002164 return 0;
2165}
2166
2167/* This function fail or initite the connection. */
2168__LJMP static int hlua_socket_connect(struct lua_State *L)
2169{
2170 struct hlua_socket *socket;
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002171 int port = -1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002172 const char *ip;
2173 struct connection *conn;
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002174 struct hlua *hlua;
2175 struct appctx *appctx;
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002176 int low, high;
2177 struct sockaddr_storage *addr;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002178
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002179 if (lua_gettop(L) < 2)
2180 WILL_LJMP(luaL_error(L, "connect: need at least 2 arguments"));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002181
2182 /* Get args. */
2183 socket = MAY_LJMP(hlua_checksocket(L, 1));
2184 ip = MAY_LJMP(luaL_checkstring(L, 2));
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002185 if (lua_gettop(L) >= 3)
2186 port = MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002187
Willy Tarreau973a5422015-08-05 21:47:23 +02002188 conn = si_alloc_conn(&socket->s->si[1]);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002189 if (!conn)
2190 WILL_LJMP(luaL_error(L, "connect: internal error"));
2191
Willy Tarreau3adac082015-09-26 17:51:09 +02002192 /* needed for the connection not to be closed */
2193 conn->target = socket->s->target;
2194
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002195 /* Parse ip address. */
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002196 addr = str2sa_range(ip, &low, &high, NULL, NULL, NULL, 0);
2197 if (!addr)
2198 WILL_LJMP(luaL_error(L, "connect: cannot parse destination address '%s'", ip));
2199 if (low != high)
2200 WILL_LJMP(luaL_error(L, "connect: port ranges not supported : address '%s'", ip));
2201 memcpy(&conn->addr.to, addr, sizeof(struct sockaddr_storage));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002202
2203 /* Set port. */
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002204 if (low == 0) {
2205 if (conn->addr.to.ss_family == AF_INET) {
2206 if (port == -1)
2207 WILL_LJMP(luaL_error(L, "connect: port missing"));
2208 ((struct sockaddr_in *)&conn->addr.to)->sin_port = htons(port);
2209 } else if (conn->addr.to.ss_family == AF_INET6) {
2210 if (port == -1)
2211 WILL_LJMP(luaL_error(L, "connect: port missing"));
2212 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_port = htons(port);
2213 }
2214 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002215
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002216 hlua = hlua_gethlua(L);
2217 appctx = objt_appctx(socket->s->si[0].end);
Willy Tarreaubdc97a82015-08-24 15:42:28 +02002218
2219 /* inform the stream that we want to be notified whenever the
2220 * connection completes.
2221 */
2222 si_applet_cant_get(&socket->s->si[0]);
2223 si_applet_cant_put(&socket->s->si[0]);
Thierry FOURNIER8c8fbbe2015-09-26 17:02:35 +02002224 appctx_wakeup(appctx);
Willy Tarreaubdc97a82015-08-24 15:42:28 +02002225
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +02002226 hlua->flags |= HLUA_MUST_GC;
2227
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002228 if (!hlua_com_new(hlua, &appctx->ctx.hlua.wake_on_write))
2229 WILL_LJMP(luaL_error(L, "out of memory"));
Thierry FOURNIER4abd3ae2015-03-03 17:29:06 +01002230 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_connect_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002231
2232 return 0;
2233}
2234
Baptiste Assmann84bb4932015-03-02 21:40:06 +01002235#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002236__LJMP static int hlua_socket_connect_ssl(struct lua_State *L)
2237{
2238 struct hlua_socket *socket;
2239
2240 MAY_LJMP(check_args(L, 3, "connect_ssl"));
2241 socket = MAY_LJMP(hlua_checksocket(L, 1));
2242 socket->s->target = &socket_ssl.obj_type;
2243 return MAY_LJMP(hlua_socket_connect(L));
2244}
Baptiste Assmann84bb4932015-03-02 21:40:06 +01002245#endif
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002246
2247__LJMP static int hlua_socket_setoption(struct lua_State *L)
2248{
2249 return 0;
2250}
2251
2252__LJMP static int hlua_socket_settimeout(struct lua_State *L)
2253{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002254 struct hlua_socket *socket;
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002255 int tmout;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002256
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002257 MAY_LJMP(check_args(L, 2, "settimeout"));
2258
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002259 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002260 tmout = MAY_LJMP(luaL_checkinteger(L, 2)) * 1000;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002261
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01002262 socket->s->req.rto = tmout;
2263 socket->s->req.wto = tmout;
2264 socket->s->res.rto = tmout;
2265 socket->s->res.wto = tmout;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002266
2267 return 0;
2268}
2269
2270__LJMP static int hlua_socket_new(lua_State *L)
2271{
2272 struct hlua_socket *socket;
2273 struct appctx *appctx;
Willy Tarreau15b5e142015-04-04 14:38:25 +02002274 struct session *sess;
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002275 struct stream *strm;
Willy Tarreaud420a972015-04-06 00:39:18 +02002276 struct task *task;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002277
2278 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002279 if (!lua_checkstack(L, 3)) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002280 hlua_pusherror(L, "socket: full stack");
2281 goto out_fail_conf;
2282 }
2283
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002284 /* Create the object: obj[0] = userdata. */
2285 lua_newtable(L);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002286 socket = MAY_LJMP(lua_newuserdata(L, sizeof(*socket)));
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002287 lua_rawseti(L, -2, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002288 memset(socket, 0, sizeof(*socket));
2289
Thierry FOURNIER4a6170c2015-03-09 17:07:10 +01002290 /* Check if the various memory pools are intialized. */
Willy Tarreau87b09662015-04-03 00:22:06 +02002291 if (!pool2_stream || !pool2_buffer) {
Thierry FOURNIER4a6170c2015-03-09 17:07:10 +01002292 hlua_pusherror(L, "socket: uninitialized pools.");
2293 goto out_fail_conf;
2294 }
2295
Willy Tarreau87b09662015-04-03 00:22:06 +02002296 /* Pop a class stream metatable and affect it to the userdata. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002297 lua_rawgeti(L, LUA_REGISTRYINDEX, class_socket_ref);
2298 lua_setmetatable(L, -2);
2299
Willy Tarreaud420a972015-04-06 00:39:18 +02002300 /* Create the applet context */
2301 appctx = appctx_new(&update_applet);
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002302 if (!appctx) {
2303 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaufeb76402015-04-03 14:10:06 +02002304 goto out_fail_conf;
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002305 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002306
Willy Tarreaud420a972015-04-06 00:39:18 +02002307 appctx->ctx.hlua.socket = socket;
2308 appctx->ctx.hlua.connected = 0;
2309 LIST_INIT(&appctx->ctx.hlua.wake_on_write);
2310 LIST_INIT(&appctx->ctx.hlua.wake_on_read);
Willy Tarreaub2bf8332015-04-04 15:58:58 +02002311
Willy Tarreaud420a972015-04-06 00:39:18 +02002312 /* Now create a session, task and stream for this applet */
2313 sess = session_new(&socket_proxy, NULL, &appctx->obj_type);
2314 if (!sess) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002315 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaud420a972015-04-06 00:39:18 +02002316 goto out_fail_sess;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002317 }
2318
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002319 task = task_new();
2320 if (!task) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002321 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaufeb76402015-04-03 14:10:06 +02002322 goto out_fail_task;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002323 }
Willy Tarreaud420a972015-04-06 00:39:18 +02002324 task->nice = 0;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002325
Willy Tarreau73b65ac2015-04-08 18:26:29 +02002326 strm = stream_new(sess, task, &appctx->obj_type);
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002327 if (!strm) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002328 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaud420a972015-04-06 00:39:18 +02002329 goto out_fail_stream;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002330 }
2331
Willy Tarreaud420a972015-04-06 00:39:18 +02002332 /* Configure an empty Lua for the stream. */
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002333 socket->s = strm;
2334 strm->hlua.T = NULL;
2335 strm->hlua.Tref = LUA_REFNIL;
2336 strm->hlua.Mref = LUA_REFNIL;
2337 strm->hlua.nargs = 0;
2338 strm->hlua.flags = 0;
2339 LIST_INIT(&strm->hlua.com);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002340
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002341 /* Configure "right" stream interface. this "si" is used to connect
2342 * and retrieve data from the server. The connection is initialized
2343 * with the "struct server".
2344 */
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002345 si_set_state(&strm->si[1], SI_ST_ASS);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002346
2347 /* Force destination server. */
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002348 strm->flags |= SF_DIRECT | SF_ASSIGNED | SF_ADDR_SET | SF_BE_ASSIGNED;
2349 strm->target = &socket_tcp.obj_type;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002350
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002351 /* Update statistics counters. */
2352 socket_proxy.feconn++; /* beconn will be increased later */
2353 jobs++;
2354 totalconn++;
2355
2356 /* Return yield waiting for connection. */
2357 return 1;
2358
Willy Tarreaud420a972015-04-06 00:39:18 +02002359 out_fail_stream:
2360 task_free(task);
2361 out_fail_task:
Willy Tarreau11c36242015-04-04 15:54:03 +02002362 session_free(sess);
Willy Tarreaud420a972015-04-06 00:39:18 +02002363 out_fail_sess:
2364 appctx_free(appctx);
2365 out_fail_conf:
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002366 WILL_LJMP(lua_error(L));
2367 return 0;
2368}
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01002369
2370/*
2371 *
2372 *
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002373 * Class Channel
2374 *
2375 *
2376 */
2377
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002378/* The state between the channel data and the HTTP parser state can be
2379 * unconsistent, so reset the parser and call it again. Warning, this
2380 * action not revalidate the request and not send a 400 if the modified
2381 * resuest is not valid.
2382 *
Thierry FOURNIER6e01f382015-11-02 09:52:54 +01002383 * This function never fails. The direction is set using dir, which equals
2384 * either SMP_OPT_DIR_REQ or SMP_OPT_DIR_RES.
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002385 */
2386static void hlua_resynchonize_proto(struct stream *stream, int dir)
2387{
2388 /* Protocol HTTP. */
2389 if (stream->be->mode == PR_MODE_HTTP) {
2390
Thierry FOURNIER6e01f382015-11-02 09:52:54 +01002391 if (dir == SMP_OPT_DIR_REQ)
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002392 http_txn_reset_req(stream->txn);
Thierry FOURNIER6e01f382015-11-02 09:52:54 +01002393 else if (dir == SMP_OPT_DIR_RES)
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002394 http_txn_reset_res(stream->txn);
2395
2396 if (stream->txn->hdr_idx.v)
2397 hdr_idx_init(&stream->txn->hdr_idx);
2398
Thierry FOURNIER6e01f382015-11-02 09:52:54 +01002399 if (dir == SMP_OPT_DIR_REQ)
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002400 http_msg_analyzer(&stream->txn->req, &stream->txn->hdr_idx);
Thierry FOURNIER6e01f382015-11-02 09:52:54 +01002401 else if (dir == SMP_OPT_DIR_RES)
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002402 http_msg_analyzer(&stream->txn->rsp, &stream->txn->hdr_idx);
2403 }
2404}
2405
Thierry FOURNIER6e01f382015-11-02 09:52:54 +01002406/* Check the protocole integrity after the Lua manipulations. Close the stream
2407 * and returns 0 if fails, otherwise returns 1. The direction is set using dir,
2408 * which equals either SMP_OPT_DIR_REQ or SMP_OPT_DIR_RES.
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002409 */
2410static int hlua_check_proto(struct stream *stream, int dir)
2411{
2412 const struct chunk msg = { .len = 0 };
2413
Willy Tarreau9af89f72015-09-26 11:50:08 +02002414 /* Protocol HTTP. The message parsing state must match the request or
2415 * response state. The problem that may happen is that Lua modifies
2416 * the request or response message *after* it was parsed, and corrupted
2417 * it so that it could not be processed anymore. We just need to verify
2418 * if the parser is still expected to run or not.
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002419 */
2420 if (stream->be->mode == PR_MODE_HTTP) {
Thierry FOURNIER6e01f382015-11-02 09:52:54 +01002421 if (dir == SMP_OPT_DIR_REQ &&
Willy Tarreau9af89f72015-09-26 11:50:08 +02002422 !(stream->req.analysers & AN_REQ_WAIT_HTTP) &&
2423 stream->txn->req.msg_state < HTTP_MSG_BODY) {
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002424 stream_int_retnclose(&stream->si[0], &msg);
2425 return 0;
2426 }
Thierry FOURNIER6e01f382015-11-02 09:52:54 +01002427 else if (dir == SMP_OPT_DIR_RES &&
Willy Tarreau9af89f72015-09-26 11:50:08 +02002428 !(stream->res.analysers & AN_RES_WAIT_HTTP) &&
2429 stream->txn->rsp.msg_state < HTTP_MSG_BODY) {
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002430 stream_int_retnclose(&stream->si[0], &msg);
2431 return 0;
2432 }
2433 }
2434 return 1;
2435}
2436
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002437/* Returns the struct hlua_channel join to the class channel in the
2438 * stack entry "ud" or throws an argument error.
2439 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002440__LJMP static struct channel *hlua_checkchannel(lua_State *L, int ud)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002441{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002442 return MAY_LJMP(hlua_checkudata(L, ud, class_channel_ref));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002443}
2444
Willy Tarreau47860ed2015-03-10 14:07:50 +01002445/* Pushes the channel onto the top of the stack. If the stask does not have a
2446 * free slots, the function fails and returns 0;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002447 */
Willy Tarreau2a71af42015-03-10 13:51:50 +01002448static int hlua_channel_new(lua_State *L, struct channel *channel)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002449{
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002450 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002451 if (!lua_checkstack(L, 3))
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002452 return 0;
2453
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002454 lua_newtable(L);
Willy Tarreau47860ed2015-03-10 14:07:50 +01002455 lua_pushlightuserdata(L, channel);
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002456 lua_rawseti(L, -2, 0);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002457
2458 /* Pop a class sesison metatable and affect it to the userdata. */
2459 lua_rawgeti(L, LUA_REGISTRYINDEX, class_channel_ref);
2460 lua_setmetatable(L, -2);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002461 return 1;
2462}
2463
2464/* Duplicate all the data present in the input channel and put it
2465 * in a string LUA variables. Returns -1 and push a nil value in
2466 * the stack if the channel is closed and all the data are consumed,
2467 * returns 0 if no data are available, otherwise it returns the length
2468 * of the builded string.
2469 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002470static inline int _hlua_channel_dup(struct channel *chn, lua_State *L)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002471{
2472 char *blk1;
2473 char *blk2;
2474 int len1;
2475 int len2;
2476 int ret;
2477 luaL_Buffer b;
2478
Willy Tarreau47860ed2015-03-10 14:07:50 +01002479 ret = bi_getblk_nc(chn, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002480 if (unlikely(ret == 0))
2481 return 0;
2482
2483 if (unlikely(ret < 0)) {
2484 lua_pushnil(L);
2485 return -1;
2486 }
2487
2488 luaL_buffinit(L, &b);
2489 luaL_addlstring(&b, blk1, len1);
2490 if (unlikely(ret == 2))
2491 luaL_addlstring(&b, blk2, len2);
2492 luaL_pushresult(&b);
2493
2494 if (unlikely(ret == 2))
2495 return len1 + len2;
2496 return len1;
2497}
2498
2499/* "_hlua_channel_dup" wrapper. If no data are available, it returns
2500 * a yield. This function keep the data in the buffer.
2501 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002502__LJMP static int hlua_channel_dup_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002503{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002504 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002505
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002506 chn = MAY_LJMP(hlua_checkchannel(L, 1));
2507
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002508 if (_hlua_channel_dup(chn, L) == 0)
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002509 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_dup_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002510 return 1;
2511}
2512
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002513/* Check arguments for the function "hlua_channel_dup_yield". */
2514__LJMP static int hlua_channel_dup(lua_State *L)
2515{
2516 MAY_LJMP(check_args(L, 1, "dup"));
2517 MAY_LJMP(hlua_checkchannel(L, 1));
2518 return MAY_LJMP(hlua_channel_dup_yield(L, 0, 0));
2519}
2520
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002521/* "_hlua_channel_dup" wrapper. If no data are available, it returns
2522 * a yield. This function consumes the data in the buffer. It returns
2523 * a string containing the data or a nil pointer if no data are available
2524 * and the channel is closed.
2525 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002526__LJMP static int hlua_channel_get_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002527{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002528 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002529 int ret;
2530
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002531 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002532
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002533 ret = _hlua_channel_dup(chn, L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002534 if (unlikely(ret == 0))
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002535 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_get_yield, TICK_ETERNITY, 0));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002536
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002537 if (unlikely(ret == -1))
2538 return 1;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002539
Willy Tarreau47860ed2015-03-10 14:07:50 +01002540 chn->buf->i -= ret;
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002541 hlua_resynchonize_proto(chn_strm(chn), !!(chn->flags & CF_ISRESP));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002542 return 1;
2543}
2544
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002545/* Check arguments for the fucntion "hlua_channel_get_yield". */
2546__LJMP static int hlua_channel_get(lua_State *L)
2547{
2548 MAY_LJMP(check_args(L, 1, "get"));
2549 MAY_LJMP(hlua_checkchannel(L, 1));
2550 return MAY_LJMP(hlua_channel_get_yield(L, 0, 0));
2551}
2552
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002553/* This functions consumes and returns one line. If the channel is closed,
2554 * and the last data does not contains a final '\n', the data are returned
2555 * without the final '\n'. When no more data are avalaible, it returns nil
2556 * value.
2557 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002558__LJMP static int hlua_channel_getline_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002559{
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002560 char *blk1;
2561 char *blk2;
2562 int len1;
2563 int len2;
2564 int len;
Willy Tarreau47860ed2015-03-10 14:07:50 +01002565 struct channel *chn;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002566 int ret;
2567 luaL_Buffer b;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002568
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002569 chn = MAY_LJMP(hlua_checkchannel(L, 1));
2570
Willy Tarreau47860ed2015-03-10 14:07:50 +01002571 ret = bi_getline_nc(chn, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002572 if (ret == 0)
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002573 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_getline_yield, TICK_ETERNITY, 0));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002574
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002575 if (ret == -1) {
2576 lua_pushnil(L);
2577 return 1;
2578 }
2579
2580 luaL_buffinit(L, &b);
2581 luaL_addlstring(&b, blk1, len1);
2582 len = len1;
2583 if (unlikely(ret == 2)) {
2584 luaL_addlstring(&b, blk2, len2);
2585 len += len2;
2586 }
2587 luaL_pushresult(&b);
Willy Tarreau47860ed2015-03-10 14:07:50 +01002588 buffer_replace2(chn->buf, chn->buf->p, chn->buf->p + len, NULL, 0);
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002589 hlua_resynchonize_proto(chn_strm(chn), !!(chn->flags & CF_ISRESP));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002590 return 1;
2591}
2592
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002593/* Check arguments for the fucntion "hlua_channel_getline_yield". */
2594__LJMP static int hlua_channel_getline(lua_State *L)
2595{
2596 MAY_LJMP(check_args(L, 1, "getline"));
2597 MAY_LJMP(hlua_checkchannel(L, 1));
2598 return MAY_LJMP(hlua_channel_getline_yield(L, 0, 0));
2599}
2600
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002601/* This function takes a string as input, and append it at the
2602 * input side of channel. If the data is too big, but a space
2603 * is probably available after sending some data, the function
2604 * yield. If the data is bigger than the buffer, or if the
2605 * channel is closed, it returns -1. otherwise, it returns the
2606 * amount of data writed.
2607 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002608__LJMP static int hlua_channel_append_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002609{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002610 struct channel *chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002611 size_t len;
2612 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
2613 int l = MAY_LJMP(luaL_checkinteger(L, 3));
2614 int ret;
2615 int max;
2616
Willy Tarreau47860ed2015-03-10 14:07:50 +01002617 max = channel_recv_limit(chn) - buffer_len(chn->buf);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002618 if (max > len - l)
2619 max = len - l;
2620
Willy Tarreau47860ed2015-03-10 14:07:50 +01002621 ret = bi_putblk(chn, str + l, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002622 if (ret == -2 || ret == -3) {
2623 lua_pushinteger(L, -1);
2624 return 1;
2625 }
Willy Tarreaubc18da12015-03-13 14:00:47 +01002626 if (ret == -1) {
2627 chn->flags |= CF_WAKE_WRITE;
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002628 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
Willy Tarreaubc18da12015-03-13 14:00:47 +01002629 }
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002630 l += ret;
2631 lua_pop(L, 1);
2632 lua_pushinteger(L, l);
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002633 hlua_resynchonize_proto(chn_strm(chn), !!(chn->flags & CF_ISRESP));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002634
Willy Tarreau47860ed2015-03-10 14:07:50 +01002635 max = channel_recv_limit(chn) - buffer_len(chn->buf);
2636 if (max == 0 && chn->buf->o == 0) {
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002637 /* There are no space avalaible, and the output buffer is empty.
2638 * in this case, we cannot add more data, so we cannot yield,
2639 * we return the amount of copyied data.
2640 */
2641 return 1;
2642 }
2643 if (l < len)
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002644 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002645 return 1;
2646}
2647
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002648/* just a wrapper of "hlua_channel_append_yield". It returns the length
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002649 * of the writed string, or -1 if the channel is closed or if the
2650 * buffer size is too little for the data.
2651 */
2652__LJMP static int hlua_channel_append(lua_State *L)
2653{
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002654 size_t len;
2655
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002656 MAY_LJMP(check_args(L, 2, "append"));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002657 MAY_LJMP(hlua_checkchannel(L, 1));
2658 MAY_LJMP(luaL_checklstring(L, 2, &len));
2659 MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002660 lua_pushinteger(L, 0);
2661
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002662 return MAY_LJMP(hlua_channel_append_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002663}
2664
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002665/* just a wrapper of "hlua_channel_append_yield". This wrapper starts
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002666 * his process by cleaning the buffer. The result is a replacement
2667 * of the current data. It returns the length of the writed string,
2668 * or -1 if the channel is closed or if the buffer size is too
2669 * little for the data.
2670 */
2671__LJMP static int hlua_channel_set(lua_State *L)
2672{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002673 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002674
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002675 MAY_LJMP(check_args(L, 2, "set"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002676 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002677 lua_pushinteger(L, 0);
2678
Willy Tarreau47860ed2015-03-10 14:07:50 +01002679 chn->buf->i = 0;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002680
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002681 return MAY_LJMP(hlua_channel_append_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002682}
2683
2684/* Append data in the output side of the buffer. This data is immediatly
2685 * sent. The fcuntion returns the ammount of data writed. If the buffer
2686 * cannot contains the data, the function yield. The function returns -1
2687 * if the channel is closed.
2688 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002689__LJMP static int hlua_channel_send_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002690{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002691 struct channel *chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002692 size_t len;
2693 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
2694 int l = MAY_LJMP(luaL_checkinteger(L, 3));
2695 int max;
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01002696 struct hlua *hlua = hlua_gethlua(L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002697
Willy Tarreau47860ed2015-03-10 14:07:50 +01002698 if (unlikely(channel_output_closed(chn))) {
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002699 lua_pushinteger(L, -1);
2700 return 1;
2701 }
2702
Thierry FOURNIER3e3a6082015-03-05 17:06:12 +01002703 /* Check if the buffer is avalaible because HAProxy doesn't allocate
2704 * the request buffer if its not required.
2705 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002706 if (chn->buf->size == 0) {
Willy Tarreau87b09662015-04-03 00:22:06 +02002707 if (!stream_alloc_recv_buffer(chn)) {
Willy Tarreau47860ed2015-03-10 14:07:50 +01002708 chn_prod(chn)->flags |= SI_FL_WAIT_ROOM;
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002709 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIER3e3a6082015-03-05 17:06:12 +01002710 }
2711 }
2712
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01002713 /* the writed data will be immediatly sent, so we can check
2714 * the avalaible space without taking in account the reserve.
2715 * The reserve is guaranted for the processing of incoming
2716 * data, because the buffer will be flushed.
2717 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002718 max = chn->buf->size - buffer_len(chn->buf);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01002719
2720 /* If there are no space avalaible, and the output buffer is empty.
2721 * in this case, we cannot add more data, so we cannot yield,
2722 * we return the amount of copyied data.
2723 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002724 if (max == 0 && chn->buf->o == 0)
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01002725 return 1;
2726
2727 /* Adjust the real required length. */
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002728 if (max > len - l)
2729 max = len - l;
2730
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01002731 /* The buffer avalaible size may be not contiguous. This test
2732 * detects a non contiguous buffer and realign it.
2733 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002734 if (bi_space_for_replace(chn->buf) < max)
2735 buffer_slow_realign(chn->buf);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01002736
2737 /* Copy input data in the buffer. */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002738 max = buffer_replace2(chn->buf, chn->buf->p, chn->buf->p, str + l, max);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01002739
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002740 /* buffer replace considers that the input part is filled.
2741 * so, I must forward these new data in the output part.
2742 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002743 b_adv(chn->buf, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002744
2745 l += max;
2746 lua_pop(L, 1);
2747 lua_pushinteger(L, l);
2748
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01002749 /* If there are no space avalaible, and the output buffer is empty.
2750 * in this case, we cannot add more data, so we cannot yield,
2751 * we return the amount of copyied data.
2752 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002753 max = chn->buf->size - buffer_len(chn->buf);
2754 if (max == 0 && chn->buf->o == 0)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002755 return 1;
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01002756
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01002757 if (l < len) {
2758 /* If we are waiting for space in the response buffer, we
2759 * must set the flag WAKERESWR. This flag required the task
2760 * wake up if any activity is detected on the response buffer.
2761 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002762 if (chn->flags & CF_ISRESP)
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01002763 HLUA_SET_WAKERESWR(hlua);
Thierry FOURNIER53e08ec2015-03-06 00:35:53 +01002764 else
2765 HLUA_SET_WAKEREQWR(hlua);
2766 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01002767 }
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002768
2769 return 1;
2770}
2771
2772/* Just a wraper of "_hlua_channel_send". This wrapper permits
2773 * yield the LUA process, and resume it without checking the
2774 * input arguments.
2775 */
2776__LJMP static int hlua_channel_send(lua_State *L)
2777{
2778 MAY_LJMP(check_args(L, 2, "send"));
2779 lua_pushinteger(L, 0);
2780
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002781 return MAY_LJMP(hlua_channel_send_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002782}
2783
2784/* This function forward and amount of butes. The data pass from
2785 * the input side of the buffer to the output side, and can be
2786 * forwarded. This function never fails.
2787 *
2788 * The Lua function takes an amount of bytes to be forwarded in
2789 * imput. It returns the number of bytes forwarded.
2790 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002791__LJMP static int hlua_channel_forward_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002792{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002793 struct channel *chn;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002794 int len;
2795 int l;
2796 int max;
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01002797 struct hlua *hlua = hlua_gethlua(L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002798
2799 chn = MAY_LJMP(hlua_checkchannel(L, 1));
2800 len = MAY_LJMP(luaL_checkinteger(L, 2));
2801 l = MAY_LJMP(luaL_checkinteger(L, -1));
2802
2803 max = len - l;
Willy Tarreau47860ed2015-03-10 14:07:50 +01002804 if (max > chn->buf->i)
2805 max = chn->buf->i;
2806 channel_forward(chn, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002807 l += max;
2808
2809 lua_pop(L, 1);
2810 lua_pushinteger(L, l);
2811
2812 /* Check if it miss bytes to forward. */
2813 if (l < len) {
2814 /* The the input channel or the output channel are closed, we
2815 * must return the amount of data forwarded.
2816 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002817 if (channel_input_closed(chn) || channel_output_closed(chn))
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002818 return 1;
2819
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01002820 /* If we are waiting for space data in the response buffer, we
2821 * must set the flag WAKERESWR. This flag required the task
2822 * wake up if any activity is detected on the response buffer.
2823 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002824 if (chn->flags & CF_ISRESP)
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01002825 HLUA_SET_WAKERESWR(hlua);
Thierry FOURNIER53e08ec2015-03-06 00:35:53 +01002826 else
2827 HLUA_SET_WAKEREQWR(hlua);
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01002828
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002829 /* Otherwise, we can yield waiting for new data in the inpout side. */
Thierry FOURNIER4abd3ae2015-03-03 17:29:06 +01002830 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_forward_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002831 }
2832
2833 return 1;
2834}
2835
2836/* Just check the input and prepare the stack for the previous
2837 * function "hlua_channel_forward_yield"
2838 */
2839__LJMP static int hlua_channel_forward(lua_State *L)
2840{
2841 MAY_LJMP(check_args(L, 2, "forward"));
2842 MAY_LJMP(hlua_checkchannel(L, 1));
2843 MAY_LJMP(luaL_checkinteger(L, 2));
2844
2845 lua_pushinteger(L, 0);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002846 return MAY_LJMP(hlua_channel_forward_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002847}
2848
2849/* Just returns the number of bytes available in the input
2850 * side of the buffer. This function never fails.
2851 */
2852__LJMP static int hlua_channel_get_in_len(lua_State *L)
2853{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002854 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002855
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002856 MAY_LJMP(check_args(L, 1, "get_in_len"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002857 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Willy Tarreau47860ed2015-03-10 14:07:50 +01002858 lua_pushinteger(L, chn->buf->i);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002859 return 1;
2860}
2861
2862/* Just returns the number of bytes available in the output
2863 * side of the buffer. This function never fails.
2864 */
2865__LJMP static int hlua_channel_get_out_len(lua_State *L)
2866{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002867 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002868
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002869 MAY_LJMP(check_args(L, 1, "get_out_len"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002870 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Willy Tarreau47860ed2015-03-10 14:07:50 +01002871 lua_pushinteger(L, chn->buf->o);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002872 return 1;
2873}
2874
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002875/*
2876 *
2877 *
2878 * Class Fetches
2879 *
2880 *
2881 */
2882
2883/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02002884 * a class stream, otherwise it throws an error.
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002885 */
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01002886__LJMP static struct hlua_smp *hlua_checkfetches(lua_State *L, int ud)
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002887{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002888 return MAY_LJMP(hlua_checkudata(L, ud, class_fetches_ref));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002889}
2890
2891/* This function creates and push in the stack a fetch object according
2892 * with a current TXN.
2893 */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01002894static int hlua_fetches_new(lua_State *L, struct hlua_txn *txn, unsigned int flags)
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002895{
Willy Tarreau7073c472015-04-06 11:15:40 +02002896 struct hlua_smp *hsmp;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002897
2898 /* Check stack size. */
2899 if (!lua_checkstack(L, 3))
2900 return 0;
2901
2902 /* Create the object: obj[0] = userdata.
2903 * Note that the base of the Fetches object is the
2904 * transaction object.
2905 */
2906 lua_newtable(L);
Willy Tarreau7073c472015-04-06 11:15:40 +02002907 hsmp = lua_newuserdata(L, sizeof(*hsmp));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002908 lua_rawseti(L, -2, 0);
2909
Willy Tarreau7073c472015-04-06 11:15:40 +02002910 hsmp->s = txn->s;
2911 hsmp->p = txn->p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01002912 hsmp->dir = txn->dir;
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01002913 hsmp->flags = flags;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002914
2915 /* Pop a class sesison metatable and affect it to the userdata. */
2916 lua_rawgeti(L, LUA_REGISTRYINDEX, class_fetches_ref);
2917 lua_setmetatable(L, -2);
2918
2919 return 1;
2920}
2921
2922/* This function is an LUA binding. It is called with each sample-fetch.
2923 * It uses closure argument to store the associated sample-fetch. It
2924 * returns only one argument or throws an error. An error is thrown
2925 * only if an error is encountered during the argument parsing. If
2926 * the "sample-fetch" function fails, nil is returned.
2927 */
2928__LJMP static int hlua_run_sample_fetch(lua_State *L)
2929{
Willy Tarreaub2ccb562015-04-06 11:11:15 +02002930 struct hlua_smp *hsmp;
Willy Tarreau2ec22742015-03-10 14:27:20 +01002931 struct sample_fetch *f;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002932 struct arg args[ARGM_NBARGS + 1];
2933 int i;
2934 struct sample smp;
2935
2936 /* Get closure arguments. */
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002937 f = lua_touserdata(L, lua_upvalueindex(1));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002938
2939 /* Get traditionnal arguments. */
Willy Tarreaub2ccb562015-04-06 11:11:15 +02002940 hsmp = MAY_LJMP(hlua_checkfetches(L, 1));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002941
Thierry FOURNIERca988662015-12-20 18:43:03 +01002942 /* Check execution authorization. */
2943 if (f->use & SMP_USE_HTTP_ANY &&
2944 !(hsmp->flags & HLUA_F_MAY_USE_HTTP)) {
2945 lua_pushfstring(L, "the sample-fetch '%s' needs an HTTP parser which "
2946 "is not available in Lua services", f->kw);
2947 WILL_LJMP(lua_error(L));
2948 }
2949
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002950 /* Get extra arguments. */
2951 for (i = 0; i < lua_gettop(L) - 1; i++) {
2952 if (i >= ARGM_NBARGS)
2953 break;
2954 hlua_lua2arg(L, i + 2, &args[i]);
2955 }
2956 args[i].type = ARGT_STOP;
David Carlierabdb00f2016-04-27 16:14:50 +01002957 args[i].data.str.str = NULL;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002958
2959 /* Check arguments. */
Willy Tarreaub2ccb562015-04-06 11:11:15 +02002960 MAY_LJMP(hlua_lua2arg_check(L, 2, args, f->arg_mask, hsmp->p));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002961
2962 /* Run the special args checker. */
Willy Tarreau2ec22742015-03-10 14:27:20 +01002963 if (f->val_args && !f->val_args(args, NULL)) {
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002964 lua_pushfstring(L, "error in arguments");
2965 WILL_LJMP(lua_error(L));
2966 }
2967
2968 /* Initialise the sample. */
2969 memset(&smp, 0, sizeof(smp));
2970
2971 /* Run the sample fetch process. */
Willy Tarreau1777ea62016-03-10 16:15:46 +01002972 smp_set_owner(&smp, hsmp->p, hsmp->s->sess, hsmp->s, hsmp->dir & SMP_OPT_DIR);
Thierry FOURNIER0786d052015-05-11 15:42:45 +02002973 if (!f->process(args, &smp, f->kw, f->private)) {
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01002974 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01002975 lua_pushstring(L, "");
2976 else
2977 lua_pushnil(L);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002978 return 1;
2979 }
2980
2981 /* Convert the returned sample in lua value. */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01002982 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01002983 hlua_smp2lua_str(L, &smp);
2984 else
2985 hlua_smp2lua(L, &smp);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002986 return 1;
2987}
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002988
2989/*
2990 *
2991 *
Thierry FOURNIER594afe72015-03-10 23:58:30 +01002992 * Class Converters
2993 *
2994 *
2995 */
2996
2997/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02002998 * a class stream, otherwise it throws an error.
Thierry FOURNIER594afe72015-03-10 23:58:30 +01002999 */
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003000__LJMP static struct hlua_smp *hlua_checkconverters(lua_State *L, int ud)
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003001{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003002 return MAY_LJMP(hlua_checkudata(L, ud, class_converters_ref));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003003}
3004
3005/* This function creates and push in the stack a Converters object
3006 * according with a current TXN.
3007 */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003008static int hlua_converters_new(lua_State *L, struct hlua_txn *txn, unsigned int flags)
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003009{
Willy Tarreau7073c472015-04-06 11:15:40 +02003010 struct hlua_smp *hsmp;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003011
3012 /* Check stack size. */
3013 if (!lua_checkstack(L, 3))
3014 return 0;
3015
3016 /* Create the object: obj[0] = userdata.
3017 * Note that the base of the Converters object is the
3018 * same than the TXN object.
3019 */
3020 lua_newtable(L);
Willy Tarreau7073c472015-04-06 11:15:40 +02003021 hsmp = lua_newuserdata(L, sizeof(*hsmp));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003022 lua_rawseti(L, -2, 0);
3023
Willy Tarreau7073c472015-04-06 11:15:40 +02003024 hsmp->s = txn->s;
3025 hsmp->p = txn->p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01003026 hsmp->dir = txn->dir;
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003027 hsmp->flags = flags;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003028
Willy Tarreau87b09662015-04-03 00:22:06 +02003029 /* Pop a class stream metatable and affect it to the table. */
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003030 lua_rawgeti(L, LUA_REGISTRYINDEX, class_converters_ref);
3031 lua_setmetatable(L, -2);
3032
3033 return 1;
3034}
3035
3036/* This function is an LUA binding. It is called with each converter.
3037 * It uses closure argument to store the associated converter. It
3038 * returns only one argument or throws an error. An error is thrown
3039 * only if an error is encountered during the argument parsing. If
3040 * the converter function function fails, nil is returned.
3041 */
3042__LJMP static int hlua_run_sample_conv(lua_State *L)
3043{
Willy Tarreauda5f1082015-04-06 11:17:13 +02003044 struct hlua_smp *hsmp;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003045 struct sample_conv *conv;
3046 struct arg args[ARGM_NBARGS + 1];
3047 int i;
3048 struct sample smp;
3049
3050 /* Get closure arguments. */
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003051 conv = lua_touserdata(L, lua_upvalueindex(1));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003052
3053 /* Get traditionnal arguments. */
Willy Tarreauda5f1082015-04-06 11:17:13 +02003054 hsmp = MAY_LJMP(hlua_checkconverters(L, 1));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003055
3056 /* Get extra arguments. */
3057 for (i = 0; i < lua_gettop(L) - 2; i++) {
3058 if (i >= ARGM_NBARGS)
3059 break;
3060 hlua_lua2arg(L, i + 3, &args[i]);
3061 }
3062 args[i].type = ARGT_STOP;
David Carlierabdb00f2016-04-27 16:14:50 +01003063 args[i].data.str.str = NULL;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003064
3065 /* Check arguments. */
Willy Tarreauda5f1082015-04-06 11:17:13 +02003066 MAY_LJMP(hlua_lua2arg_check(L, 3, args, conv->arg_mask, hsmp->p));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003067
3068 /* Run the special args checker. */
3069 if (conv->val_args && !conv->val_args(args, conv, "", 0, NULL)) {
3070 hlua_pusherror(L, "error in arguments");
3071 WILL_LJMP(lua_error(L));
3072 }
3073
3074 /* Initialise the sample. */
3075 if (!hlua_lua2smp(L, 2, &smp)) {
3076 hlua_pusherror(L, "error in the input argument");
3077 WILL_LJMP(lua_error(L));
3078 }
3079
Willy Tarreau1777ea62016-03-10 16:15:46 +01003080 smp_set_owner(&smp, hsmp->p, hsmp->s->sess, hsmp->s, hsmp->dir & SMP_OPT_DIR);
3081
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003082 /* Apply expected cast. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003083 if (!sample_casts[smp.data.type][conv->in_type]) {
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003084 hlua_pusherror(L, "invalid input argument: cannot cast '%s' to '%s'",
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003085 smp_to_type[smp.data.type], smp_to_type[conv->in_type]);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003086 WILL_LJMP(lua_error(L));
3087 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003088 if (sample_casts[smp.data.type][conv->in_type] != c_none &&
3089 !sample_casts[smp.data.type][conv->in_type](&smp)) {
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003090 hlua_pusherror(L, "error during the input argument casting");
3091 WILL_LJMP(lua_error(L));
3092 }
3093
3094 /* Run the sample conversion process. */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003095 if (!conv->process(args, &smp, conv->private)) {
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003096 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003097 lua_pushstring(L, "");
3098 else
Willy Tarreaua678b432015-08-28 10:14:59 +02003099 lua_pushnil(L);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003100 return 1;
3101 }
3102
3103 /* Convert the returned sample in lua value. */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003104 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003105 hlua_smp2lua_str(L, &smp);
3106 else
3107 hlua_smp2lua(L, &smp);
Willy Tarreaua678b432015-08-28 10:14:59 +02003108 return 1;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003109}
3110
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003111/*
3112 *
3113 *
3114 * Class AppletTCP
3115 *
3116 *
3117 */
3118
3119/* Returns a struct hlua_txn if the stack entry "ud" is
3120 * a class stream, otherwise it throws an error.
3121 */
3122__LJMP static struct hlua_appctx *hlua_checkapplet_tcp(lua_State *L, int ud)
3123{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003124 return MAY_LJMP(hlua_checkudata(L, ud, class_applet_tcp_ref));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003125}
3126
3127/* This function creates and push in the stack an Applet object
3128 * according with a current TXN.
3129 */
3130static int hlua_applet_tcp_new(lua_State *L, struct appctx *ctx)
3131{
3132 struct hlua_appctx *appctx;
3133 struct stream_interface *si = ctx->owner;
3134 struct stream *s = si_strm(si);
3135 struct proxy *p = s->be;
3136
3137 /* Check stack size. */
3138 if (!lua_checkstack(L, 3))
3139 return 0;
3140
3141 /* Create the object: obj[0] = userdata.
3142 * Note that the base of the Converters object is the
3143 * same than the TXN object.
3144 */
3145 lua_newtable(L);
3146 appctx = lua_newuserdata(L, sizeof(*appctx));
3147 lua_rawseti(L, -2, 0);
3148 appctx->appctx = ctx;
3149 appctx->htxn.s = s;
3150 appctx->htxn.p = p;
3151
3152 /* Create the "f" field that contains a list of fetches. */
3153 lua_pushstring(L, "f");
3154 if (!hlua_fetches_new(L, &appctx->htxn, 0))
3155 return 0;
3156 lua_settable(L, -3);
3157
3158 /* Create the "sf" field that contains a list of stringsafe fetches. */
3159 lua_pushstring(L, "sf");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003160 if (!hlua_fetches_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003161 return 0;
3162 lua_settable(L, -3);
3163
3164 /* Create the "c" field that contains a list of converters. */
3165 lua_pushstring(L, "c");
3166 if (!hlua_converters_new(L, &appctx->htxn, 0))
3167 return 0;
3168 lua_settable(L, -3);
3169
3170 /* Create the "sc" field that contains a list of stringsafe converters. */
3171 lua_pushstring(L, "sc");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003172 if (!hlua_converters_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003173 return 0;
3174 lua_settable(L, -3);
3175
3176 /* Pop a class stream metatable and affect it to the table. */
3177 lua_rawgeti(L, LUA_REGISTRYINDEX, class_applet_tcp_ref);
3178 lua_setmetatable(L, -2);
3179
3180 return 1;
3181}
3182
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003183__LJMP static int hlua_applet_tcp_set_priv(lua_State *L)
3184{
3185 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3186 struct stream *s = appctx->htxn.s;
3187 struct hlua *hlua = &s->hlua;
3188
3189 MAY_LJMP(check_args(L, 2, "set_priv"));
3190
3191 /* Remove previous value. */
3192 if (hlua->Mref != -1)
3193 luaL_unref(L, hlua->Mref, LUA_REGISTRYINDEX);
3194
3195 /* Get and store new value. */
3196 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
3197 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
3198
3199 return 0;
3200}
3201
3202__LJMP static int hlua_applet_tcp_get_priv(lua_State *L)
3203{
3204 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3205 struct stream *s = appctx->htxn.s;
3206 struct hlua *hlua = &s->hlua;
3207
3208 /* Push configuration index in the stack. */
3209 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
3210
3211 return 1;
3212}
3213
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003214/* If expected data not yet available, it returns a yield. This function
3215 * consumes the data in the buffer. It returns a string containing the
3216 * data. This string can be empty.
3217 */
3218__LJMP static int hlua_applet_tcp_getline_yield(lua_State *L, int status, lua_KContext ctx)
3219{
3220 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3221 struct stream_interface *si = appctx->appctx->owner;
3222 int ret;
3223 char *blk1;
3224 int len1;
3225 char *blk2;
3226 int len2;
3227
3228 /* Read the maximum amount of data avalaible. */
3229 ret = bo_getline_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
3230
3231 /* Data not yet avalaible. return yield. */
3232 if (ret == 0) {
3233 si_applet_cant_get(si);
3234 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_getline_yield, TICK_ETERNITY, 0));
3235 }
3236
3237 /* End of data: commit the total strings and return. */
3238 if (ret < 0) {
3239 luaL_pushresult(&appctx->b);
3240 return 1;
3241 }
3242
3243 /* Ensure that the block 2 length is usable. */
3244 if (ret == 1)
3245 len2 = 0;
3246
3247 /* dont check the max length read and dont check. */
3248 luaL_addlstring(&appctx->b, blk1, len1);
3249 luaL_addlstring(&appctx->b, blk2, len2);
3250
3251 /* Consume input channel output buffer data. */
3252 bo_skip(si_oc(si), len1 + len2);
3253 luaL_pushresult(&appctx->b);
3254 return 1;
3255}
3256
3257/* Check arguments for the fucntion "hlua_channel_get_yield". */
3258__LJMP static int hlua_applet_tcp_getline(lua_State *L)
3259{
3260 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3261
3262 /* Initialise the string catenation. */
3263 luaL_buffinit(L, &appctx->b);
3264
3265 return MAY_LJMP(hlua_applet_tcp_getline_yield(L, 0, 0));
3266}
3267
3268/* If expected data not yet available, it returns a yield. This function
3269 * consumes the data in the buffer. It returns a string containing the
3270 * data. This string can be empty.
3271 */
3272__LJMP static int hlua_applet_tcp_recv_yield(lua_State *L, int status, lua_KContext ctx)
3273{
3274 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3275 struct stream_interface *si = appctx->appctx->owner;
3276 int len = MAY_LJMP(luaL_checkinteger(L, 2));
3277 int ret;
3278 char *blk1;
3279 int len1;
3280 char *blk2;
3281 int len2;
3282
3283 /* Read the maximum amount of data avalaible. */
3284 ret = bo_getblk_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
3285
3286 /* Data not yet avalaible. return yield. */
3287 if (ret == 0) {
3288 si_applet_cant_get(si);
3289 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
3290 }
3291
3292 /* End of data: commit the total strings and return. */
3293 if (ret < 0) {
3294 luaL_pushresult(&appctx->b);
3295 return 1;
3296 }
3297
3298 /* Ensure that the block 2 length is usable. */
3299 if (ret == 1)
3300 len2 = 0;
3301
3302 if (len == -1) {
3303
3304 /* If len == -1, catenate all the data avalaile and
3305 * yield because we want to get all the data until
3306 * the end of data stream.
3307 */
3308 luaL_addlstring(&appctx->b, blk1, len1);
3309 luaL_addlstring(&appctx->b, blk2, len2);
3310 bo_skip(si_oc(si), len1 + len2);
3311 si_applet_cant_get(si);
3312 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
3313
3314 } else {
3315
3316 /* Copy the fisrt block caping to the length required. */
3317 if (len1 > len)
3318 len1 = len;
3319 luaL_addlstring(&appctx->b, blk1, len1);
3320 len -= len1;
3321
3322 /* Copy the second block. */
3323 if (len2 > len)
3324 len2 = len;
3325 luaL_addlstring(&appctx->b, blk2, len2);
3326 len -= len2;
3327
3328 /* Consume input channel output buffer data. */
3329 bo_skip(si_oc(si), len1 + len2);
3330
3331 /* If we are no other data avalaible, yield waiting for new data. */
3332 if (len > 0) {
3333 lua_pushinteger(L, len);
3334 lua_replace(L, 2);
3335 si_applet_cant_get(si);
3336 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
3337 }
3338
3339 /* return the result. */
3340 luaL_pushresult(&appctx->b);
3341 return 1;
3342 }
3343
3344 /* we never executes this */
3345 hlua_pusherror(L, "Lua: internal error");
3346 WILL_LJMP(lua_error(L));
3347 return 0;
3348}
3349
3350/* Check arguments for the fucntion "hlua_channel_get_yield". */
3351__LJMP static int hlua_applet_tcp_recv(lua_State *L)
3352{
3353 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3354 int len = -1;
3355
3356 if (lua_gettop(L) > 2)
3357 WILL_LJMP(luaL_error(L, "The 'recv' function requires between 1 and 2 arguments."));
3358 if (lua_gettop(L) >= 2) {
3359 len = MAY_LJMP(luaL_checkinteger(L, 2));
3360 lua_pop(L, 1);
3361 }
3362
3363 /* Confirm or set the required length */
3364 lua_pushinteger(L, len);
3365
3366 /* Initialise the string catenation. */
3367 luaL_buffinit(L, &appctx->b);
3368
3369 return MAY_LJMP(hlua_applet_tcp_recv_yield(L, 0, 0));
3370}
3371
3372/* Append data in the output side of the buffer. This data is immediatly
3373 * sent. The fcuntion returns the ammount of data writed. If the buffer
3374 * cannot contains the data, the function yield. The function returns -1
3375 * if the channel is closed.
3376 */
3377__LJMP static int hlua_applet_tcp_send_yield(lua_State *L, int status, lua_KContext ctx)
3378{
3379 size_t len;
3380 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3381 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
3382 int l = MAY_LJMP(luaL_checkinteger(L, 3));
3383 struct stream_interface *si = appctx->appctx->owner;
3384 struct channel *chn = si_ic(si);
3385 int max;
3386
3387 /* Get the max amount of data which can write as input in the channel. */
3388 max = channel_recv_max(chn);
3389 if (max > (len - l))
3390 max = len - l;
3391
3392 /* Copy data. */
3393 bi_putblk(chn, str + l, max);
3394
3395 /* update counters. */
3396 l += max;
3397 lua_pop(L, 1);
3398 lua_pushinteger(L, l);
3399
3400 /* If some data is not send, declares the situation to the
3401 * applet, and returns a yield.
3402 */
3403 if (l < len) {
3404 si_applet_cant_put(si);
3405 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_send_yield, TICK_ETERNITY, 0));
3406 }
3407
3408 return 1;
3409}
3410
3411/* Just a wraper of "hlua_applet_tcp_send_yield". This wrapper permits
3412 * yield the LUA process, and resume it without checking the
3413 * input arguments.
3414 */
3415__LJMP static int hlua_applet_tcp_send(lua_State *L)
3416{
3417 MAY_LJMP(check_args(L, 2, "send"));
3418 lua_pushinteger(L, 0);
3419
3420 return MAY_LJMP(hlua_applet_tcp_send_yield(L, 0, 0));
3421}
3422
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003423/*
3424 *
3425 *
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003426 * Class AppletHTTP
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003427 *
3428 *
3429 */
3430
3431/* Returns a struct hlua_txn if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02003432 * a class stream, otherwise it throws an error.
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003433 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003434__LJMP static struct hlua_appctx *hlua_checkapplet_http(lua_State *L, int ud)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003435{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003436 return MAY_LJMP(hlua_checkudata(L, ud, class_applet_http_ref));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003437}
3438
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003439/* This function creates and push in the stack an Applet object
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003440 * according with a current TXN.
3441 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003442static int hlua_applet_http_new(lua_State *L, struct appctx *ctx)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003443{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003444 struct hlua_appctx *appctx;
Thierry FOURNIER841475e2015-12-11 17:10:09 +01003445 struct hlua_txn htxn;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003446 struct stream_interface *si = ctx->owner;
3447 struct stream *s = si_strm(si);
3448 struct proxy *px = s->be;
3449 struct http_txn *txn = s->txn;
3450 const char *path;
3451 const char *end;
3452 const char *p;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003453
3454 /* Check stack size. */
3455 if (!lua_checkstack(L, 3))
3456 return 0;
3457
3458 /* Create the object: obj[0] = userdata.
3459 * Note that the base of the Converters object is the
3460 * same than the TXN object.
3461 */
3462 lua_newtable(L);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003463 appctx = lua_newuserdata(L, sizeof(*appctx));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003464 lua_rawseti(L, -2, 0);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003465 appctx->appctx = ctx;
3466 appctx->appctx->ctx.hlua_apphttp.status = 200; /* Default status code returned. */
3467 appctx->htxn.s = s;
3468 appctx->htxn.p = px;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003469
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003470 /* Create the "f" field that contains a list of fetches. */
3471 lua_pushstring(L, "f");
3472 if (!hlua_fetches_new(L, &appctx->htxn, 0))
3473 return 0;
3474 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003475
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003476 /* Create the "sf" field that contains a list of stringsafe fetches. */
3477 lua_pushstring(L, "sf");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003478 if (!hlua_fetches_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003479 return 0;
3480 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003481
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003482 /* Create the "c" field that contains a list of converters. */
3483 lua_pushstring(L, "c");
3484 if (!hlua_converters_new(L, &appctx->htxn, 0))
3485 return 0;
3486 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003487
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003488 /* Create the "sc" field that contains a list of stringsafe converters. */
3489 lua_pushstring(L, "sc");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003490 if (!hlua_converters_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003491 return 0;
3492 lua_settable(L, -3);
Willy Tarreaueee5b512015-04-03 23:46:31 +02003493
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003494 /* Stores the request method. */
3495 lua_pushstring(L, "method");
3496 lua_pushlstring(L, txn->req.chn->buf->p, txn->req.sl.rq.m_l);
3497 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003498
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003499 /* Stores the http version. */
3500 lua_pushstring(L, "version");
3501 lua_pushlstring(L, txn->req.chn->buf->p + txn->req.sl.rq.v, txn->req.sl.rq.v_l);
3502 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003503
Thierry FOURNIER841475e2015-12-11 17:10:09 +01003504 /* creates an array of headers. hlua_http_get_headers() crates and push
3505 * the array on the top of the stack.
3506 */
3507 lua_pushstring(L, "headers");
3508 htxn.s = s;
3509 htxn.p = px;
3510 htxn.dir = SMP_OPT_DIR_REQ;
3511 if (!hlua_http_get_headers(L, &htxn, &htxn.s->txn->req))
3512 return 0;
3513 lua_settable(L, -3);
3514
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003515 /* Get path and qs */
3516 path = http_get_path(txn);
3517 end = txn->req.chn->buf->p + txn->req.sl.rq.u + txn->req.sl.rq.u_l;
3518 p = path;
3519 while (p < end && *p != '?')
3520 p++;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003521
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003522 /* Stores the request path. */
3523 lua_pushstring(L, "path");
3524 lua_pushlstring(L, path, p - path);
3525 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003526
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003527 /* Stores the query string. */
3528 lua_pushstring(L, "qs");
3529 if (*p == '?')
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003530 p++;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003531 lua_pushlstring(L, p, end - p);
3532 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01003533
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003534 /* Stores the request path. */
3535 lua_pushstring(L, "length");
3536 lua_pushinteger(L, txn->req.body_len);
3537 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01003538
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003539 /* Create an array of HTTP request headers. */
3540 lua_pushstring(L, "headers");
3541 MAY_LJMP(hlua_http_get_headers(L, &appctx->htxn, &appctx->htxn.s->txn->req));
3542 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01003543
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003544 /* Create an empty array of HTTP request headers. */
3545 lua_pushstring(L, "response");
3546 lua_newtable(L);
3547 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01003548
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003549 /* Pop a class stream metatable and affect it to the table. */
3550 lua_rawgeti(L, LUA_REGISTRYINDEX, class_applet_http_ref);
3551 lua_setmetatable(L, -2);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003552
3553 return 1;
3554}
3555
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003556__LJMP static int hlua_applet_http_set_priv(lua_State *L)
3557{
3558 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3559 struct stream *s = appctx->htxn.s;
3560 struct hlua *hlua = &s->hlua;
3561
3562 MAY_LJMP(check_args(L, 2, "set_priv"));
3563
3564 /* Remove previous value. */
3565 if (hlua->Mref != -1)
3566 luaL_unref(L, hlua->Mref, LUA_REGISTRYINDEX);
3567
3568 /* Get and store new value. */
3569 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
3570 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
3571
3572 return 0;
3573}
3574
3575__LJMP static int hlua_applet_http_get_priv(lua_State *L)
3576{
3577 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3578 struct stream *s = appctx->htxn.s;
3579 struct hlua *hlua = &s->hlua;
3580
3581 /* Push configuration index in the stack. */
3582 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
3583
3584 return 1;
3585}
3586
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003587/* If expected data not yet available, it returns a yield. This function
3588 * consumes the data in the buffer. It returns a string containing the
3589 * data. This string can be empty.
3590 */
3591__LJMP static int hlua_applet_http_getline_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003592{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003593 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3594 struct stream_interface *si = appctx->appctx->owner;
3595 struct channel *chn = si_ic(si);
3596 int ret;
3597 char *blk1;
3598 int len1;
3599 char *blk2;
3600 int len2;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003601
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003602 /* Maybe we cant send a 100-continue ? */
3603 if (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_100C) {
3604 ret = bi_putblk(chn, HTTP_100C, strlen(HTTP_100C));
3605 /* if ret == -2 or -3 the channel closed or the message si too
3606 * big for the buffers. We cant send anything. So, we ignoring
3607 * the error, considers that the 100-continue is sent, and try
3608 * to receive.
3609 * If ret is -1, we dont have room in the buffer, so we yield.
3610 */
3611 if (ret == -1) {
3612 si_applet_cant_put(si);
3613 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_getline_yield, TICK_ETERNITY, 0));
3614 }
3615 appctx->appctx->ctx.hlua_apphttp.flags &= ~APPLET_100C;
3616 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003617
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003618 /* Check for the end of the data. */
3619 if (appctx->appctx->ctx.hlua_apphttp.left_bytes <= 0) {
3620 luaL_pushresult(&appctx->b);
3621 return 1;
3622 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003623
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003624 /* Read the maximum amount of data avalaible. */
3625 ret = bo_getline_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003626
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003627 /* Data not yet avalaible. return yield. */
3628 if (ret == 0) {
3629 si_applet_cant_get(si);
3630 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_getline_yield, TICK_ETERNITY, 0));
3631 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003632
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003633 /* End of data: commit the total strings and return. */
3634 if (ret < 0) {
3635 luaL_pushresult(&appctx->b);
3636 return 1;
3637 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003638
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003639 /* Ensure that the block 2 length is usable. */
3640 if (ret == 1)
3641 len2 = 0;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003642
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003643 /* Copy the fisrt block caping to the length required. */
3644 if (len1 > appctx->appctx->ctx.hlua_apphttp.left_bytes)
3645 len1 = appctx->appctx->ctx.hlua_apphttp.left_bytes;
3646 luaL_addlstring(&appctx->b, blk1, len1);
3647 appctx->appctx->ctx.hlua_apphttp.left_bytes -= len1;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003648
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003649 /* Copy the second block. */
3650 if (len2 > appctx->appctx->ctx.hlua_apphttp.left_bytes)
3651 len2 = appctx->appctx->ctx.hlua_apphttp.left_bytes;
3652 luaL_addlstring(&appctx->b, blk2, len2);
3653 appctx->appctx->ctx.hlua_apphttp.left_bytes -= len2;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003654
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003655 /* Consume input channel output buffer data. */
3656 bo_skip(si_oc(si), len1 + len2);
3657 luaL_pushresult(&appctx->b);
3658 return 1;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003659}
3660
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003661/* Check arguments for the fucntion "hlua_channel_get_yield". */
3662__LJMP static int hlua_applet_http_getline(lua_State *L)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003663{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003664 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003665
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003666 /* Initialise the string catenation. */
3667 luaL_buffinit(L, &appctx->b);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003668
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003669 return MAY_LJMP(hlua_applet_http_getline_yield(L, 0, 0));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003670}
3671
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003672/* If expected data not yet available, it returns a yield. This function
3673 * consumes the data in the buffer. It returns a string containing the
3674 * data. This string can be empty.
3675 */
3676__LJMP static int hlua_applet_http_recv_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003677{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003678 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3679 struct stream_interface *si = appctx->appctx->owner;
3680 int len = MAY_LJMP(luaL_checkinteger(L, 2));
3681 struct channel *chn = si_ic(si);
3682 int ret;
3683 char *blk1;
3684 int len1;
3685 char *blk2;
3686 int len2;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003687
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003688 /* Maybe we cant send a 100-continue ? */
3689 if (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_100C) {
3690 ret = bi_putblk(chn, HTTP_100C, strlen(HTTP_100C));
3691 /* if ret == -2 or -3 the channel closed or the message si too
3692 * big for the buffers. We cant send anything. So, we ignoring
3693 * the error, considers that the 100-continue is sent, and try
3694 * to receive.
3695 * If ret is -1, we dont have room in the buffer, so we yield.
3696 */
3697 if (ret == -1) {
3698 si_applet_cant_put(si);
3699 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_recv_yield, TICK_ETERNITY, 0));
3700 }
3701 appctx->appctx->ctx.hlua_apphttp.flags &= ~APPLET_100C;
3702 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003703
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003704 /* Read the maximum amount of data avalaible. */
3705 ret = bo_getblk_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003706
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003707 /* Data not yet avalaible. return yield. */
3708 if (ret == 0) {
3709 si_applet_cant_get(si);
3710 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_recv_yield, TICK_ETERNITY, 0));
3711 }
3712
3713 /* End of data: commit the total strings and return. */
3714 if (ret < 0) {
3715 luaL_pushresult(&appctx->b);
3716 return 1;
3717 }
3718
3719 /* Ensure that the block 2 length is usable. */
3720 if (ret == 1)
3721 len2 = 0;
3722
3723 /* Copy the fisrt block caping to the length required. */
3724 if (len1 > len)
3725 len1 = len;
3726 luaL_addlstring(&appctx->b, blk1, len1);
3727 len -= len1;
3728
3729 /* Copy the second block. */
3730 if (len2 > len)
3731 len2 = len;
3732 luaL_addlstring(&appctx->b, blk2, len2);
3733 len -= len2;
3734
3735 /* Consume input channel output buffer data. */
3736 bo_skip(si_oc(si), len1 + len2);
3737 if (appctx->appctx->ctx.hlua_apphttp.left_bytes != -1)
3738 appctx->appctx->ctx.hlua_apphttp.left_bytes -= len;
3739
3740 /* If we are no other data avalaible, yield waiting for new data. */
3741 if (len > 0) {
3742 lua_pushinteger(L, len);
3743 lua_replace(L, 2);
3744 si_applet_cant_get(si);
3745 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_recv_yield, TICK_ETERNITY, 0));
3746 }
3747
3748 /* return the result. */
3749 luaL_pushresult(&appctx->b);
3750 return 1;
3751}
3752
3753/* Check arguments for the fucntion "hlua_channel_get_yield". */
3754__LJMP static int hlua_applet_http_recv(lua_State *L)
3755{
3756 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3757 int len = -1;
3758
3759 /* Check arguments. */
3760 if (lua_gettop(L) > 2)
3761 WILL_LJMP(luaL_error(L, "The 'recv' function requires between 1 and 2 arguments."));
3762 if (lua_gettop(L) >= 2) {
3763 len = MAY_LJMP(luaL_checkinteger(L, 2));
3764 lua_pop(L, 1);
3765 }
3766
3767 /* Check the required length */
3768 if (len == -1 || len > appctx->appctx->ctx.hlua_apphttp.left_bytes)
3769 len = appctx->appctx->ctx.hlua_apphttp.left_bytes;
3770 lua_pushinteger(L, len);
3771
3772 /* Initialise the string catenation. */
3773 luaL_buffinit(L, &appctx->b);
3774
3775 return MAY_LJMP(hlua_applet_http_recv_yield(L, 0, 0));
3776}
3777
3778/* Append data in the output side of the buffer. This data is immediatly
3779 * sent. The fcuntion returns the ammount of data writed. If the buffer
3780 * cannot contains the data, the function yield. The function returns -1
3781 * if the channel is closed.
3782 */
3783__LJMP static int hlua_applet_http_send_yield(lua_State *L, int status, lua_KContext ctx)
3784{
3785 size_t len;
3786 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3787 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
3788 int l = MAY_LJMP(luaL_checkinteger(L, 3));
3789 struct stream_interface *si = appctx->appctx->owner;
3790 struct channel *chn = si_ic(si);
3791 int max;
3792
3793 /* Get the max amount of data which can write as input in the channel. */
3794 max = channel_recv_max(chn);
3795 if (max > (len - l))
3796 max = len - l;
3797
3798 /* Copy data. */
3799 bi_putblk(chn, str + l, max);
3800
3801 /* update counters. */
3802 l += max;
3803 lua_pop(L, 1);
3804 lua_pushinteger(L, l);
3805
3806 /* If some data is not send, declares the situation to the
3807 * applet, and returns a yield.
3808 */
3809 if (l < len) {
3810 si_applet_cant_put(si);
3811 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_send_yield, TICK_ETERNITY, 0));
3812 }
3813
3814 return 1;
3815}
3816
3817/* Just a wraper of "hlua_applet_send_yield". This wrapper permits
3818 * yield the LUA process, and resume it without checking the
3819 * input arguments.
3820 */
3821__LJMP static int hlua_applet_http_send(lua_State *L)
3822{
3823 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3824 size_t len;
3825 char hex[10];
3826
3827 MAY_LJMP(luaL_checklstring(L, 2, &len));
3828
3829 /* If transfer encoding chunked is selected, we surround the data
3830 * by chunk data.
3831 */
3832 if (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_CHUNKED) {
3833 snprintf(hex, 9, "%x", (unsigned int)len);
3834 lua_pushfstring(L, "%s\r\n", hex);
3835 lua_insert(L, 2); /* swap the last 2 entries. */
3836 lua_pushstring(L, "\r\n");
3837 lua_concat(L, 3);
3838 }
3839
3840 /* This interger is used for followinf the amount of data sent. */
3841 lua_pushinteger(L, 0);
3842
3843 /* We want to send some data. Headers must be sent. */
3844 if (!(appctx->appctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT)) {
3845 hlua_pusherror(L, "Lua: 'send' you must call start_response() before sending data.");
3846 WILL_LJMP(lua_error(L));
3847 }
3848
3849 return MAY_LJMP(hlua_applet_http_send_yield(L, 0, 0));
3850}
3851
3852__LJMP static int hlua_applet_http_addheader(lua_State *L)
3853{
3854 const char *name;
3855 int ret;
3856
3857 MAY_LJMP(hlua_checkapplet_http(L, 1));
3858 name = MAY_LJMP(luaL_checkstring(L, 2));
3859 MAY_LJMP(luaL_checkstring(L, 3));
3860
3861 /* Push in the stack the "response" entry. */
3862 ret = lua_getfield(L, 1, "response");
3863 if (ret != LUA_TTABLE) {
3864 hlua_pusherror(L, "Lua: 'add_header' internal error: AppletHTTP['response'] "
3865 "is expected as an array. %s found", lua_typename(L, ret));
3866 WILL_LJMP(lua_error(L));
3867 }
3868
3869 /* check if the header is already registered if it is not
3870 * the case, register it.
3871 */
3872 ret = lua_getfield(L, -1, name);
3873 if (ret == LUA_TNIL) {
3874
3875 /* Entry not found. */
3876 lua_pop(L, 1); /* remove the nil. The "response" table is the top of the stack. */
3877
3878 /* Insert the new header name in the array in the top of the stack.
3879 * It left the new array in the top of the stack.
3880 */
3881 lua_newtable(L);
3882 lua_pushvalue(L, 2);
3883 lua_pushvalue(L, -2);
3884 lua_settable(L, -4);
3885
3886 } else if (ret != LUA_TTABLE) {
3887
3888 /* corruption error. */
3889 hlua_pusherror(L, "Lua: 'add_header' internal error: AppletHTTP['response']['%s'] "
3890 "is expected as an array. %s found", name, lua_typename(L, ret));
3891 WILL_LJMP(lua_error(L));
3892 }
3893
3894 /* Now the top od thestack is an array of values. We push
3895 * the header value as new entry.
3896 */
3897 lua_pushvalue(L, 3);
3898 ret = lua_rawlen(L, -2);
3899 lua_rawseti(L, -2, ret + 1);
3900 lua_pushboolean(L, 1);
3901 return 1;
3902}
3903
3904__LJMP static int hlua_applet_http_status(lua_State *L)
3905{
3906 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3907 int status = MAY_LJMP(luaL_checkinteger(L, 2));
3908
3909 if (status < 100 || status > 599) {
3910 lua_pushboolean(L, 0);
3911 return 1;
3912 }
3913
3914 appctx->appctx->ctx.hlua_apphttp.status = status;
3915 lua_pushboolean(L, 1);
3916 return 1;
3917}
3918
3919/* We will build the status line and the headers of the HTTP response.
3920 * We will try send at once if its not possible, we give back the hand
3921 * waiting for more room.
3922 */
3923__LJMP static int hlua_applet_http_start_response_yield(lua_State *L, int status, lua_KContext ctx)
3924{
3925 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3926 struct stream_interface *si = appctx->appctx->owner;
3927 struct channel *chn = si_ic(si);
3928 int ret;
3929 size_t len;
3930 const char *msg;
3931
3932 /* Get the message as the first argument on the stack. */
3933 msg = MAY_LJMP(luaL_checklstring(L, 2, &len));
3934
3935 /* Send the message at once. */
3936 ret = bi_putblk(chn, msg, len);
3937
3938 /* if ret == -2 or -3 the channel closed or the message si too
3939 * big for the buffers.
3940 */
3941 if (ret == -2 || ret == -3) {
3942 hlua_pusherror(L, "Lua: 'start_response': response header block too big");
3943 WILL_LJMP(lua_error(L));
3944 }
3945
3946 /* If ret is -1, we dont have room in the buffer, so we yield. */
3947 if (ret == -1) {
3948 si_applet_cant_put(si);
3949 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_start_response_yield, TICK_ETERNITY, 0));
3950 }
3951
3952 /* Headers sent, set the flag. */
3953 appctx->appctx->ctx.hlua_apphttp.flags |= APPLET_HDR_SENT;
3954 return 0;
3955}
3956
3957__LJMP static int hlua_applet_http_start_response(lua_State *L)
3958{
3959 struct chunk *tmp = get_trash_chunk();
3960 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003961 const char *name;
3962 const char *value;
3963 int id;
3964 int hdr_connection = 0;
3965 int hdr_contentlength = -1;
3966 int hdr_chunked = 0;
3967
3968 /* Use the same http version than the request. */
3969 chunk_appendf(tmp, "HTTP/1.%c %d %s\r\n",
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +01003970 appctx->appctx->ctx.hlua_apphttp.flags & APPLET_HTTP11 ? '1' : '0',
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003971 appctx->appctx->ctx.hlua_apphttp.status,
3972 get_reason(appctx->appctx->ctx.hlua_apphttp.status));
3973
3974 /* Get the array associated to the field "response" in the object AppletHTTP. */
3975 lua_pushvalue(L, 0);
3976 if (lua_getfield(L, 1, "response") != LUA_TTABLE) {
3977 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response'] missing.\n",
3978 appctx->appctx->rule->arg.hlua_rule->fcn.name);
3979 WILL_LJMP(lua_error(L));
3980 }
3981
3982 /* Browse the list of headers. */
3983 lua_pushnil(L);
3984 while(lua_next(L, -2) != 0) {
3985
3986 /* We expect a string as -2. */
3987 if (lua_type(L, -2) != LUA_TSTRING) {
3988 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response'][] element must be a string. got %s.\n",
3989 appctx->appctx->rule->arg.hlua_rule->fcn.name,
3990 lua_typename(L, lua_type(L, -2)));
3991 WILL_LJMP(lua_error(L));
3992 }
3993 name = lua_tostring(L, -2);
3994
3995 /* We expect an array as -1. */
3996 if (lua_type(L, -1) != LUA_TTABLE) {
3997 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'] element must be an table. got %s.\n",
3998 appctx->appctx->rule->arg.hlua_rule->fcn.name,
3999 name,
4000 lua_typename(L, lua_type(L, -1)));
4001 WILL_LJMP(lua_error(L));
4002 }
4003
4004 /* Browse the table who is on the top of the stack. */
4005 lua_pushnil(L);
4006 while(lua_next(L, -2) != 0) {
4007
4008 /* We expect a number as -2. */
4009 if (lua_type(L, -2) != LUA_TNUMBER) {
4010 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'][] element must be a number. got %s.\n",
4011 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4012 name,
4013 lua_typename(L, lua_type(L, -2)));
4014 WILL_LJMP(lua_error(L));
4015 }
4016 id = lua_tointeger(L, -2);
4017
4018 /* We expect a string as -2. */
4019 if (lua_type(L, -1) != LUA_TSTRING) {
4020 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'][%d] element must be a string. got %s.\n",
4021 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4022 name, id,
4023 lua_typename(L, lua_type(L, -1)));
4024 WILL_LJMP(lua_error(L));
4025 }
4026 value = lua_tostring(L, -1);
4027
4028 /* Catenate a new header. */
4029 chunk_appendf(tmp, "%s: %s\r\n", name, value);
4030
4031 /* Protocol checks. */
4032
4033 /* Check if the header conneciton is present. */
4034 if (strcasecmp("connection", name) == 0)
4035 hdr_connection = 1;
4036
4037 /* Copy the header content length. The length conversion
4038 * is done without control. If it contains a ad value, this
4039 * is not our problem.
4040 */
4041 if (strcasecmp("content-length", name) == 0)
4042 hdr_contentlength = atoi(value);
4043
4044 /* Check if the client annouces a transfer-encoding chunked it self. */
4045 if (strcasecmp("transfer-encoding", name) == 0 &&
4046 strcasecmp("chunked", value) == 0)
4047 hdr_chunked = 1;
4048
4049 /* Remove the array from the stack, and get next element with a remaining string. */
4050 lua_pop(L, 1);
4051 }
4052
4053 /* Remove the array from the stack, and get next element with a remaining string. */
4054 lua_pop(L, 1);
4055 }
4056
4057 /* If the http protocol version is 1.1, we expect an header "connection" set
4058 * to "close" to be HAProxy/keeplive compliant. Otherwise, we expect nothing.
4059 * If the header conneciton is present, don't change it, if it is not present,
4060 * we must set.
4061 *
4062 * we set a "connection: close" header for ensuring that the keepalive will be
4063 * respected by haproxy. HAProcy considers that the application cloe the connection
4064 * and it keep the connection from the client open.
4065 */
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +01004066 if (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_HTTP11 && !hdr_connection)
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004067 chunk_appendf(tmp, "Connection: close\r\n");
4068
4069 /* If we dont have a content-length set, we must announce a transfer enconding
4070 * chunked. This is required by haproxy for the keepalive compliance.
4071 * If the applet annouce a transfer-encoding chunked itslef, don't
4072 * do anything.
4073 */
4074 if (hdr_contentlength == -1 && hdr_chunked == 0) {
4075 chunk_appendf(tmp, "Transfer-encoding: chunked\r\n");
4076 appctx->appctx->ctx.hlua_apphttp.flags |= APPLET_CHUNKED;
4077 }
4078
4079 /* Finalize headers. */
4080 chunk_appendf(tmp, "\r\n");
4081
4082 /* Remove the last entry and the array of headers */
4083 lua_pop(L, 2);
4084
4085 /* Push the headers block. */
4086 lua_pushlstring(L, tmp->str, tmp->len);
4087
4088 return MAY_LJMP(hlua_applet_http_start_response_yield(L, 0, 0));
4089}
4090
4091/*
4092 *
4093 *
4094 * Class HTTP
4095 *
4096 *
4097 */
4098
4099/* Returns a struct hlua_txn if the stack entry "ud" is
4100 * a class stream, otherwise it throws an error.
4101 */
4102__LJMP static struct hlua_txn *hlua_checkhttp(lua_State *L, int ud)
4103{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02004104 return MAY_LJMP(hlua_checkudata(L, ud, class_http_ref));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004105}
4106
4107/* This function creates and push in the stack a HTTP object
4108 * according with a current TXN.
4109 */
4110static int hlua_http_new(lua_State *L, struct hlua_txn *txn)
4111{
4112 struct hlua_txn *htxn;
4113
4114 /* Check stack size. */
4115 if (!lua_checkstack(L, 3))
4116 return 0;
4117
4118 /* Create the object: obj[0] = userdata.
4119 * Note that the base of the Converters object is the
4120 * same than the TXN object.
4121 */
4122 lua_newtable(L);
4123 htxn = lua_newuserdata(L, sizeof(*htxn));
4124 lua_rawseti(L, -2, 0);
4125
4126 htxn->s = txn->s;
4127 htxn->p = txn->p;
4128
4129 /* Pop a class stream metatable and affect it to the table. */
4130 lua_rawgeti(L, LUA_REGISTRYINDEX, class_http_ref);
4131 lua_setmetatable(L, -2);
4132
4133 return 1;
4134}
4135
4136/* This function creates ans returns an array of HTTP headers.
4137 * This function does not fails. It is used as wrapper with the
4138 * 2 following functions.
4139 */
4140__LJMP static int hlua_http_get_headers(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg)
4141{
4142 const char *cur_ptr, *cur_next, *p;
4143 int old_idx, cur_idx;
4144 struct hdr_idx_elem *cur_hdr;
4145 const char *hn, *hv;
4146 int hnl, hvl;
4147 int type;
4148 const char *in;
4149 char *out;
4150 int len;
4151
4152 /* Create the table. */
4153 lua_newtable(L);
4154
4155 if (!htxn->s->txn)
4156 return 1;
4157
4158 /* Build array of headers. */
4159 old_idx = 0;
4160 cur_next = msg->chn->buf->p + hdr_idx_first_pos(&htxn->s->txn->hdr_idx);
4161
4162 while (1) {
4163 cur_idx = htxn->s->txn->hdr_idx.v[old_idx].next;
4164 if (!cur_idx)
4165 break;
4166 old_idx = cur_idx;
4167
4168 cur_hdr = &htxn->s->txn->hdr_idx.v[cur_idx];
4169 cur_ptr = cur_next;
4170 cur_next = cur_ptr + cur_hdr->len + cur_hdr->cr + 1;
4171
4172 /* Now we have one full header at cur_ptr of len cur_hdr->len,
4173 * and the next header starts at cur_next. We'll check
4174 * this header in the list as well as against the default
4175 * rule.
4176 */
4177
4178 /* look for ': *'. */
4179 hn = cur_ptr;
4180 for (p = cur_ptr; p < cur_ptr + cur_hdr->len && *p != ':'; p++);
4181 if (p >= cur_ptr+cur_hdr->len)
4182 continue;
4183 hnl = p - hn;
4184 p++;
4185 while (p < cur_ptr+cur_hdr->len && ( *p == ' ' || *p == '\t' ))
4186 p++;
4187 if (p >= cur_ptr+cur_hdr->len)
4188 continue;
4189 hv = p;
4190 hvl = cur_ptr+cur_hdr->len-p;
4191
4192 /* Lowercase the key. Don't check the size of trash, it have
4193 * the size of one buffer and the input data contains in one
4194 * buffer.
4195 */
4196 out = trash.str;
4197 for (in=hn; in<hn+hnl; in++, out++)
4198 *out = tolower(*in);
4199 *out = '\0';
4200
4201 /* Check for existing entry:
4202 * assume that the table is on the top of the stack, and
4203 * push the key in the stack, the function lua_gettable()
4204 * perform the lookup.
4205 */
4206 lua_pushlstring(L, trash.str, hnl);
4207 lua_gettable(L, -2);
4208 type = lua_type(L, -1);
4209
4210 switch (type) {
4211 case LUA_TNIL:
4212 /* Table not found, create it. */
4213 lua_pop(L, 1); /* remove the nil value. */
4214 lua_pushlstring(L, trash.str, hnl); /* push the header name as key. */
4215 lua_newtable(L); /* create and push empty table. */
4216 lua_pushlstring(L, hv, hvl); /* push header value. */
4217 lua_rawseti(L, -2, 0); /* index header value (pop it). */
4218 lua_rawset(L, -3); /* index new table with header name (pop the values). */
4219 break;
4220
4221 case LUA_TTABLE:
4222 /* Entry found: push the value in the table. */
4223 len = lua_rawlen(L, -1);
4224 lua_pushlstring(L, hv, hvl); /* push header value. */
4225 lua_rawseti(L, -2, len+1); /* index header value (pop it). */
4226 lua_pop(L, 1); /* remove the table (it is stored in the main table). */
4227 break;
4228
4229 default:
4230 /* Other cases are errors. */
4231 hlua_pusherror(L, "internal error during the parsing of headers.");
4232 WILL_LJMP(lua_error(L));
4233 }
4234 }
4235
4236 return 1;
4237}
4238
4239__LJMP static int hlua_http_req_get_headers(lua_State *L)
4240{
4241 struct hlua_txn *htxn;
4242
4243 MAY_LJMP(check_args(L, 1, "req_get_headers"));
4244 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4245
4246 return hlua_http_get_headers(L, htxn, &htxn->s->txn->req);
4247}
4248
4249__LJMP static int hlua_http_res_get_headers(lua_State *L)
4250{
4251 struct hlua_txn *htxn;
4252
4253 MAY_LJMP(check_args(L, 1, "res_get_headers"));
4254 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4255
4256 return hlua_http_get_headers(L, htxn, &htxn->s->txn->rsp);
4257}
4258
4259/* This function replace full header, or just a value in
4260 * the request or in the response. It is a wrapper fir the
4261 * 4 following functions.
4262 */
4263__LJMP static inline int hlua_http_rep_hdr(lua_State *L, struct hlua_txn *htxn,
4264 struct http_msg *msg, int action)
4265{
4266 size_t name_len;
4267 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
4268 const char *reg = MAY_LJMP(luaL_checkstring(L, 3));
4269 const char *value = MAY_LJMP(luaL_checkstring(L, 4));
4270 struct my_regex re;
4271
4272 if (!regex_comp(reg, &re, 1, 1, NULL))
4273 WILL_LJMP(luaL_argerror(L, 3, "invalid regex"));
4274
4275 http_transform_header_str(htxn->s, msg, name, name_len, value, &re, action);
4276 regex_free(&re);
4277 return 0;
4278}
4279
4280__LJMP static int hlua_http_req_rep_hdr(lua_State *L)
4281{
4282 struct hlua_txn *htxn;
4283
4284 MAY_LJMP(check_args(L, 4, "req_rep_hdr"));
4285 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4286
4287 return MAY_LJMP(hlua_http_rep_hdr(L, htxn, &htxn->s->txn->req, ACT_HTTP_REPLACE_HDR));
4288}
4289
4290__LJMP static int hlua_http_res_rep_hdr(lua_State *L)
4291{
4292 struct hlua_txn *htxn;
4293
4294 MAY_LJMP(check_args(L, 4, "res_rep_hdr"));
4295 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4296
4297 return MAY_LJMP(hlua_http_rep_hdr(L, htxn, &htxn->s->txn->rsp, ACT_HTTP_REPLACE_HDR));
4298}
4299
4300__LJMP static int hlua_http_req_rep_val(lua_State *L)
4301{
4302 struct hlua_txn *htxn;
4303
4304 MAY_LJMP(check_args(L, 4, "req_rep_hdr"));
4305 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4306
4307 return MAY_LJMP(hlua_http_rep_hdr(L, htxn, &htxn->s->txn->req, ACT_HTTP_REPLACE_VAL));
4308}
4309
4310__LJMP static int hlua_http_res_rep_val(lua_State *L)
4311{
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004312 struct hlua_txn *htxn;
4313
4314 MAY_LJMP(check_args(L, 4, "res_rep_val"));
4315 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4316
Thierry FOURNIER0ea5c7f2015-08-05 19:05:19 +02004317 return MAY_LJMP(hlua_http_rep_hdr(L, htxn, &htxn->s->txn->rsp, ACT_HTTP_REPLACE_VAL));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004318}
4319
4320/* This function deletes all the occurences of an header.
4321 * It is a wrapper for the 2 following functions.
4322 */
4323__LJMP static inline int hlua_http_del_hdr(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg)
4324{
4325 size_t len;
4326 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &len));
4327 struct hdr_ctx ctx;
Willy Tarreaueee5b512015-04-03 23:46:31 +02004328 struct http_txn *txn = htxn->s->txn;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004329
4330 ctx.idx = 0;
4331 while (http_find_header2(name, len, msg->chn->buf->p, &txn->hdr_idx, &ctx))
4332 http_remove_header2(msg, &txn->hdr_idx, &ctx);
4333 return 0;
4334}
4335
4336__LJMP static int hlua_http_req_del_hdr(lua_State *L)
4337{
4338 struct hlua_txn *htxn;
4339
4340 MAY_LJMP(check_args(L, 2, "req_del_hdr"));
4341 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4342
Willy Tarreaueee5b512015-04-03 23:46:31 +02004343 return hlua_http_del_hdr(L, htxn, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004344}
4345
4346__LJMP static int hlua_http_res_del_hdr(lua_State *L)
4347{
4348 struct hlua_txn *htxn;
4349
4350 MAY_LJMP(check_args(L, 2, "req_del_hdr"));
4351 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4352
Willy Tarreaueee5b512015-04-03 23:46:31 +02004353 return hlua_http_del_hdr(L, htxn, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004354}
4355
4356/* This function adds an header. It is a wrapper used by
4357 * the 2 following functions.
4358 */
4359__LJMP static inline int hlua_http_add_hdr(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg)
4360{
4361 size_t name_len;
4362 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
4363 size_t value_len;
4364 const char *value = MAY_LJMP(luaL_checklstring(L, 3, &value_len));
4365 char *p;
4366
4367 /* Check length. */
4368 trash.len = value_len + name_len + 2;
4369 if (trash.len > trash.size)
4370 return 0;
4371
4372 /* Creates the header string. */
4373 p = trash.str;
4374 memcpy(p, name, name_len);
4375 p += name_len;
4376 *p = ':';
4377 p++;
4378 *p = ' ';
4379 p++;
4380 memcpy(p, value, value_len);
4381
Willy Tarreaueee5b512015-04-03 23:46:31 +02004382 lua_pushboolean(L, http_header_add_tail2(msg, &htxn->s->txn->hdr_idx,
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004383 trash.str, trash.len) != 0);
4384
4385 return 0;
4386}
4387
4388__LJMP static int hlua_http_req_add_hdr(lua_State *L)
4389{
4390 struct hlua_txn *htxn;
4391
4392 MAY_LJMP(check_args(L, 3, "req_add_hdr"));
4393 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4394
Willy Tarreaueee5b512015-04-03 23:46:31 +02004395 return hlua_http_add_hdr(L, htxn, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004396}
4397
4398__LJMP static int hlua_http_res_add_hdr(lua_State *L)
4399{
4400 struct hlua_txn *htxn;
4401
4402 MAY_LJMP(check_args(L, 3, "res_add_hdr"));
4403 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4404
Willy Tarreaueee5b512015-04-03 23:46:31 +02004405 return hlua_http_add_hdr(L, htxn, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004406}
4407
4408static int hlua_http_req_set_hdr(lua_State *L)
4409{
4410 struct hlua_txn *htxn;
4411
4412 MAY_LJMP(check_args(L, 3, "req_set_hdr"));
4413 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4414
Willy Tarreaueee5b512015-04-03 23:46:31 +02004415 hlua_http_del_hdr(L, htxn, &htxn->s->txn->req);
4416 return hlua_http_add_hdr(L, htxn, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004417}
4418
4419static int hlua_http_res_set_hdr(lua_State *L)
4420{
4421 struct hlua_txn *htxn;
4422
4423 MAY_LJMP(check_args(L, 3, "res_set_hdr"));
4424 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4425
Willy Tarreaueee5b512015-04-03 23:46:31 +02004426 hlua_http_del_hdr(L, htxn, &htxn->s->txn->rsp);
4427 return hlua_http_add_hdr(L, htxn, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004428}
4429
4430/* This function set the method. */
4431static int hlua_http_req_set_meth(lua_State *L)
4432{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02004433 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004434 size_t name_len;
4435 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004436
Willy Tarreau987e3fb2015-04-04 01:09:08 +02004437 lua_pushboolean(L, http_replace_req_line(0, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004438 return 1;
4439}
4440
4441/* This function set the method. */
4442static int hlua_http_req_set_path(lua_State *L)
4443{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02004444 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004445 size_t name_len;
4446 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Willy Tarreau987e3fb2015-04-04 01:09:08 +02004447 lua_pushboolean(L, http_replace_req_line(1, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004448 return 1;
4449}
4450
4451/* This function set the query-string. */
4452static int hlua_http_req_set_query(lua_State *L)
4453{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02004454 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004455 size_t name_len;
4456 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004457
4458 /* Check length. */
4459 if (name_len > trash.size - 1) {
4460 lua_pushboolean(L, 0);
4461 return 1;
4462 }
4463
4464 /* Add the mark question as prefix. */
4465 chunk_reset(&trash);
4466 trash.str[trash.len++] = '?';
4467 memcpy(trash.str + trash.len, name, name_len);
4468 trash.len += name_len;
4469
Willy Tarreau987e3fb2015-04-04 01:09:08 +02004470 lua_pushboolean(L, http_replace_req_line(2, trash.str, trash.len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004471 return 1;
4472}
4473
4474/* This function set the uri. */
4475static int hlua_http_req_set_uri(lua_State *L)
4476{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02004477 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004478 size_t name_len;
4479 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004480
Willy Tarreau987e3fb2015-04-04 01:09:08 +02004481 lua_pushboolean(L, http_replace_req_line(3, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004482 return 1;
4483}
4484
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02004485/* This function set the response code. */
4486static int hlua_http_res_set_status(lua_State *L)
4487{
4488 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4489 unsigned int code = MAY_LJMP(luaL_checkinteger(L, 2));
4490
4491 http_set_status(code, htxn->s);
4492 return 0;
4493}
4494
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004495/*
4496 *
4497 *
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004498 * Class TXN
4499 *
4500 *
4501 */
4502
4503/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02004504 * a class stream, otherwise it throws an error.
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004505 */
4506__LJMP static struct hlua_txn *hlua_checktxn(lua_State *L, int ud)
4507{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02004508 return MAY_LJMP(hlua_checkudata(L, ud, class_txn_ref));
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004509}
4510
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02004511__LJMP static int hlua_set_var(lua_State *L)
4512{
4513 struct hlua_txn *htxn;
4514 const char *name;
4515 size_t len;
4516 struct sample smp;
4517
4518 MAY_LJMP(check_args(L, 3, "set_var"));
4519
4520 /* It is useles to retrieve the stream, but this function
4521 * runs only in a stream context.
4522 */
4523 htxn = MAY_LJMP(hlua_checktxn(L, 1));
4524 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
4525
4526 /* Converts the third argument in a sample. */
4527 hlua_lua2smp(L, 3, &smp);
4528
4529 /* Store the sample in a variable. */
Willy Tarreau7560dd42016-03-10 16:28:58 +01004530 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
Willy Tarreau6204cd92016-03-10 16:33:04 +01004531 vars_set_by_name(name, len, &smp);
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02004532 return 0;
4533}
4534
4535__LJMP static int hlua_get_var(lua_State *L)
4536{
4537 struct hlua_txn *htxn;
4538 const char *name;
4539 size_t len;
4540 struct sample smp;
4541
4542 MAY_LJMP(check_args(L, 2, "get_var"));
4543
4544 /* It is useles to retrieve the stream, but this function
4545 * runs only in a stream context.
4546 */
4547 htxn = MAY_LJMP(hlua_checktxn(L, 1));
4548 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
4549
Willy Tarreau7560dd42016-03-10 16:28:58 +01004550 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
Willy Tarreau6204cd92016-03-10 16:33:04 +01004551 if (!vars_get_by_name(name, len, &smp)) {
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02004552 lua_pushnil(L);
4553 return 1;
4554 }
4555
4556 return hlua_smp2lua(L, &smp);
4557}
4558
Willy Tarreau59551662015-03-10 14:23:13 +01004559__LJMP static int hlua_set_priv(lua_State *L)
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01004560{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01004561 struct hlua *hlua;
4562
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01004563 MAY_LJMP(check_args(L, 2, "set_priv"));
4564
Willy Tarreau87b09662015-04-03 00:22:06 +02004565 /* It is useles to retrieve the stream, but this function
4566 * runs only in a stream context.
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01004567 */
4568 MAY_LJMP(hlua_checktxn(L, 1));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01004569 hlua = hlua_gethlua(L);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01004570
4571 /* Remove previous value. */
4572 if (hlua->Mref != -1)
4573 luaL_unref(L, hlua->Mref, LUA_REGISTRYINDEX);
4574
4575 /* Get and store new value. */
4576 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
4577 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
4578
4579 return 0;
4580}
4581
Willy Tarreau59551662015-03-10 14:23:13 +01004582__LJMP static int hlua_get_priv(lua_State *L)
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01004583{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01004584 struct hlua *hlua;
4585
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01004586 MAY_LJMP(check_args(L, 1, "get_priv"));
4587
Willy Tarreau87b09662015-04-03 00:22:06 +02004588 /* It is useles to retrieve the stream, but this function
4589 * runs only in a stream context.
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01004590 */
4591 MAY_LJMP(hlua_checktxn(L, 1));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01004592 hlua = hlua_gethlua(L);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01004593
4594 /* Push configuration index in the stack. */
4595 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
4596
4597 return 1;
4598}
4599
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004600/* Create stack entry containing a class TXN. This function
4601 * return 0 if the stack does not contains free slots,
4602 * otherwise it returns 1.
4603 */
Thierry FOURNIERab00df62016-07-14 11:42:37 +02004604static int hlua_txn_new(lua_State *L, struct stream *s, struct proxy *p, int dir, int flags)
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004605{
Willy Tarreaude491382015-04-06 11:04:28 +02004606 struct hlua_txn *htxn;
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004607
4608 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01004609 if (!lua_checkstack(L, 3))
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004610 return 0;
4611
4612 /* NOTE: The allocation never fails. The failure
4613 * throw an error, and the function never returns.
4614 * if the throw is not avalaible, the process is aborted.
4615 */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01004616 /* Create the object: obj[0] = userdata. */
4617 lua_newtable(L);
Willy Tarreaude491382015-04-06 11:04:28 +02004618 htxn = lua_newuserdata(L, sizeof(*htxn));
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01004619 lua_rawseti(L, -2, 0);
4620
Willy Tarreaude491382015-04-06 11:04:28 +02004621 htxn->s = s;
4622 htxn->p = p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01004623 htxn->dir = dir;
Thierry FOURNIERab00df62016-07-14 11:42:37 +02004624 htxn->flags = flags;
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004625
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01004626 /* Create the "f" field that contains a list of fetches. */
4627 lua_pushstring(L, "f");
Thierry FOURNIERca988662015-12-20 18:43:03 +01004628 if (!hlua_fetches_new(L, htxn, HLUA_F_MAY_USE_HTTP))
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01004629 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02004630 lua_rawset(L, -3);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01004631
4632 /* Create the "sf" field that contains a list of stringsafe fetches. */
4633 lua_pushstring(L, "sf");
Thierry FOURNIERca988662015-12-20 18:43:03 +01004634 if (!hlua_fetches_new(L, htxn, HLUA_F_MAY_USE_HTTP | HLUA_F_AS_STRING))
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01004635 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02004636 lua_rawset(L, -3);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01004637
Thierry FOURNIER594afe72015-03-10 23:58:30 +01004638 /* Create the "c" field that contains a list of converters. */
4639 lua_pushstring(L, "c");
Willy Tarreaude491382015-04-06 11:04:28 +02004640 if (!hlua_converters_new(L, htxn, 0))
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01004641 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02004642 lua_rawset(L, -3);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01004643
4644 /* Create the "sc" field that contains a list of stringsafe converters. */
4645 lua_pushstring(L, "sc");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01004646 if (!hlua_converters_new(L, htxn, HLUA_F_AS_STRING))
Thierry FOURNIER594afe72015-03-10 23:58:30 +01004647 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02004648 lua_rawset(L, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01004649
Thierry FOURNIER397826a2015-03-11 19:39:09 +01004650 /* Create the "req" field that contains the request channel object. */
4651 lua_pushstring(L, "req");
Willy Tarreau2a71af42015-03-10 13:51:50 +01004652 if (!hlua_channel_new(L, &s->req))
Thierry FOURNIER397826a2015-03-11 19:39:09 +01004653 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02004654 lua_rawset(L, -3);
Thierry FOURNIER397826a2015-03-11 19:39:09 +01004655
4656 /* Create the "res" field that contains the response channel object. */
4657 lua_pushstring(L, "res");
Willy Tarreau2a71af42015-03-10 13:51:50 +01004658 if (!hlua_channel_new(L, &s->res))
Thierry FOURNIER397826a2015-03-11 19:39:09 +01004659 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02004660 lua_rawset(L, -3);
Thierry FOURNIER397826a2015-03-11 19:39:09 +01004661
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004662 /* Creates the HTTP object is the current proxy allows http. */
4663 lua_pushstring(L, "http");
4664 if (p->mode == PR_MODE_HTTP) {
Willy Tarreaude491382015-04-06 11:04:28 +02004665 if (!hlua_http_new(L, htxn))
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004666 return 0;
4667 }
4668 else
4669 lua_pushnil(L);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02004670 lua_rawset(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004671
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004672 /* Pop a class sesison metatable and affect it to the userdata. */
4673 lua_rawgeti(L, LUA_REGISTRYINDEX, class_txn_ref);
4674 lua_setmetatable(L, -2);
4675
4676 return 1;
4677}
4678
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01004679__LJMP static int hlua_txn_deflog(lua_State *L)
4680{
4681 const char *msg;
4682 struct hlua_txn *htxn;
4683
4684 MAY_LJMP(check_args(L, 2, "deflog"));
4685 htxn = MAY_LJMP(hlua_checktxn(L, 1));
4686 msg = MAY_LJMP(luaL_checkstring(L, 2));
4687
4688 hlua_sendlog(htxn->s->be, htxn->s->logs.level, msg);
4689 return 0;
4690}
4691
4692__LJMP static int hlua_txn_log(lua_State *L)
4693{
4694 int level;
4695 const char *msg;
4696 struct hlua_txn *htxn;
4697
4698 MAY_LJMP(check_args(L, 3, "log"));
4699 htxn = MAY_LJMP(hlua_checktxn(L, 1));
4700 level = MAY_LJMP(luaL_checkinteger(L, 2));
4701 msg = MAY_LJMP(luaL_checkstring(L, 3));
4702
4703 if (level < 0 || level >= NB_LOG_LEVELS)
4704 WILL_LJMP(luaL_argerror(L, 1, "Invalid loglevel."));
4705
4706 hlua_sendlog(htxn->s->be, level, msg);
4707 return 0;
4708}
4709
4710__LJMP static int hlua_txn_log_debug(lua_State *L)
4711{
4712 const char *msg;
4713 struct hlua_txn *htxn;
4714
4715 MAY_LJMP(check_args(L, 2, "Debug"));
4716 htxn = MAY_LJMP(hlua_checktxn(L, 1));
4717 msg = MAY_LJMP(luaL_checkstring(L, 2));
4718 hlua_sendlog(htxn->s->be, LOG_DEBUG, msg);
4719 return 0;
4720}
4721
4722__LJMP static int hlua_txn_log_info(lua_State *L)
4723{
4724 const char *msg;
4725 struct hlua_txn *htxn;
4726
4727 MAY_LJMP(check_args(L, 2, "Info"));
4728 htxn = MAY_LJMP(hlua_checktxn(L, 1));
4729 msg = MAY_LJMP(luaL_checkstring(L, 2));
4730 hlua_sendlog(htxn->s->be, LOG_INFO, msg);
4731 return 0;
4732}
4733
4734__LJMP static int hlua_txn_log_warning(lua_State *L)
4735{
4736 const char *msg;
4737 struct hlua_txn *htxn;
4738
4739 MAY_LJMP(check_args(L, 2, "Warning"));
4740 htxn = MAY_LJMP(hlua_checktxn(L, 1));
4741 msg = MAY_LJMP(luaL_checkstring(L, 2));
4742 hlua_sendlog(htxn->s->be, LOG_WARNING, msg);
4743 return 0;
4744}
4745
4746__LJMP static int hlua_txn_log_alert(lua_State *L)
4747{
4748 const char *msg;
4749 struct hlua_txn *htxn;
4750
4751 MAY_LJMP(check_args(L, 2, "Alert"));
4752 htxn = MAY_LJMP(hlua_checktxn(L, 1));
4753 msg = MAY_LJMP(luaL_checkstring(L, 2));
4754 hlua_sendlog(htxn->s->be, LOG_ALERT, msg);
4755 return 0;
4756}
4757
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01004758__LJMP static int hlua_txn_set_loglevel(lua_State *L)
4759{
4760 struct hlua_txn *htxn;
4761 int ll;
4762
4763 MAY_LJMP(check_args(L, 2, "set_loglevel"));
4764 htxn = MAY_LJMP(hlua_checktxn(L, 1));
4765 ll = MAY_LJMP(luaL_checkinteger(L, 2));
4766
4767 if (ll < 0 || ll > 7)
4768 WILL_LJMP(luaL_argerror(L, 2, "Bad log level. It must be between 0 and 7"));
4769
4770 htxn->s->logs.level = ll;
4771 return 0;
4772}
4773
4774__LJMP static int hlua_txn_set_tos(lua_State *L)
4775{
4776 struct hlua_txn *htxn;
4777 struct connection *cli_conn;
4778 int tos;
4779
4780 MAY_LJMP(check_args(L, 2, "set_tos"));
4781 htxn = MAY_LJMP(hlua_checktxn(L, 1));
4782 tos = MAY_LJMP(luaL_checkinteger(L, 2));
4783
Willy Tarreau9ad7bd42015-04-03 19:19:59 +02004784 if ((cli_conn = objt_conn(htxn->s->sess->origin)) && conn_ctrl_ready(cli_conn))
Vincent Bernat6e615892016-05-18 16:17:44 +02004785 inet_set_tos(cli_conn->t.sock.fd, &cli_conn->addr.from, tos);
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01004786
4787 return 0;
4788}
4789
4790__LJMP static int hlua_txn_set_mark(lua_State *L)
4791{
4792#ifdef SO_MARK
4793 struct hlua_txn *htxn;
4794 struct connection *cli_conn;
4795 int mark;
4796
4797 MAY_LJMP(check_args(L, 2, "set_mark"));
4798 htxn = MAY_LJMP(hlua_checktxn(L, 1));
4799 mark = MAY_LJMP(luaL_checkinteger(L, 2));
4800
Willy Tarreau9ad7bd42015-04-03 19:19:59 +02004801 if ((cli_conn = objt_conn(htxn->s->sess->origin)) && conn_ctrl_ready(cli_conn))
Willy Tarreau07081fe2015-04-06 10:59:20 +02004802 setsockopt(cli_conn->t.sock.fd, SOL_SOCKET, SO_MARK, &mark, sizeof(mark));
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01004803#endif
4804 return 0;
4805}
4806
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01004807/* This function is an Lua binding that send pending data
4808 * to the client, and close the stream interface.
4809 */
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02004810__LJMP static int hlua_txn_done(lua_State *L)
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01004811{
Willy Tarreaub2ccb562015-04-06 11:11:15 +02004812 struct hlua_txn *htxn;
Thierry FOURNIER9bd52d42016-07-14 11:45:33 +02004813 struct hlua *hlua;
Willy Tarreau81389672015-03-10 12:03:52 +01004814 struct channel *ic, *oc;
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01004815
Willy Tarreau80f5fae2015-02-27 16:38:20 +01004816 MAY_LJMP(check_args(L, 1, "close"));
Willy Tarreaub2ccb562015-04-06 11:11:15 +02004817 htxn = MAY_LJMP(hlua_checktxn(L, 1));
Thierry FOURNIER9bd52d42016-07-14 11:45:33 +02004818 hlua = hlua_gethlua(L);
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01004819
Thierry FOURNIERab00df62016-07-14 11:42:37 +02004820 /* If the flags NOTERM is set, we cannot terminate the http
4821 * session, so we just end the execution of the current
4822 * lua code.
4823 */
4824 if (htxn->flags & HLUA_TXN_NOTERM) {
4825 WILL_LJMP(hlua_done(L));
4826 return 0;
4827 }
4828
Willy Tarreaub2ccb562015-04-06 11:11:15 +02004829 ic = &htxn->s->req;
4830 oc = &htxn->s->res;
Willy Tarreau81389672015-03-10 12:03:52 +01004831
Willy Tarreau630ef452015-08-28 10:06:15 +02004832 if (htxn->s->txn) {
4833 /* HTTP mode, let's stay in sync with the stream */
4834 bi_fast_delete(ic->buf, htxn->s->txn->req.sov);
4835 htxn->s->txn->req.next -= htxn->s->txn->req.sov;
4836 htxn->s->txn->req.sov = 0;
4837 ic->analysers &= AN_REQ_HTTP_XFER_BODY;
4838 oc->analysers = AN_RES_HTTP_XFER_BODY;
4839 htxn->s->txn->req.msg_state = HTTP_MSG_CLOSED;
4840 htxn->s->txn->rsp.msg_state = HTTP_MSG_DONE;
4841
Willy Tarreau630ef452015-08-28 10:06:15 +02004842 /* Note that if we want to support keep-alive, we need
4843 * to bypass the close/shutr_now calls below, but that
4844 * may only be done if the HTTP request was already
4845 * processed and the connection header is known (ie
4846 * not during TCP rules).
4847 */
4848 }
4849
Thierry FOURNIER10ec2142015-08-24 17:23:45 +02004850 channel_auto_read(ic);
Willy Tarreau81389672015-03-10 12:03:52 +01004851 channel_abort(ic);
4852 channel_auto_close(ic);
4853 channel_erase(ic);
Thierry FOURNIER10ec2142015-08-24 17:23:45 +02004854
4855 oc->wex = tick_add_ifset(now_ms, oc->wto);
Willy Tarreau81389672015-03-10 12:03:52 +01004856 channel_auto_read(oc);
4857 channel_auto_close(oc);
4858 channel_shutr_now(oc);
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01004859
Willy Tarreau0458b082015-08-28 09:40:04 +02004860 ic->analysers = 0;
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02004861
Thierry FOURNIER9bd52d42016-07-14 11:45:33 +02004862 hlua->flags |= HLUA_STOP;
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02004863 WILL_LJMP(hlua_done(L));
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01004864 return 0;
4865}
4866
4867__LJMP static int hlua_log(lua_State *L)
4868{
4869 int level;
4870 const char *msg;
4871
4872 MAY_LJMP(check_args(L, 2, "log"));
4873 level = MAY_LJMP(luaL_checkinteger(L, 1));
4874 msg = MAY_LJMP(luaL_checkstring(L, 2));
4875
4876 if (level < 0 || level >= NB_LOG_LEVELS)
4877 WILL_LJMP(luaL_argerror(L, 1, "Invalid loglevel."));
4878
4879 hlua_sendlog(NULL, level, msg);
4880 return 0;
4881}
4882
4883__LJMP static int hlua_log_debug(lua_State *L)
4884{
4885 const char *msg;
4886
4887 MAY_LJMP(check_args(L, 1, "debug"));
4888 msg = MAY_LJMP(luaL_checkstring(L, 1));
4889 hlua_sendlog(NULL, LOG_DEBUG, msg);
4890 return 0;
4891}
4892
4893__LJMP static int hlua_log_info(lua_State *L)
4894{
4895 const char *msg;
4896
4897 MAY_LJMP(check_args(L, 1, "info"));
4898 msg = MAY_LJMP(luaL_checkstring(L, 1));
4899 hlua_sendlog(NULL, LOG_INFO, msg);
4900 return 0;
4901}
4902
4903__LJMP static int hlua_log_warning(lua_State *L)
4904{
4905 const char *msg;
4906
4907 MAY_LJMP(check_args(L, 1, "warning"));
4908 msg = MAY_LJMP(luaL_checkstring(L, 1));
4909 hlua_sendlog(NULL, LOG_WARNING, msg);
4910 return 0;
4911}
4912
4913__LJMP static int hlua_log_alert(lua_State *L)
4914{
4915 const char *msg;
4916
4917 MAY_LJMP(check_args(L, 1, "alert"));
4918 msg = MAY_LJMP(luaL_checkstring(L, 1));
4919 hlua_sendlog(NULL, LOG_ALERT, msg);
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01004920 return 0;
4921}
4922
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01004923__LJMP static int hlua_sleep_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01004924{
4925 int wakeup_ms = lua_tointeger(L, -1);
4926 if (now_ms < wakeup_ms)
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01004927 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01004928 return 0;
4929}
4930
4931__LJMP static int hlua_sleep(lua_State *L)
4932{
4933 unsigned int delay;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01004934 unsigned int wakeup_ms;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01004935
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01004936 MAY_LJMP(check_args(L, 1, "sleep"));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01004937
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01004938 delay = MAY_LJMP(luaL_checkinteger(L, 1)) * 1000;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01004939 wakeup_ms = tick_add(now_ms, delay);
4940 lua_pushinteger(L, wakeup_ms);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01004941
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01004942 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
4943 return 0;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01004944}
4945
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01004946__LJMP static int hlua_msleep(lua_State *L)
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01004947{
4948 unsigned int delay;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01004949 unsigned int wakeup_ms;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01004950
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01004951 MAY_LJMP(check_args(L, 1, "msleep"));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01004952
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01004953 delay = MAY_LJMP(luaL_checkinteger(L, 1));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01004954 wakeup_ms = tick_add(now_ms, delay);
4955 lua_pushinteger(L, wakeup_ms);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01004956
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01004957 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
4958 return 0;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01004959}
4960
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01004961/* This functionis an LUA binding. it permits to give back
4962 * the hand at the HAProxy scheduler. It is used when the
4963 * LUA processing consumes a lot of time.
4964 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01004965__LJMP static int hlua_yield_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01004966{
4967 return 0;
4968}
4969
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01004970__LJMP static int hlua_yield(lua_State *L)
4971{
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01004972 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_yield_yield, TICK_ETERNITY, HLUA_CTRLYIELD));
4973 return 0;
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01004974}
4975
Thierry FOURNIER37196f42015-02-16 19:34:56 +01004976/* This function change the nice of the currently executed
4977 * task. It is used set low or high priority at the current
4978 * task.
4979 */
Willy Tarreau59551662015-03-10 14:23:13 +01004980__LJMP static int hlua_set_nice(lua_State *L)
Thierry FOURNIER37196f42015-02-16 19:34:56 +01004981{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01004982 struct hlua *hlua;
4983 int nice;
Thierry FOURNIER37196f42015-02-16 19:34:56 +01004984
Willy Tarreau80f5fae2015-02-27 16:38:20 +01004985 MAY_LJMP(check_args(L, 1, "set_nice"));
4986 hlua = hlua_gethlua(L);
4987 nice = MAY_LJMP(luaL_checkinteger(L, 1));
Thierry FOURNIER37196f42015-02-16 19:34:56 +01004988
4989 /* If he task is not set, I'm in a start mode. */
4990 if (!hlua || !hlua->task)
4991 return 0;
4992
4993 if (nice < -1024)
4994 nice = -1024;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01004995 else if (nice > 1024)
Thierry FOURNIER37196f42015-02-16 19:34:56 +01004996 nice = 1024;
4997
4998 hlua->task->nice = nice;
4999 return 0;
5000}
5001
Thierry FOURNIER24f33532015-01-23 12:13:00 +01005002/* This function is used as a calback of a task. It is called by the
5003 * HAProxy task subsystem when the task is awaked. The LUA runtime can
5004 * return an E_AGAIN signal, the emmiter of this signal must set a
5005 * signal to wake the task.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005006 *
5007 * Task wrapper are longjmp safe because the only one Lua code
5008 * executed is the safe hlua_ctx_resume();
Thierry FOURNIER24f33532015-01-23 12:13:00 +01005009 */
5010static struct task *hlua_process_task(struct task *task)
5011{
5012 struct hlua *hlua = task->context;
5013 enum hlua_exec status;
5014
5015 /* We need to remove the task from the wait queue before executing
5016 * the Lua code because we don't know if it needs to wait for
5017 * another timer or not in the case of E_AGAIN.
5018 */
5019 task_delete(task);
5020
Thierry FOURNIERbd413492015-03-03 16:52:26 +01005021 /* If it is the first call to the task, we must initialize the
5022 * execution timeouts.
5023 */
5024 if (!HLUA_IS_RUNNING(hlua))
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02005025 hlua->max_time = hlua_timeout_task;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01005026
Thierry FOURNIER24f33532015-01-23 12:13:00 +01005027 /* Execute the Lua code. */
5028 status = hlua_ctx_resume(hlua, 1);
5029
5030 switch (status) {
5031 /* finished or yield */
5032 case HLUA_E_OK:
5033 hlua_ctx_destroy(hlua);
5034 task_delete(task);
5035 task_free(task);
5036 break;
5037
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01005038 case HLUA_E_AGAIN: /* co process or timeout wake me later. */
5039 if (hlua->wake_time != TICK_ETERNITY)
5040 task_schedule(task, hlua->wake_time);
Thierry FOURNIER24f33532015-01-23 12:13:00 +01005041 break;
5042
5043 /* finished with error. */
5044 case HLUA_E_ERRMSG:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005045 SEND_ERR(NULL, "Lua task: %s.\n", lua_tostring(hlua->T, -1));
Thierry FOURNIER24f33532015-01-23 12:13:00 +01005046 hlua_ctx_destroy(hlua);
5047 task_delete(task);
5048 task_free(task);
5049 break;
5050
5051 case HLUA_E_ERR:
5052 default:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005053 SEND_ERR(NULL, "Lua task: unknown error.\n");
Thierry FOURNIER24f33532015-01-23 12:13:00 +01005054 hlua_ctx_destroy(hlua);
5055 task_delete(task);
5056 task_free(task);
5057 break;
5058 }
5059 return NULL;
5060}
5061
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01005062/* This function is an LUA binding that register LUA function to be
5063 * executed after the HAProxy configuration parsing and before the
5064 * HAProxy scheduler starts. This function expect only one LUA
5065 * argument that is a function. This function returns nothing, but
5066 * throws if an error is encountered.
5067 */
5068__LJMP static int hlua_register_init(lua_State *L)
5069{
5070 struct hlua_init_function *init;
5071 int ref;
5072
5073 MAY_LJMP(check_args(L, 1, "register_init"));
5074
5075 ref = MAY_LJMP(hlua_checkfunction(L, 1));
5076
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02005077 init = calloc(1, sizeof(*init));
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01005078 if (!init)
5079 WILL_LJMP(luaL_error(L, "lua out of memory error."));
5080
5081 init->function_ref = ref;
5082 LIST_ADDQ(&hlua_init_functions, &init->l);
5083 return 0;
5084}
5085
Thierry FOURNIER24f33532015-01-23 12:13:00 +01005086/* This functio is an LUA binding. It permits to register a task
5087 * executed in parallel of the main HAroxy activity. The task is
5088 * created and it is set in the HAProxy scheduler. It can be called
5089 * from the "init" section, "post init" or during the runtime.
5090 *
5091 * Lua prototype:
5092 *
5093 * <none> core.register_task(<function>)
5094 */
5095static int hlua_register_task(lua_State *L)
5096{
5097 struct hlua *hlua;
5098 struct task *task;
5099 int ref;
5100
5101 MAY_LJMP(check_args(L, 1, "register_task"));
5102
5103 ref = MAY_LJMP(hlua_checkfunction(L, 1));
5104
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02005105 hlua = calloc(1, sizeof(*hlua));
Thierry FOURNIER24f33532015-01-23 12:13:00 +01005106 if (!hlua)
5107 WILL_LJMP(luaL_error(L, "lua out of memory error."));
5108
5109 task = task_new();
5110 task->context = hlua;
5111 task->process = hlua_process_task;
5112
5113 if (!hlua_ctx_init(hlua, task))
5114 WILL_LJMP(luaL_error(L, "lua out of memory error."));
5115
5116 /* Restore the function in the stack. */
5117 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ref);
5118 hlua->nargs = 0;
5119
5120 /* Schedule task. */
5121 task_schedule(task, now_ms);
5122
5123 return 0;
5124}
5125
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005126/* Wrapper called by HAProxy to execute an LUA converter. This wrapper
5127 * doesn't allow "yield" functions because the HAProxy engine cannot
5128 * resume converters.
5129 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005130static int hlua_sample_conv_wrapper(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005131{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02005132 struct hlua_function *fcn = private;
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005133 struct stream *stream = smp->strm;
Thierry Fournierfd107a22016-02-19 19:57:23 +01005134 const char *error;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005135
Willy Tarreaube508f12016-03-10 11:47:01 +01005136 if (!stream)
5137 return 0;
5138
Willy Tarreau87b09662015-04-03 00:22:06 +02005139 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01005140 * Lua context can be not initialized. This behavior
5141 * permits to save performances because a systematic
5142 * Lua initialization cause 5% performances loss.
5143 */
Willy Tarreau87b09662015-04-03 00:22:06 +02005144 if (!stream->hlua.T && !hlua_ctx_init(&stream->hlua, stream->task)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005145 SEND_ERR(stream->be, "Lua converter '%s': can't initialize Lua context.\n", fcn->name);
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01005146 return 0;
5147 }
5148
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005149 /* If it is the first run, initialize the data for the call. */
Willy Tarreau87b09662015-04-03 00:22:06 +02005150 if (!HLUA_IS_RUNNING(&stream->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005151
5152 /* The following Lua calls can fail. */
5153 if (!SET_SAFE_LJMP(stream->hlua.T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01005154 if (lua_type(stream->hlua.T, -1) == LUA_TSTRING)
5155 error = lua_tostring(stream->hlua.T, -1);
5156 else
5157 error = "critical error";
5158 SEND_ERR(stream->be, "Lua converter '%s': %s.\n", fcn->name, error);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005159 return 0;
5160 }
5161
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005162 /* Check stack available size. */
Willy Tarreau87b09662015-04-03 00:22:06 +02005163 if (!lua_checkstack(stream->hlua.T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005164 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry FOURNIER10e5bc72015-09-25 23:51:34 +02005165 RESET_SAFE_LJMP(stream->hlua.T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005166 return 0;
5167 }
5168
5169 /* Restore the function in the stack. */
Willy Tarreau87b09662015-04-03 00:22:06 +02005170 lua_rawgeti(stream->hlua.T, LUA_REGISTRYINDEX, fcn->function_ref);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005171
5172 /* convert input sample and pust-it in the stack. */
Willy Tarreau87b09662015-04-03 00:22:06 +02005173 if (!lua_checkstack(stream->hlua.T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005174 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry FOURNIER10e5bc72015-09-25 23:51:34 +02005175 RESET_SAFE_LJMP(stream->hlua.T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005176 return 0;
5177 }
Willy Tarreau87b09662015-04-03 00:22:06 +02005178 hlua_smp2lua(stream->hlua.T, smp);
Thierry Fournier4a53bfd2016-05-27 16:35:01 +02005179 stream->hlua.nargs = 1;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005180
5181 /* push keywords in the stack. */
5182 if (arg_p) {
5183 for (; arg_p->type != ARGT_STOP; arg_p++) {
Willy Tarreau87b09662015-04-03 00:22:06 +02005184 if (!lua_checkstack(stream->hlua.T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005185 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry FOURNIER10e5bc72015-09-25 23:51:34 +02005186 RESET_SAFE_LJMP(stream->hlua.T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005187 return 0;
5188 }
Willy Tarreau87b09662015-04-03 00:22:06 +02005189 hlua_arg2lua(stream->hlua.T, arg_p);
5190 stream->hlua.nargs++;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005191 }
5192 }
5193
Thierry FOURNIERbd413492015-03-03 16:52:26 +01005194 /* We must initialize the execution timeouts. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02005195 stream->hlua.max_time = hlua_timeout_session;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01005196
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005197 /* At this point the execution is safe. */
5198 RESET_SAFE_LJMP(stream->hlua.T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005199 }
5200
5201 /* Execute the function. */
Willy Tarreau87b09662015-04-03 00:22:06 +02005202 switch (hlua_ctx_resume(&stream->hlua, 0)) {
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005203 /* finished. */
5204 case HLUA_E_OK:
5205 /* Convert the returned value in sample. */
Willy Tarreau87b09662015-04-03 00:22:06 +02005206 hlua_lua2smp(stream->hlua.T, -1, smp);
5207 lua_pop(stream->hlua.T, 1);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005208 return 1;
5209
5210 /* yield. */
5211 case HLUA_E_AGAIN:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005212 SEND_ERR(stream->be, "Lua converter '%s': cannot use yielded functions.\n", fcn->name);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005213 return 0;
5214
5215 /* finished with error. */
5216 case HLUA_E_ERRMSG:
5217 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005218 SEND_ERR(stream->be, "Lua converter '%s': %s.\n",
5219 fcn->name, lua_tostring(stream->hlua.T, -1));
Willy Tarreau87b09662015-04-03 00:22:06 +02005220 lua_pop(stream->hlua.T, 1);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005221 return 0;
5222
5223 case HLUA_E_ERR:
5224 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005225 SEND_ERR(stream->be, "Lua converter '%s' returns an unknown error.\n", fcn->name);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005226
5227 default:
5228 return 0;
5229 }
5230}
5231
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005232/* Wrapper called by HAProxy to execute a sample-fetch. this wrapper
5233 * doesn't allow "yield" functions because the HAProxy engine cannot
Willy Tarreaube508f12016-03-10 11:47:01 +01005234 * resume sample-fetches. This function will be called by the sample
5235 * fetch engine to call lua-based fetch operations.
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005236 */
Thierry FOURNIER0786d052015-05-11 15:42:45 +02005237static int hlua_sample_fetch_wrapper(const struct arg *arg_p, struct sample *smp,
5238 const char *kw, void *private)
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005239{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02005240 struct hlua_function *fcn = private;
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005241 struct stream *stream = smp->strm;
Thierry Fournierfd107a22016-02-19 19:57:23 +01005242 const char *error;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005243
Willy Tarreaube508f12016-03-10 11:47:01 +01005244 if (!stream)
5245 return 0;
5246
Willy Tarreau87b09662015-04-03 00:22:06 +02005247 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01005248 * Lua context can be not initialized. This behavior
5249 * permits to save performances because a systematic
5250 * Lua initialization cause 5% performances loss.
5251 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005252 if (!stream->hlua.T && !hlua_ctx_init(&stream->hlua, stream->task)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005253 SEND_ERR(stream->be, "Lua sample-fetch '%s': can't initialize Lua context.\n", fcn->name);
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01005254 return 0;
5255 }
5256
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005257 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005258 if (!HLUA_IS_RUNNING(&stream->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005259
5260 /* The following Lua calls can fail. */
5261 if (!SET_SAFE_LJMP(stream->hlua.T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01005262 if (lua_type(stream->hlua.T, -1) == LUA_TSTRING)
5263 error = lua_tostring(stream->hlua.T, -1);
5264 else
5265 error = "critical error";
5266 SEND_ERR(smp->px, "Lua sample-fetch '%s': %s.\n", fcn->name, error);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005267 return 0;
5268 }
5269
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005270 /* Check stack available size. */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005271 if (!lua_checkstack(stream->hlua.T, 2)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005272 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry FOURNIER10e5bc72015-09-25 23:51:34 +02005273 RESET_SAFE_LJMP(stream->hlua.T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005274 return 0;
5275 }
5276
5277 /* Restore the function in the stack. */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005278 lua_rawgeti(stream->hlua.T, LUA_REGISTRYINDEX, fcn->function_ref);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005279
5280 /* push arguments in the stack. */
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005281 if (!hlua_txn_new(stream->hlua.T, stream, smp->px, smp->opt & SMP_OPT_DIR,
5282 HLUA_TXN_NOTERM)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005283 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry FOURNIER10e5bc72015-09-25 23:51:34 +02005284 RESET_SAFE_LJMP(stream->hlua.T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005285 return 0;
5286 }
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005287 stream->hlua.nargs = 1;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005288
5289 /* push keywords in the stack. */
5290 for (; arg_p && arg_p->type != ARGT_STOP; arg_p++) {
5291 /* Check stack available size. */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005292 if (!lua_checkstack(stream->hlua.T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005293 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry FOURNIER10e5bc72015-09-25 23:51:34 +02005294 RESET_SAFE_LJMP(stream->hlua.T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005295 return 0;
5296 }
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005297 if (!lua_checkstack(stream->hlua.T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005298 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry FOURNIER10e5bc72015-09-25 23:51:34 +02005299 RESET_SAFE_LJMP(stream->hlua.T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005300 return 0;
5301 }
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005302 hlua_arg2lua(stream->hlua.T, arg_p);
5303 stream->hlua.nargs++;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005304 }
5305
Thierry FOURNIERbd413492015-03-03 16:52:26 +01005306 /* We must initialize the execution timeouts. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02005307 stream->hlua.max_time = hlua_timeout_session;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01005308
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005309 /* At this point the execution is safe. */
5310 RESET_SAFE_LJMP(stream->hlua.T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005311 }
5312
5313 /* Execute the function. */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005314 switch (hlua_ctx_resume(&stream->hlua, 0)) {
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005315 /* finished. */
5316 case HLUA_E_OK:
Thierry FOURNIER26a7aac2015-10-13 14:25:11 +02005317 if (!hlua_check_proto(stream, (smp->opt & SMP_OPT_DIR) == SMP_OPT_DIR_RES))
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02005318 return 0;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005319 /* Convert the returned value in sample. */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005320 hlua_lua2smp(stream->hlua.T, -1, smp);
5321 lua_pop(stream->hlua.T, 1);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005322
5323 /* Set the end of execution flag. */
5324 smp->flags &= ~SMP_F_MAY_CHANGE;
5325 return 1;
5326
5327 /* yield. */
5328 case HLUA_E_AGAIN:
Thierry FOURNIER26a7aac2015-10-13 14:25:11 +02005329 hlua_check_proto(stream, (smp->opt & SMP_OPT_DIR) == SMP_OPT_DIR_RES);
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005330 SEND_ERR(smp->px, "Lua sample-fetch '%s': cannot use yielded functions.\n", fcn->name);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005331 return 0;
5332
5333 /* finished with error. */
5334 case HLUA_E_ERRMSG:
Thierry FOURNIER26a7aac2015-10-13 14:25:11 +02005335 hlua_check_proto(stream, (smp->opt & SMP_OPT_DIR) == SMP_OPT_DIR_RES);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005336 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005337 SEND_ERR(smp->px, "Lua sample-fetch '%s': %s.\n",
5338 fcn->name, lua_tostring(stream->hlua.T, -1));
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005339 lua_pop(stream->hlua.T, 1);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005340 return 0;
5341
5342 case HLUA_E_ERR:
Thierry FOURNIER26a7aac2015-10-13 14:25:11 +02005343 hlua_check_proto(stream, (smp->opt & SMP_OPT_DIR) == SMP_OPT_DIR_RES);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005344 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005345 SEND_ERR(smp->px, "Lua sample-fetch '%s' returns an unknown error.\n", fcn->name);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005346
5347 default:
5348 return 0;
5349 }
5350}
5351
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005352/* This function is an LUA binding used for registering
5353 * "sample-conv" functions. It expects a converter name used
5354 * in the haproxy configuration file, and an LUA function.
5355 */
5356__LJMP static int hlua_register_converters(lua_State *L)
5357{
5358 struct sample_conv_kw_list *sck;
5359 const char *name;
5360 int ref;
5361 int len;
5362 struct hlua_function *fcn;
5363
5364 MAY_LJMP(check_args(L, 2, "register_converters"));
5365
5366 /* First argument : converter name. */
5367 name = MAY_LJMP(luaL_checkstring(L, 1));
5368
5369 /* Second argument : lua function. */
5370 ref = MAY_LJMP(hlua_checkfunction(L, 2));
5371
5372 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02005373 sck = calloc(1, sizeof(*sck) + sizeof(struct sample_conv) * 2);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005374 if (!sck)
5375 WILL_LJMP(luaL_error(L, "lua out of memory error."));
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02005376 fcn = calloc(1, sizeof(*fcn));
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005377 if (!fcn)
5378 WILL_LJMP(luaL_error(L, "lua out of memory error."));
5379
5380 /* Fill fcn. */
5381 fcn->name = strdup(name);
5382 if (!fcn->name)
5383 WILL_LJMP(luaL_error(L, "lua out of memory error."));
5384 fcn->function_ref = ref;
5385
5386 /* List head */
5387 sck->list.n = sck->list.p = NULL;
5388
5389 /* converter keyword. */
5390 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02005391 sck->kw[0].kw = calloc(1, len);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005392 if (!sck->kw[0].kw)
5393 WILL_LJMP(luaL_error(L, "lua out of memory error."));
5394
5395 snprintf((char *)sck->kw[0].kw, len, "lua.%s", name);
5396 sck->kw[0].process = hlua_sample_conv_wrapper;
David Carlier0c437f42016-04-27 16:21:56 +01005397 sck->kw[0].arg_mask = ARG12(0,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005398 sck->kw[0].val_args = NULL;
5399 sck->kw[0].in_type = SMP_T_STR;
5400 sck->kw[0].out_type = SMP_T_STR;
5401 sck->kw[0].private = fcn;
5402
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005403 /* Register this new converter */
5404 sample_register_convs(sck);
5405
5406 return 0;
5407}
5408
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005409/* This fucntion is an LUA binding used for registering
5410 * "sample-fetch" functions. It expects a converter name used
5411 * in the haproxy configuration file, and an LUA function.
5412 */
5413__LJMP static int hlua_register_fetches(lua_State *L)
5414{
5415 const char *name;
5416 int ref;
5417 int len;
5418 struct sample_fetch_kw_list *sfk;
5419 struct hlua_function *fcn;
5420
5421 MAY_LJMP(check_args(L, 2, "register_fetches"));
5422
5423 /* First argument : sample-fetch name. */
5424 name = MAY_LJMP(luaL_checkstring(L, 1));
5425
5426 /* Second argument : lua function. */
5427 ref = MAY_LJMP(hlua_checkfunction(L, 2));
5428
5429 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02005430 sfk = calloc(1, sizeof(*sfk) + sizeof(struct sample_fetch) * 2);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005431 if (!sfk)
5432 WILL_LJMP(luaL_error(L, "lua out of memory error."));
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02005433 fcn = calloc(1, sizeof(*fcn));
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005434 if (!fcn)
5435 WILL_LJMP(luaL_error(L, "lua out of memory error."));
5436
5437 /* Fill fcn. */
5438 fcn->name = strdup(name);
5439 if (!fcn->name)
5440 WILL_LJMP(luaL_error(L, "lua out of memory error."));
5441 fcn->function_ref = ref;
5442
5443 /* List head */
5444 sfk->list.n = sfk->list.p = NULL;
5445
5446 /* sample-fetch keyword. */
5447 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02005448 sfk->kw[0].kw = calloc(1, len);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005449 if (!sfk->kw[0].kw)
5450 return luaL_error(L, "lua out of memory error.");
5451
5452 snprintf((char *)sfk->kw[0].kw, len, "lua.%s", name);
5453 sfk->kw[0].process = hlua_sample_fetch_wrapper;
David Carlier0c437f42016-04-27 16:21:56 +01005454 sfk->kw[0].arg_mask = ARG12(0,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005455 sfk->kw[0].val_args = NULL;
5456 sfk->kw[0].out_type = SMP_T_STR;
5457 sfk->kw[0].use = SMP_USE_HTTP_ANY;
5458 sfk->kw[0].val = 0;
5459 sfk->kw[0].private = fcn;
5460
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005461 /* Register this new fetch. */
5462 sample_register_fetches(sfk);
5463
5464 return 0;
5465}
5466
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005467/* This function is a wrapper to execute each LUA function declared
5468 * as an action wrapper during the initialisation period. This function
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005469 * return ACT_RET_CONT if the processing is finished (with or without
5470 * error) and return ACT_RET_YIELD if the function must be called again
5471 * because the LUA returns a yield.
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005472 */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005473static enum act_return hlua_action(struct act_rule *rule, struct proxy *px,
Willy Tarreau658b85b2015-09-27 10:00:49 +02005474 struct session *sess, struct stream *s, int flags)
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005475{
5476 char **arg;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005477 unsigned int analyzer;
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02005478 int dir;
Thierry Fournierfd107a22016-02-19 19:57:23 +01005479 const char *error;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005480
5481 switch (rule->from) {
Thierry FOURNIER6e01f382015-11-02 09:52:54 +01005482 case ACT_F_TCP_REQ_CNT: analyzer = AN_REQ_INSPECT_FE ; dir = SMP_OPT_DIR_REQ; break;
5483 case ACT_F_TCP_RES_CNT: analyzer = AN_RES_INSPECT ; dir = SMP_OPT_DIR_RES; break;
5484 case ACT_F_HTTP_REQ: analyzer = AN_REQ_HTTP_PROCESS_FE; dir = SMP_OPT_DIR_REQ; break;
5485 case ACT_F_HTTP_RES: analyzer = AN_RES_HTTP_PROCESS_BE; dir = SMP_OPT_DIR_RES; break;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005486 default:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005487 SEND_ERR(px, "Lua: internal error while execute action.\n");
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005488 return ACT_RET_CONT;
5489 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005490
Willy Tarreau87b09662015-04-03 00:22:06 +02005491 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01005492 * Lua context can be not initialized. This behavior
5493 * permits to save performances because a systematic
5494 * Lua initialization cause 5% performances loss.
5495 */
5496 if (!s->hlua.T && !hlua_ctx_init(&s->hlua, s->task)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005497 SEND_ERR(px, "Lua action '%s': can't initialize Lua context.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005498 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02005499 return ACT_RET_CONT;
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01005500 }
5501
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005502 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01005503 if (!HLUA_IS_RUNNING(&s->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005504
5505 /* The following Lua calls can fail. */
5506 if (!SET_SAFE_LJMP(s->hlua.T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01005507 if (lua_type(s->hlua.T, -1) == LUA_TSTRING)
5508 error = lua_tostring(s->hlua.T, -1);
5509 else
5510 error = "critical error";
5511 SEND_ERR(px, "Lua function '%s': %s.\n",
5512 rule->arg.hlua_rule->fcn.name, error);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005513 return ACT_RET_CONT;
5514 }
5515
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005516 /* Check stack available size. */
5517 if (!lua_checkstack(s->hlua.T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005518 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005519 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER10e5bc72015-09-25 23:51:34 +02005520 RESET_SAFE_LJMP(s->hlua.T);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02005521 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005522 }
5523
5524 /* Restore the function in the stack. */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005525 lua_rawgeti(s->hlua.T, LUA_REGISTRYINDEX, rule->arg.hlua_rule->fcn.function_ref);
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005526
Willy Tarreau87b09662015-04-03 00:22:06 +02005527 /* Create and and push object stream in the stack. */
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005528 if (!hlua_txn_new(s->hlua.T, s, px, dir, 0)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005529 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005530 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER10e5bc72015-09-25 23:51:34 +02005531 RESET_SAFE_LJMP(s->hlua.T);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02005532 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005533 }
5534 s->hlua.nargs = 1;
5535
5536 /* push keywords in the stack. */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005537 for (arg = rule->arg.hlua_rule->args; arg && *arg; arg++) {
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005538 if (!lua_checkstack(s->hlua.T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005539 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005540 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER10e5bc72015-09-25 23:51:34 +02005541 RESET_SAFE_LJMP(s->hlua.T);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02005542 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005543 }
5544 lua_pushstring(s->hlua.T, *arg);
5545 s->hlua.nargs++;
5546 }
5547
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005548 /* Now the execution is safe. */
5549 RESET_SAFE_LJMP(s->hlua.T);
5550
Thierry FOURNIERbd413492015-03-03 16:52:26 +01005551 /* We must initialize the execution timeouts. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02005552 s->hlua.max_time = hlua_timeout_session;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005553 }
5554
5555 /* Execute the function. */
Willy Tarreau528192d2015-09-27 10:48:01 +02005556 switch (hlua_ctx_resume(&s->hlua, !(flags & ACT_FLAG_FINAL))) {
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005557 /* finished. */
5558 case HLUA_E_OK:
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02005559 if (!hlua_check_proto(s, dir))
5560 return ACT_RET_ERR;
Thierry FOURNIER9bd52d42016-07-14 11:45:33 +02005561 if (s->hlua.flags & HLUA_STOP)
5562 return ACT_RET_STOP;
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02005563 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005564
5565 /* yield. */
5566 case HLUA_E_AGAIN:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01005567 /* Set timeout in the required channel. */
5568 if (s->hlua.wake_time != TICK_ETERNITY) {
5569 if (analyzer & (AN_REQ_INSPECT_FE|AN_REQ_HTTP_PROCESS_FE))
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01005570 s->req.analyse_exp = s->hlua.wake_time;
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01005571 else if (analyzer & (AN_RES_INSPECT|AN_RES_HTTP_PROCESS_BE))
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01005572 s->res.analyse_exp = s->hlua.wake_time;
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01005573 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005574 /* Some actions can be wake up when a "write" event
5575 * is detected on a response channel. This is useful
5576 * only for actions targetted on the requests.
5577 */
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01005578 if (HLUA_IS_WAKERESWR(&s->hlua)) {
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01005579 s->res.flags |= CF_WAKE_WRITE;
Willy Tarreau76bd97f2015-03-10 17:16:10 +01005580 if ((analyzer & (AN_REQ_INSPECT_FE|AN_REQ_HTTP_PROCESS_FE)))
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01005581 s->res.analysers |= analyzer;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005582 }
Thierry FOURNIER53e08ec2015-03-06 00:35:53 +01005583 if (HLUA_IS_WAKEREQWR(&s->hlua))
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01005584 s->req.flags |= CF_WAKE_WRITE;
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02005585 return ACT_RET_YIELD;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005586
5587 /* finished with error. */
5588 case HLUA_E_ERRMSG:
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02005589 if (!hlua_check_proto(s, dir))
5590 return ACT_RET_ERR;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005591 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005592 SEND_ERR(px, "Lua function '%s': %s.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005593 rule->arg.hlua_rule->fcn.name, lua_tostring(s->hlua.T, -1));
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005594 lua_pop(s->hlua.T, 1);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02005595 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005596
5597 case HLUA_E_ERR:
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02005598 if (!hlua_check_proto(s, dir))
5599 return ACT_RET_ERR;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005600 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005601 SEND_ERR(px, "Lua function '%s' return an unknown error.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005602 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005603
5604 default:
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02005605 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005606 }
5607}
5608
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02005609struct task *hlua_applet_wakeup(struct task *t)
5610{
5611 struct appctx *ctx = t->context;
5612 struct stream_interface *si = ctx->owner;
5613
5614 /* If the applet is wake up without any expected work, the sheduler
5615 * remove it from the run queue. This flag indicate that the applet
5616 * is waiting for write. If the buffer is full, the main processing
5617 * will send some data and after call the applet, otherwise it call
5618 * the applet ASAP.
5619 */
5620 si_applet_cant_put(si);
5621 appctx_wakeup(ctx);
5622 return NULL;
5623}
5624
5625static int hlua_applet_tcp_init(struct appctx *ctx, struct proxy *px, struct stream *strm)
5626{
5627 struct stream_interface *si = ctx->owner;
5628 struct hlua *hlua = &ctx->ctx.hlua_apptcp.hlua;
5629 struct task *task;
5630 char **arg;
Thierry Fournierfd107a22016-02-19 19:57:23 +01005631 const char *error;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02005632
5633 HLUA_INIT(hlua);
5634 ctx->ctx.hlua_apptcp.flags = 0;
5635
5636 /* Create task used by signal to wakeup applets. */
5637 task = task_new();
5638 if (!task) {
5639 SEND_ERR(px, "Lua applet tcp '%s': out of memory.\n",
5640 ctx->rule->arg.hlua_rule->fcn.name);
5641 return 0;
5642 }
5643 task->nice = 0;
5644 task->context = ctx;
5645 task->process = hlua_applet_wakeup;
5646 ctx->ctx.hlua_apptcp.task = task;
5647
5648 /* In the execution wrappers linked with a stream, the
5649 * Lua context can be not initialized. This behavior
5650 * permits to save performances because a systematic
5651 * Lua initialization cause 5% performances loss.
5652 */
5653 if (!hlua_ctx_init(hlua, task)) {
5654 SEND_ERR(px, "Lua applet tcp '%s': can't initialize Lua context.\n",
5655 ctx->rule->arg.hlua_rule->fcn.name);
5656 return 0;
5657 }
5658
5659 /* Set timeout according with the applet configuration. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02005660 hlua->max_time = ctx->applet->timeout;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02005661
5662 /* The following Lua calls can fail. */
5663 if (!SET_SAFE_LJMP(hlua->T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01005664 if (lua_type(hlua->T, -1) == LUA_TSTRING)
5665 error = lua_tostring(hlua->T, -1);
5666 else
5667 error = "critical error";
5668 SEND_ERR(px, "Lua applet tcp '%s': %s.\n",
5669 ctx->rule->arg.hlua_rule->fcn.name, error);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02005670 RESET_SAFE_LJMP(hlua->T);
5671 return 0;
5672 }
5673
5674 /* Check stack available size. */
5675 if (!lua_checkstack(hlua->T, 1)) {
5676 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
5677 ctx->rule->arg.hlua_rule->fcn.name);
5678 RESET_SAFE_LJMP(hlua->T);
5679 return 0;
5680 }
5681
5682 /* Restore the function in the stack. */
5683 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ctx->rule->arg.hlua_rule->fcn.function_ref);
5684
5685 /* Create and and push object stream in the stack. */
5686 if (!hlua_applet_tcp_new(hlua->T, ctx)) {
5687 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
5688 ctx->rule->arg.hlua_rule->fcn.name);
5689 RESET_SAFE_LJMP(hlua->T);
5690 return 0;
5691 }
5692 hlua->nargs = 1;
5693
5694 /* push keywords in the stack. */
5695 for (arg = ctx->rule->arg.hlua_rule->args; arg && *arg; arg++) {
5696 if (!lua_checkstack(hlua->T, 1)) {
5697 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
5698 ctx->rule->arg.hlua_rule->fcn.name);
5699 RESET_SAFE_LJMP(hlua->T);
5700 return 0;
5701 }
5702 lua_pushstring(hlua->T, *arg);
5703 hlua->nargs++;
5704 }
5705
5706 RESET_SAFE_LJMP(hlua->T);
5707
5708 /* Wakeup the applet ASAP. */
5709 si_applet_cant_get(si);
5710 si_applet_cant_put(si);
5711
5712 return 1;
5713}
5714
5715static void hlua_applet_tcp_fct(struct appctx *ctx)
5716{
5717 struct stream_interface *si = ctx->owner;
5718 struct stream *strm = si_strm(si);
5719 struct channel *res = si_ic(si);
5720 struct act_rule *rule = ctx->rule;
5721 struct proxy *px = strm->be;
5722 struct hlua *hlua = &ctx->ctx.hlua_apptcp.hlua;
5723
5724 /* The applet execution is already done. */
5725 if (ctx->ctx.hlua_apptcp.flags & APPLET_DONE)
5726 return;
5727
5728 /* If the stream is disconnect or closed, ldo nothing. */
5729 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
5730 return;
5731
5732 /* Execute the function. */
5733 switch (hlua_ctx_resume(hlua, 1)) {
5734 /* finished. */
5735 case HLUA_E_OK:
5736 ctx->ctx.hlua_apptcp.flags |= APPLET_DONE;
5737
5738 /* log time */
5739 strm->logs.tv_request = now;
5740
5741 /* eat the whole request */
5742 bo_skip(si_oc(si), si_ob(si)->o);
5743 res->flags |= CF_READ_NULL;
5744 si_shutr(si);
5745 return;
5746
5747 /* yield. */
5748 case HLUA_E_AGAIN:
Thierry Fournier0164f202016-02-20 17:47:43 +01005749 if (hlua->wake_time != TICK_ETERNITY)
5750 task_schedule(ctx->ctx.hlua_apptcp.task, hlua->wake_time);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02005751 return;
5752
5753 /* finished with error. */
5754 case HLUA_E_ERRMSG:
5755 /* Display log. */
5756 SEND_ERR(px, "Lua applet tcp '%s': %s.\n",
5757 rule->arg.hlua_rule->fcn.name, lua_tostring(hlua->T, -1));
5758 lua_pop(hlua->T, 1);
5759 goto error;
5760
5761 case HLUA_E_ERR:
5762 /* Display log. */
5763 SEND_ERR(px, "Lua applet tcp '%s' return an unknown error.\n",
5764 rule->arg.hlua_rule->fcn.name);
5765 goto error;
5766
5767 default:
5768 goto error;
5769 }
5770
5771error:
5772
5773 /* For all other cases, just close the stream. */
5774 si_shutw(si);
5775 si_shutr(si);
5776 ctx->ctx.hlua_apptcp.flags |= APPLET_DONE;
5777}
5778
5779static void hlua_applet_tcp_release(struct appctx *ctx)
5780{
5781 task_free(ctx->ctx.hlua_apptcp.task);
5782 ctx->ctx.hlua_apptcp.task = NULL;
5783 hlua_ctx_destroy(&ctx->ctx.hlua_apptcp.hlua);
5784}
5785
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005786/* The function returns 1 if the initialisation is complete, 0 if
5787 * an errors occurs and -1 if more data are required for initializing
5788 * the applet.
5789 */
5790static int hlua_applet_http_init(struct appctx *ctx, struct proxy *px, struct stream *strm)
5791{
5792 struct stream_interface *si = ctx->owner;
5793 struct channel *req = si_oc(si);
5794 struct http_msg *msg;
5795 struct http_txn *txn;
5796 struct hlua *hlua = &ctx->ctx.hlua_apphttp.hlua;
5797 char **arg;
5798 struct hdr_ctx hdr;
5799 struct task *task;
5800 struct sample smp; /* just used for a valid call to smp_prefetch_http. */
Thierry Fournierfd107a22016-02-19 19:57:23 +01005801 const char *error;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005802
5803 /* Wait for a full HTTP request. */
5804 if (!smp_prefetch_http(px, strm, 0, NULL, &smp, 0)) {
5805 if (smp.flags & SMP_F_MAY_CHANGE)
5806 return -1;
5807 return 0;
5808 }
5809 txn = strm->txn;
5810 msg = &txn->req;
5811
Willy Tarreau0078bfc2015-10-07 20:20:28 +02005812 /* We want two things in HTTP mode :
5813 * - enforce server-close mode if we were in keep-alive, so that the
5814 * applet is released after each response ;
5815 * - enable request body transfer to the applet in order to resync
5816 * with the response body.
5817 */
5818 if ((txn->flags & TX_CON_WANT_MSK) == TX_CON_WANT_KAL)
5819 txn->flags = (txn->flags & ~TX_CON_WANT_MSK) | TX_CON_WANT_SCL;
Willy Tarreau0078bfc2015-10-07 20:20:28 +02005820
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005821 HLUA_INIT(hlua);
5822 ctx->ctx.hlua_apphttp.left_bytes = -1;
5823 ctx->ctx.hlua_apphttp.flags = 0;
5824
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +01005825 if (txn->req.flags & HTTP_MSGF_VER_11)
5826 ctx->ctx.hlua_apphttp.flags |= APPLET_HTTP11;
5827
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005828 /* Create task used by signal to wakeup applets. */
5829 task = task_new();
5830 if (!task) {
5831 SEND_ERR(px, "Lua applet http '%s': out of memory.\n",
5832 ctx->rule->arg.hlua_rule->fcn.name);
5833 return 0;
5834 }
5835 task->nice = 0;
5836 task->context = ctx;
5837 task->process = hlua_applet_wakeup;
5838 ctx->ctx.hlua_apphttp.task = task;
5839
5840 /* In the execution wrappers linked with a stream, the
5841 * Lua context can be not initialized. This behavior
5842 * permits to save performances because a systematic
5843 * Lua initialization cause 5% performances loss.
5844 */
5845 if (!hlua_ctx_init(hlua, task)) {
5846 SEND_ERR(px, "Lua applet http '%s': can't initialize Lua context.\n",
5847 ctx->rule->arg.hlua_rule->fcn.name);
5848 return 0;
5849 }
5850
5851 /* Set timeout according with the applet configuration. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02005852 hlua->max_time = ctx->applet->timeout;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005853
5854 /* The following Lua calls can fail. */
5855 if (!SET_SAFE_LJMP(hlua->T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01005856 if (lua_type(hlua->T, -1) == LUA_TSTRING)
5857 error = lua_tostring(hlua->T, -1);
5858 else
5859 error = "critical error";
5860 SEND_ERR(px, "Lua applet http '%s': %s.\n",
5861 ctx->rule->arg.hlua_rule->fcn.name, error);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005862 return 0;
5863 }
5864
5865 /* Check stack available size. */
5866 if (!lua_checkstack(hlua->T, 1)) {
5867 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
5868 ctx->rule->arg.hlua_rule->fcn.name);
5869 RESET_SAFE_LJMP(hlua->T);
5870 return 0;
5871 }
5872
5873 /* Restore the function in the stack. */
5874 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ctx->rule->arg.hlua_rule->fcn.function_ref);
5875
5876 /* Create and and push object stream in the stack. */
5877 if (!hlua_applet_http_new(hlua->T, ctx)) {
5878 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
5879 ctx->rule->arg.hlua_rule->fcn.name);
5880 RESET_SAFE_LJMP(hlua->T);
5881 return 0;
5882 }
5883 hlua->nargs = 1;
5884
5885 /* Look for a 100-continue expected. */
5886 if (msg->flags & HTTP_MSGF_VER_11) {
5887 hdr.idx = 0;
5888 if (http_find_header2("Expect", 6, req->buf->p, &txn->hdr_idx, &hdr) &&
5889 unlikely(hdr.vlen == 12 && strncasecmp(hdr.line+hdr.val, "100-continue", 12) == 0))
5890 ctx->ctx.hlua_apphttp.flags |= APPLET_100C;
5891 }
5892
5893 /* push keywords in the stack. */
5894 for (arg = ctx->rule->arg.hlua_rule->args; arg && *arg; arg++) {
5895 if (!lua_checkstack(hlua->T, 1)) {
5896 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
5897 ctx->rule->arg.hlua_rule->fcn.name);
5898 RESET_SAFE_LJMP(hlua->T);
5899 return 0;
5900 }
5901 lua_pushstring(hlua->T, *arg);
5902 hlua->nargs++;
5903 }
5904
5905 RESET_SAFE_LJMP(hlua->T);
5906
5907 /* Wakeup the applet when data is ready for read. */
5908 si_applet_cant_get(si);
5909
5910 return 1;
5911}
5912
5913static void hlua_applet_http_fct(struct appctx *ctx)
5914{
5915 struct stream_interface *si = ctx->owner;
5916 struct stream *strm = si_strm(si);
5917 struct channel *res = si_ic(si);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005918 struct act_rule *rule = ctx->rule;
5919 struct proxy *px = strm->be;
5920 struct hlua *hlua = &ctx->ctx.hlua_apphttp.hlua;
5921 char *blk1;
5922 int len1;
5923 char *blk2;
5924 int len2;
5925 int ret;
5926
5927 /* If the stream is disconnect or closed, ldo nothing. */
5928 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
5929 return;
5930
5931 /* Set the currently running flag. */
5932 if (!HLUA_IS_RUNNING(hlua) &&
5933 !(ctx->ctx.hlua_apphttp.flags & APPLET_DONE)) {
5934
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005935 /* Wait for full HTTP analysys. */
5936 if (unlikely(strm->txn->req.msg_state < HTTP_MSG_BODY)) {
5937 si_applet_cant_get(si);
5938 return;
5939 }
5940
5941 /* Store the max amount of bytes that we can read. */
5942 ctx->ctx.hlua_apphttp.left_bytes = strm->txn->req.body_len;
5943
5944 /* We need to flush the request header. This left the body
5945 * for the Lua.
5946 */
5947
5948 /* Read the maximum amount of data avalaible. */
5949 ret = bo_getblk_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
5950 if (ret == -1)
5951 return;
5952
5953 /* No data available, ask for more data. */
5954 if (ret == 1)
5955 len2 = 0;
5956 if (ret == 0)
5957 len1 = 0;
5958 if (len1 + len2 < strm->txn->req.eoh + 2) {
5959 si_applet_cant_get(si);
5960 return;
5961 }
5962
5963 /* skip the requests bytes. */
5964 bo_skip(si_oc(si), strm->txn->req.eoh + 2);
5965 }
5966
5967 /* Executes The applet if it is not done. */
5968 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_DONE)) {
5969
5970 /* Execute the function. */
5971 switch (hlua_ctx_resume(hlua, 1)) {
5972 /* finished. */
5973 case HLUA_E_OK:
5974 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
5975 break;
5976
5977 /* yield. */
5978 case HLUA_E_AGAIN:
Thierry Fournier0164f202016-02-20 17:47:43 +01005979 if (hlua->wake_time != TICK_ETERNITY)
5980 task_schedule(ctx->ctx.hlua_apphttp.task, hlua->wake_time);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005981 return;
5982
5983 /* finished with error. */
5984 case HLUA_E_ERRMSG:
5985 /* Display log. */
5986 SEND_ERR(px, "Lua applet http '%s': %s.\n",
5987 rule->arg.hlua_rule->fcn.name, lua_tostring(hlua->T, -1));
5988 lua_pop(hlua->T, 1);
5989 goto error;
5990
5991 case HLUA_E_ERR:
5992 /* Display log. */
5993 SEND_ERR(px, "Lua applet http '%s' return an unknown error.\n",
5994 rule->arg.hlua_rule->fcn.name);
5995 goto error;
5996
5997 default:
5998 goto error;
5999 }
6000 }
6001
6002 if (ctx->ctx.hlua_apphttp.flags & APPLET_DONE) {
6003
6004 /* We must send the final chunk. */
6005 if (ctx->ctx.hlua_apphttp.flags & APPLET_CHUNKED &&
6006 !(ctx->ctx.hlua_apphttp.flags & APPLET_LAST_CHK)) {
6007
6008 /* sent last chunk at once. */
6009 ret = bi_putblk(res, "0\r\n\r\n", 5);
6010
6011 /* critical error. */
6012 if (ret == -2 || ret == -3) {
6013 SEND_ERR(px, "Lua applet http '%s'cannont send last chunk.\n",
6014 rule->arg.hlua_rule->fcn.name);
6015 goto error;
6016 }
6017
6018 /* no enough space error. */
6019 if (ret == -1) {
6020 si_applet_cant_put(si);
6021 return;
6022 }
6023
6024 /* set the last chunk sent. */
6025 ctx->ctx.hlua_apphttp.flags |= APPLET_LAST_CHK;
6026 }
6027
6028 /* close the connection. */
6029
6030 /* status / log */
6031 strm->txn->status = ctx->ctx.hlua_apphttp.status;
6032 strm->logs.tv_request = now;
6033
6034 /* eat the whole request */
6035 bo_skip(si_oc(si), si_ob(si)->o);
6036 res->flags |= CF_READ_NULL;
6037 si_shutr(si);
6038
6039 return;
6040 }
6041
6042error:
6043
6044 /* If we are in HTTP mode, and we are not send any
6045 * data, return a 500 server error in best effort:
6046 * if there are no room avalaible in the buffer,
6047 * just close the connection.
6048 */
6049 bi_putblk(res, error_500, strlen(error_500));
6050 if (!(strm->flags & SF_ERR_MASK))
6051 strm->flags |= SF_ERR_RESOURCE;
6052 si_shutw(si);
6053 si_shutr(si);
6054 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
6055}
6056
6057static void hlua_applet_http_release(struct appctx *ctx)
6058{
6059 task_free(ctx->ctx.hlua_apphttp.task);
6060 ctx->ctx.hlua_apphttp.task = NULL;
6061 hlua_ctx_destroy(&ctx->ctx.hlua_apphttp.hlua);
6062}
6063
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006064/* global {tcp|http}-request parser. Return ACT_RET_PRS_OK in
6065 * succes case, else return ACT_RET_PRS_ERR.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006066 *
6067 * This function can fail with an abort() due to an Lua critical error.
6068 * We are in the configuration parsing process of HAProxy, this abort() is
6069 * tolerated.
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006070 */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006071static enum act_parse_ret action_register_lua(const char **args, int *cur_arg, struct proxy *px,
6072 struct act_rule *rule, char **err)
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006073{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02006074 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006075
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006076 /* Memory for the rule. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006077 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006078 if (!rule->arg.hlua_rule) {
6079 memprintf(err, "out of memory error");
Thierry FOURNIERafa80492015-08-19 09:04:15 +02006080 return ACT_RET_PRS_ERR;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006081 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006082
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006083 /* Reference the Lua function and store the reference. */
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006084 rule->arg.hlua_rule->fcn = *fcn;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006085
6086 /* TODO: later accept arguments. */
6087 rule->arg.hlua_rule->args = NULL;
6088
Thierry FOURNIER42148732015-09-02 17:17:33 +02006089 rule->action = ACT_CUSTOM;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006090 rule->action_ptr = hlua_action;
Thierry FOURNIERafa80492015-08-19 09:04:15 +02006091 return ACT_RET_PRS_OK;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006092}
6093
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006094static enum act_parse_ret action_register_service_http(const char **args, int *cur_arg, struct proxy *px,
6095 struct act_rule *rule, char **err)
6096{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02006097 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006098
Thierry FOURNIER718e2a72015-12-20 20:13:14 +01006099 /* HTTP applets are forbidden in tcp-request rules.
6100 * HTTP applet request requires everything initilized by
6101 * "http_process_request" (analyzer flag AN_REQ_HTTP_INNER).
6102 * The applet will be immediately initilized, but its before
6103 * the call of this analyzer.
6104 */
6105 if (rule->from != ACT_F_HTTP_REQ) {
6106 memprintf(err, "HTTP applets are forbidden from 'tcp-request' rulesets");
6107 return ACT_RET_PRS_ERR;
6108 }
6109
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006110 /* Memory for the rule. */
6111 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
6112 if (!rule->arg.hlua_rule) {
6113 memprintf(err, "out of memory error");
6114 return ACT_RET_PRS_ERR;
6115 }
6116
6117 /* Reference the Lua function and store the reference. */
6118 rule->arg.hlua_rule->fcn = *fcn;
6119
6120 /* TODO: later accept arguments. */
6121 rule->arg.hlua_rule->args = NULL;
6122
6123 /* Add applet pointer in the rule. */
6124 rule->applet.obj_type = OBJ_TYPE_APPLET;
6125 rule->applet.name = fcn->name;
6126 rule->applet.init = hlua_applet_http_init;
6127 rule->applet.fct = hlua_applet_http_fct;
6128 rule->applet.release = hlua_applet_http_release;
6129 rule->applet.timeout = hlua_timeout_applet;
6130
6131 return ACT_RET_PRS_OK;
6132}
6133
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006134/* This function is an LUA binding used for registering
6135 * "sample-conv" functions. It expects a converter name used
6136 * in the haproxy configuration file, and an LUA function.
6137 */
6138__LJMP static int hlua_register_action(lua_State *L)
6139{
6140 struct action_kw_list *akl;
6141 const char *name;
6142 int ref;
6143 int len;
6144 struct hlua_function *fcn;
6145
Thierry FOURNIERed0bdaa2015-12-20 19:51:06 +01006146 MAY_LJMP(check_args(L, 3, "register_action"));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006147
6148 /* First argument : converter name. */
6149 name = MAY_LJMP(luaL_checkstring(L, 1));
6150
6151 /* Second argument : environment. */
6152 if (lua_type(L, 2) != LUA_TTABLE)
6153 WILL_LJMP(luaL_error(L, "register_action: second argument must be a table of strings"));
6154
6155 /* Third argument : lua function. */
6156 ref = MAY_LJMP(hlua_checkfunction(L, 3));
6157
6158 /* browse the second argulent as an array. */
6159 lua_pushnil(L);
6160 while (lua_next(L, 2) != 0) {
6161 if (lua_type(L, -1) != LUA_TSTRING)
6162 WILL_LJMP(luaL_error(L, "register_action: second argument must be a table of strings"));
6163
6164 /* Check required environment. Only accepted "http" or "tcp". */
6165 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006166 akl = calloc(1, sizeof(*akl) + sizeof(struct action_kw) * 2);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006167 if (!akl)
6168 WILL_LJMP(luaL_error(L, "lua out of memory error."));
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006169 fcn = calloc(1, sizeof(*fcn));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006170 if (!fcn)
6171 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6172
6173 /* Fill fcn. */
6174 fcn->name = strdup(name);
6175 if (!fcn->name)
6176 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6177 fcn->function_ref = ref;
6178
6179 /* List head */
6180 akl->list.n = akl->list.p = NULL;
6181
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006182 /* action keyword. */
6183 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006184 akl->kw[0].kw = calloc(1, len);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006185 if (!akl->kw[0].kw)
6186 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6187
6188 snprintf((char *)akl->kw[0].kw, len, "lua.%s", name);
6189
6190 akl->kw[0].match_pfx = 0;
6191 akl->kw[0].private = fcn;
6192 akl->kw[0].parse = action_register_lua;
6193
6194 /* select the action registering point. */
6195 if (strcmp(lua_tostring(L, -1), "tcp-req") == 0)
6196 tcp_req_cont_keywords_register(akl);
6197 else if (strcmp(lua_tostring(L, -1), "tcp-res") == 0)
6198 tcp_res_cont_keywords_register(akl);
6199 else if (strcmp(lua_tostring(L, -1), "http-req") == 0)
6200 http_req_keywords_register(akl);
6201 else if (strcmp(lua_tostring(L, -1), "http-res") == 0)
6202 http_res_keywords_register(akl);
6203 else
6204 WILL_LJMP(luaL_error(L, "lua action environment '%s' is unknown. "
6205 "'tcp-req', 'tcp-res', 'http-req' or 'http-res' "
6206 "are expected.", lua_tostring(L, -1)));
6207
6208 /* pop the environment string. */
6209 lua_pop(L, 1);
6210 }
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006211 return ACT_RET_PRS_OK;
6212}
6213
6214static enum act_parse_ret action_register_service_tcp(const char **args, int *cur_arg, struct proxy *px,
6215 struct act_rule *rule, char **err)
6216{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02006217 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006218
6219 /* Memory for the rule. */
6220 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
6221 if (!rule->arg.hlua_rule) {
6222 memprintf(err, "out of memory error");
6223 return ACT_RET_PRS_ERR;
6224 }
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006225
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006226 /* Reference the Lua function and store the reference. */
6227 rule->arg.hlua_rule->fcn = *fcn;
6228
6229 /* TODO: later accept arguments. */
6230 rule->arg.hlua_rule->args = NULL;
6231
6232 /* Add applet pointer in the rule. */
6233 rule->applet.obj_type = OBJ_TYPE_APPLET;
6234 rule->applet.name = fcn->name;
6235 rule->applet.init = hlua_applet_tcp_init;
6236 rule->applet.fct = hlua_applet_tcp_fct;
6237 rule->applet.release = hlua_applet_tcp_release;
6238 rule->applet.timeout = hlua_timeout_applet;
6239
6240 return 0;
6241}
6242
6243/* This function is an LUA binding used for registering
6244 * "sample-conv" functions. It expects a converter name used
6245 * in the haproxy configuration file, and an LUA function.
6246 */
6247__LJMP static int hlua_register_service(lua_State *L)
6248{
6249 struct action_kw_list *akl;
6250 const char *name;
6251 const char *env;
6252 int ref;
6253 int len;
6254 struct hlua_function *fcn;
6255
6256 MAY_LJMP(check_args(L, 3, "register_service"));
6257
6258 /* First argument : converter name. */
6259 name = MAY_LJMP(luaL_checkstring(L, 1));
6260
6261 /* Second argument : environment. */
6262 env = MAY_LJMP(luaL_checkstring(L, 2));
6263
6264 /* Third argument : lua function. */
6265 ref = MAY_LJMP(hlua_checkfunction(L, 3));
6266
6267 /* Check required environment. Only accepted "http" or "tcp". */
6268 /* Allocate and fill the sample fetch keyword struct. */
6269 akl = calloc(1, sizeof(*akl) + sizeof(struct action_kw) * 2);
6270 if (!akl)
6271 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6272 fcn = calloc(1, sizeof(*fcn));
6273 if (!fcn)
6274 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6275
6276 /* Fill fcn. */
6277 len = strlen("<lua.>") + strlen(name) + 1;
6278 fcn->name = calloc(1, len);
6279 if (!fcn->name)
6280 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6281 snprintf((char *)fcn->name, len, "<lua.%s>", name);
6282 fcn->function_ref = ref;
6283
6284 /* List head */
6285 akl->list.n = akl->list.p = NULL;
6286
6287 /* converter keyword. */
6288 len = strlen("lua.") + strlen(name) + 1;
6289 akl->kw[0].kw = calloc(1, len);
6290 if (!akl->kw[0].kw)
6291 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6292
6293 snprintf((char *)akl->kw[0].kw, len, "lua.%s", name);
6294
6295 if (strcmp(env, "tcp") == 0)
6296 akl->kw[0].parse = action_register_service_tcp;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006297 else if (strcmp(env, "http") == 0)
6298 akl->kw[0].parse = action_register_service_http;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006299 else
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006300 WILL_LJMP(luaL_error(L, "lua service environment '%s' is unknown. "
6301 "'tcp' or 'http' are expected."));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006302
6303 akl->kw[0].match_pfx = 0;
6304 akl->kw[0].private = fcn;
6305
6306 /* End of array. */
6307 memset(&akl->kw[1], 0, sizeof(*akl->kw));
6308
6309 /* Register this new converter */
6310 service_keywords_register(akl);
6311
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006312 return 0;
6313}
6314
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006315static int hlua_read_timeout(char **args, int section_type, struct proxy *curpx,
6316 struct proxy *defpx, const char *file, int line,
6317 char **err, unsigned int *timeout)
6318{
6319 const char *error;
6320
6321 error = parse_time_err(args[1], timeout, TIME_UNIT_MS);
6322 if (error && *error != '\0') {
6323 memprintf(err, "%s: invalid timeout", args[0]);
6324 return -1;
6325 }
6326 return 0;
6327}
6328
6329static int hlua_session_timeout(char **args, int section_type, struct proxy *curpx,
6330 struct proxy *defpx, const char *file, int line,
6331 char **err)
6332{
6333 return hlua_read_timeout(args, section_type, curpx, defpx,
6334 file, line, err, &hlua_timeout_session);
6335}
6336
6337static int hlua_task_timeout(char **args, int section_type, struct proxy *curpx,
6338 struct proxy *defpx, const char *file, int line,
6339 char **err)
6340{
6341 return hlua_read_timeout(args, section_type, curpx, defpx,
6342 file, line, err, &hlua_timeout_task);
6343}
6344
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006345static int hlua_applet_timeout(char **args, int section_type, struct proxy *curpx,
6346 struct proxy *defpx, const char *file, int line,
6347 char **err)
6348{
6349 return hlua_read_timeout(args, section_type, curpx, defpx,
6350 file, line, err, &hlua_timeout_applet);
6351}
6352
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01006353static int hlua_forced_yield(char **args, int section_type, struct proxy *curpx,
6354 struct proxy *defpx, const char *file, int line,
6355 char **err)
6356{
6357 char *error;
6358
6359 hlua_nb_instruction = strtoll(args[1], &error, 10);
6360 if (*error != '\0') {
6361 memprintf(err, "%s: invalid number", args[0]);
6362 return -1;
6363 }
6364 return 0;
6365}
6366
Willy Tarreau32f61e22015-03-18 17:54:59 +01006367static int hlua_parse_maxmem(char **args, int section_type, struct proxy *curpx,
6368 struct proxy *defpx, const char *file, int line,
6369 char **err)
6370{
6371 char *error;
6372
6373 if (*(args[1]) == 0) {
6374 memprintf(err, "'%s' expects an integer argument (Lua memory size in MB).\n", args[0]);
6375 return -1;
6376 }
6377 hlua_global_allocator.limit = strtoll(args[1], &error, 10) * 1024L * 1024L;
6378 if (*error != '\0') {
6379 memprintf(err, "%s: invalid number %s (error at '%c')", args[0], args[1], *error);
6380 return -1;
6381 }
6382 return 0;
6383}
6384
6385
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01006386/* This function is called by the main configuration key "lua-load". It loads and
6387 * execute an lua file during the parsing of the HAProxy configuration file. It is
6388 * the main lua entry point.
6389 *
6390 * This funtion runs with the HAProxy keywords API. It returns -1 if an error is
6391 * occured, otherwise it returns 0.
6392 *
6393 * In some error case, LUA set an error message in top of the stack. This function
6394 * returns this error message in the HAProxy logs and pop it from the stack.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006395 *
6396 * This function can fail with an abort() due to an Lua critical error.
6397 * We are in the configuration parsing process of HAProxy, this abort() is
6398 * tolerated.
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01006399 */
6400static int hlua_load(char **args, int section_type, struct proxy *curpx,
6401 struct proxy *defpx, const char *file, int line,
6402 char **err)
6403{
6404 int error;
6405
6406 /* Just load and compile the file. */
6407 error = luaL_loadfile(gL.T, args[1]);
6408 if (error) {
6409 memprintf(err, "error in lua file '%s': %s", args[1], lua_tostring(gL.T, -1));
6410 lua_pop(gL.T, 1);
6411 return -1;
6412 }
6413
6414 /* If no syntax error where detected, execute the code. */
6415 error = lua_pcall(gL.T, 0, LUA_MULTRET, 0);
6416 switch (error) {
6417 case LUA_OK:
6418 break;
6419 case LUA_ERRRUN:
6420 memprintf(err, "lua runtime error: %s\n", lua_tostring(gL.T, -1));
6421 lua_pop(gL.T, 1);
6422 return -1;
6423 case LUA_ERRMEM:
6424 memprintf(err, "lua out of memory error\n");
6425 return -1;
6426 case LUA_ERRERR:
6427 memprintf(err, "lua message handler error: %s\n", lua_tostring(gL.T, -1));
6428 lua_pop(gL.T, 1);
6429 return -1;
6430 case LUA_ERRGCMM:
6431 memprintf(err, "lua garbage collector error: %s\n", lua_tostring(gL.T, -1));
6432 lua_pop(gL.T, 1);
6433 return -1;
6434 default:
6435 memprintf(err, "lua unknonwn error: %s\n", lua_tostring(gL.T, -1));
6436 lua_pop(gL.T, 1);
6437 return -1;
6438 }
6439
6440 return 0;
6441}
6442
6443/* configuration keywords declaration */
6444static struct cfg_kw_list cfg_kws = {{ },{
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006445 { CFG_GLOBAL, "lua-load", hlua_load },
6446 { CFG_GLOBAL, "tune.lua.session-timeout", hlua_session_timeout },
6447 { CFG_GLOBAL, "tune.lua.task-timeout", hlua_task_timeout },
Thierry FOURNIER56da1012015-10-01 08:42:31 +02006448 { CFG_GLOBAL, "tune.lua.service-timeout", hlua_applet_timeout },
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01006449 { CFG_GLOBAL, "tune.lua.forced-yield", hlua_forced_yield },
Willy Tarreau32f61e22015-03-18 17:54:59 +01006450 { CFG_GLOBAL, "tune.lua.maxmem", hlua_parse_maxmem },
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01006451 { 0, NULL, NULL },
6452}};
6453
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006454/* This function can fail with an abort() due to an Lua critical error.
6455 * We are in the initialisation process of HAProxy, this abort() is
6456 * tolerated.
6457 */
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006458int hlua_post_init()
6459{
6460 struct hlua_init_function *init;
6461 const char *msg;
6462 enum hlua_exec ret;
Thierry Fournierfd107a22016-02-19 19:57:23 +01006463 const char *error;
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006464
Thierry Fournier3d4a6752016-02-19 20:53:30 +01006465 /* Call post initialisation function in safe environement. */
6466 if (!SET_SAFE_LJMP(gL.T)) {
6467 if (lua_type(gL.T, -1) == LUA_TSTRING)
6468 error = lua_tostring(gL.T, -1);
6469 else
6470 error = "critical error";
6471 fprintf(stderr, "Lua post-init: %s.\n", error);
6472 exit(1);
6473 }
6474 hlua_fcn_post_init(gL.T);
6475 RESET_SAFE_LJMP(gL.T);
6476
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006477 list_for_each_entry(init, &hlua_init_functions, l) {
6478 lua_rawgeti(gL.T, LUA_REGISTRYINDEX, init->function_ref);
6479 ret = hlua_ctx_resume(&gL, 0);
6480 switch (ret) {
6481 case HLUA_E_OK:
6482 lua_pop(gL.T, -1);
6483 return 1;
6484 case HLUA_E_AGAIN:
6485 Alert("lua init: yield not allowed.\n");
6486 return 0;
6487 case HLUA_E_ERRMSG:
6488 msg = lua_tostring(gL.T, -1);
6489 Alert("lua init: %s.\n", msg);
6490 return 0;
6491 case HLUA_E_ERR:
6492 default:
6493 Alert("lua init: unknown runtime error.\n");
6494 return 0;
6495 }
6496 }
6497 return 1;
6498}
6499
Willy Tarreau32f61e22015-03-18 17:54:59 +01006500/* The memory allocator used by the Lua stack. <ud> is a pointer to the
6501 * allocator's context. <ptr> is the pointer to alloc/free/realloc. <osize>
6502 * is the previously allocated size or the kind of object in case of a new
6503 * allocation. <nsize> is the requested new size.
6504 */
6505static void *hlua_alloc(void *ud, void *ptr, size_t osize, size_t nsize)
6506{
6507 struct hlua_mem_allocator *zone = ud;
6508
6509 if (nsize == 0) {
6510 /* it's a free */
6511 if (ptr)
6512 zone->allocated -= osize;
6513 free(ptr);
6514 return NULL;
6515 }
6516
6517 if (!ptr) {
6518 /* it's a new allocation */
6519 if (zone->limit && zone->allocated + nsize > zone->limit)
6520 return NULL;
6521
6522 ptr = malloc(nsize);
6523 if (ptr)
6524 zone->allocated += nsize;
6525 return ptr;
6526 }
6527
6528 /* it's a realloc */
6529 if (zone->limit && zone->allocated + nsize - osize > zone->limit)
6530 return NULL;
6531
6532 ptr = realloc(ptr, nsize);
6533 if (ptr)
6534 zone->allocated += nsize - osize;
6535 return ptr;
6536}
6537
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006538/* Ithis function can fail with an abort() due to an Lua critical error.
6539 * We are in the initialisation process of HAProxy, this abort() is
6540 * tolerated.
6541 */
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +01006542void hlua_init(void)
6543{
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01006544 int i;
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01006545 int idx;
6546 struct sample_fetch *sf;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01006547 struct sample_conv *sc;
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01006548 char *p;
Thierry Fournierfd107a22016-02-19 19:57:23 +01006549 const char *error_msg;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006550#ifdef USE_OPENSSL
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006551 struct srv_kw *kw;
6552 int tmp_error;
6553 char *error;
Thierry FOURNIER36d13742015-03-17 16:48:53 +01006554 char *args[] = { /* SSL client configuration. */
6555 "ssl",
6556 "verify",
6557 "none",
Thierry FOURNIER36d13742015-03-17 16:48:53 +01006558 NULL
6559 };
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006560#endif
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01006561
Willy Tarreau87b09662015-04-03 00:22:06 +02006562 /* Initialise com signals pool */
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +01006563 pool2_hlua_com = create_pool("hlua_com", sizeof(struct hlua_com), MEM_F_SHARED);
6564
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01006565 /* Register configuration keywords. */
6566 cfg_register_keywords(&cfg_kws);
6567
Thierry FOURNIER380d0932015-01-23 14:27:52 +01006568 /* Init main lua stack. */
6569 gL.Mref = LUA_REFNIL;
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01006570 gL.flags = 0;
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +01006571 LIST_INIT(&gL.com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01006572 gL.T = luaL_newstate();
6573 hlua_sethlua(&gL);
6574 gL.Tref = LUA_REFNIL;
6575 gL.task = NULL;
6576
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006577 /* From this point, until the end of the initialisation fucntion,
6578 * the Lua function can fail with an abort. We are in the initialisation
6579 * process of HAProxy, this abort() is tolerated.
6580 */
6581
Willy Tarreau32f61e22015-03-18 17:54:59 +01006582 /* change the memory allocators to track memory usage */
6583 lua_setallocf(gL.T, hlua_alloc, &hlua_global_allocator);
6584
Thierry FOURNIER380d0932015-01-23 14:27:52 +01006585 /* Initialise lua. */
6586 luaL_openlibs(gL.T);
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01006587
Thierry Fournier75933d42016-01-21 09:30:18 +01006588 /* Set safe environment for the initialisation. */
6589 if (!SET_SAFE_LJMP(gL.T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01006590 if (lua_type(gL.T, -1) == LUA_TSTRING)
6591 error_msg = lua_tostring(gL.T, -1);
6592 else
6593 error_msg = "critical error";
6594 fprintf(stderr, "Lua init: %s.\n", error_msg);
Thierry Fournier75933d42016-01-21 09:30:18 +01006595 exit(1);
6596 }
6597
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01006598 /*
6599 *
6600 * Create "core" object.
6601 *
6602 */
6603
Thierry FOURNIERa2d8c652015-03-11 17:29:39 +01006604 /* This table entry is the object "core" base. */
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01006605 lua_newtable(gL.T);
6606
6607 /* Push the loglevel constants. */
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006608 for (i = 0; i < NB_LOG_LEVELS; i++)
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01006609 hlua_class_const_int(gL.T, log_levels[i], i);
6610
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006611 /* Register special functions. */
6612 hlua_class_function(gL.T, "register_init", hlua_register_init);
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006613 hlua_class_function(gL.T, "register_task", hlua_register_task);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006614 hlua_class_function(gL.T, "register_fetches", hlua_register_fetches);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006615 hlua_class_function(gL.T, "register_converters", hlua_register_converters);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006616 hlua_class_function(gL.T, "register_action", hlua_register_action);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006617 hlua_class_function(gL.T, "register_service", hlua_register_service);
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01006618 hlua_class_function(gL.T, "yield", hlua_yield);
Willy Tarreau59551662015-03-10 14:23:13 +01006619 hlua_class_function(gL.T, "set_nice", hlua_set_nice);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006620 hlua_class_function(gL.T, "sleep", hlua_sleep);
6621 hlua_class_function(gL.T, "msleep", hlua_msleep);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01006622 hlua_class_function(gL.T, "add_acl", hlua_add_acl);
6623 hlua_class_function(gL.T, "del_acl", hlua_del_acl);
6624 hlua_class_function(gL.T, "set_map", hlua_set_map);
6625 hlua_class_function(gL.T, "del_map", hlua_del_map);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01006626 hlua_class_function(gL.T, "tcp", hlua_socket_new);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01006627 hlua_class_function(gL.T, "log", hlua_log);
6628 hlua_class_function(gL.T, "Debug", hlua_log_debug);
6629 hlua_class_function(gL.T, "Info", hlua_log_info);
6630 hlua_class_function(gL.T, "Warning", hlua_log_warning);
6631 hlua_class_function(gL.T, "Alert", hlua_log_alert);
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02006632 hlua_class_function(gL.T, "done", hlua_done);
Thierry Fournierfb0b5462016-01-21 09:28:58 +01006633 hlua_fcn_reg_core_fcn(gL.T);
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006634
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01006635 lua_setglobal(gL.T, "core");
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01006636
6637 /*
6638 *
Thierry FOURNIER3def3932015-04-07 11:27:54 +02006639 * Register class Map
6640 *
6641 */
6642
6643 /* This table entry is the object "Map" base. */
6644 lua_newtable(gL.T);
6645
6646 /* register pattern types. */
6647 for (i=0; i<PAT_MATCH_NUM; i++)
6648 hlua_class_const_int(gL.T, pat_match_names[i], i);
6649
6650 /* register constructor. */
6651 hlua_class_function(gL.T, "new", hlua_map_new);
6652
6653 /* Create and fill the metatable. */
6654 lua_newtable(gL.T);
6655
6656 /* Create and fille the __index entry. */
6657 lua_pushstring(gL.T, "__index");
6658 lua_newtable(gL.T);
6659
6660 /* Register . */
6661 hlua_class_function(gL.T, "lookup", hlua_map_lookup);
6662 hlua_class_function(gL.T, "slookup", hlua_map_slookup);
6663
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02006664 lua_rawset(gL.T, -3);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02006665
Thierry Fournier45e78d72016-02-19 18:34:46 +01006666 /* Register previous table in the registry with reference and named entry.
6667 * The function hlua_register_metatable() pops the stack, so we
6668 * previously create a copy of the table.
6669 */
Thierry FOURNIER3def3932015-04-07 11:27:54 +02006670 lua_pushvalue(gL.T, -1); /* Copy the -1 entry and push it on the stack. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01006671 class_map_ref = hlua_register_metatable(gL.T, CLASS_MAP);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02006672
6673 /* Assign the metatable to the mai Map object. */
6674 lua_setmetatable(gL.T, -2);
6675
6676 /* Set a name to the table. */
6677 lua_setglobal(gL.T, "Map");
6678
6679 /*
6680 *
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01006681 * Register class Channel
6682 *
6683 */
6684
6685 /* Create and fill the metatable. */
6686 lua_newtable(gL.T);
6687
6688 /* Create and fille the __index entry. */
6689 lua_pushstring(gL.T, "__index");
6690 lua_newtable(gL.T);
6691
6692 /* Register . */
6693 hlua_class_function(gL.T, "get", hlua_channel_get);
6694 hlua_class_function(gL.T, "dup", hlua_channel_dup);
6695 hlua_class_function(gL.T, "getline", hlua_channel_getline);
6696 hlua_class_function(gL.T, "set", hlua_channel_set);
6697 hlua_class_function(gL.T, "append", hlua_channel_append);
6698 hlua_class_function(gL.T, "send", hlua_channel_send);
6699 hlua_class_function(gL.T, "forward", hlua_channel_forward);
6700 hlua_class_function(gL.T, "get_in_len", hlua_channel_get_in_len);
6701 hlua_class_function(gL.T, "get_out_len", hlua_channel_get_out_len);
6702
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02006703 lua_rawset(gL.T, -3);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01006704
6705 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01006706 class_channel_ref = hlua_register_metatable(gL.T, CLASS_CHANNEL);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01006707
6708 /*
6709 *
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01006710 * Register class Fetches
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01006711 *
6712 */
6713
6714 /* Create and fill the metatable. */
6715 lua_newtable(gL.T);
6716
6717 /* Create and fille the __index entry. */
6718 lua_pushstring(gL.T, "__index");
6719 lua_newtable(gL.T);
6720
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01006721 /* Browse existing fetches and create the associated
6722 * object method.
6723 */
6724 sf = NULL;
6725 while ((sf = sample_fetch_getnext(sf, &idx)) != NULL) {
6726
6727 /* Dont register the keywork if the arguments check function are
6728 * not safe during the runtime.
6729 */
6730 if ((sf->val_args != NULL) &&
6731 (sf->val_args != val_payload_lv) &&
6732 (sf->val_args != val_hdr))
6733 continue;
6734
6735 /* gL.Tua doesn't support '.' and '-' in the function names, replace it
6736 * by an underscore.
6737 */
6738 strncpy(trash.str, sf->kw, trash.size);
6739 trash.str[trash.size - 1] = '\0';
6740 for (p = trash.str; *p; p++)
6741 if (*p == '.' || *p == '-' || *p == '+')
6742 *p = '_';
6743
6744 /* Register the function. */
6745 lua_pushstring(gL.T, trash.str);
Willy Tarreau2ec22742015-03-10 14:27:20 +01006746 lua_pushlightuserdata(gL.T, sf);
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01006747 lua_pushcclosure(gL.T, hlua_run_sample_fetch, 1);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02006748 lua_rawset(gL.T, -3);
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01006749 }
6750
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02006751 lua_rawset(gL.T, -3);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01006752
6753 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01006754 class_fetches_ref = hlua_register_metatable(gL.T, CLASS_FETCHES);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01006755
6756 /*
6757 *
Thierry FOURNIER594afe72015-03-10 23:58:30 +01006758 * Register class Converters
6759 *
6760 */
6761
6762 /* Create and fill the metatable. */
6763 lua_newtable(gL.T);
6764
6765 /* Create and fill the __index entry. */
6766 lua_pushstring(gL.T, "__index");
6767 lua_newtable(gL.T);
6768
6769 /* Browse existing converters and create the associated
6770 * object method.
6771 */
6772 sc = NULL;
6773 while ((sc = sample_conv_getnext(sc, &idx)) != NULL) {
6774 /* Dont register the keywork if the arguments check function are
6775 * not safe during the runtime.
6776 */
6777 if (sc->val_args != NULL)
6778 continue;
6779
6780 /* gL.Tua doesn't support '.' and '-' in the function names, replace it
6781 * by an underscore.
6782 */
6783 strncpy(trash.str, sc->kw, trash.size);
6784 trash.str[trash.size - 1] = '\0';
6785 for (p = trash.str; *p; p++)
6786 if (*p == '.' || *p == '-' || *p == '+')
6787 *p = '_';
6788
6789 /* Register the function. */
6790 lua_pushstring(gL.T, trash.str);
6791 lua_pushlightuserdata(gL.T, sc);
6792 lua_pushcclosure(gL.T, hlua_run_sample_conv, 1);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02006793 lua_rawset(gL.T, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01006794 }
6795
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02006796 lua_rawset(gL.T, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01006797
6798 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01006799 class_converters_ref = hlua_register_metatable(gL.T, CLASS_CONVERTERS);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01006800
6801 /*
6802 *
Thierry FOURNIER08504f42015-03-16 14:17:08 +01006803 * Register class HTTP
6804 *
6805 */
6806
6807 /* Create and fill the metatable. */
6808 lua_newtable(gL.T);
6809
6810 /* Create and fille the __index entry. */
6811 lua_pushstring(gL.T, "__index");
6812 lua_newtable(gL.T);
6813
6814 /* Register Lua functions. */
6815 hlua_class_function(gL.T, "req_get_headers",hlua_http_req_get_headers);
6816 hlua_class_function(gL.T, "req_del_header", hlua_http_req_del_hdr);
6817 hlua_class_function(gL.T, "req_rep_header", hlua_http_req_rep_hdr);
6818 hlua_class_function(gL.T, "req_rep_value", hlua_http_req_rep_val);
6819 hlua_class_function(gL.T, "req_add_header", hlua_http_req_add_hdr);
6820 hlua_class_function(gL.T, "req_set_header", hlua_http_req_set_hdr);
6821 hlua_class_function(gL.T, "req_set_method", hlua_http_req_set_meth);
6822 hlua_class_function(gL.T, "req_set_path", hlua_http_req_set_path);
6823 hlua_class_function(gL.T, "req_set_query", hlua_http_req_set_query);
6824 hlua_class_function(gL.T, "req_set_uri", hlua_http_req_set_uri);
6825
6826 hlua_class_function(gL.T, "res_get_headers",hlua_http_res_get_headers);
6827 hlua_class_function(gL.T, "res_del_header", hlua_http_res_del_hdr);
6828 hlua_class_function(gL.T, "res_rep_header", hlua_http_res_rep_hdr);
6829 hlua_class_function(gL.T, "res_rep_value", hlua_http_res_rep_val);
6830 hlua_class_function(gL.T, "res_add_header", hlua_http_res_add_hdr);
6831 hlua_class_function(gL.T, "res_set_header", hlua_http_res_set_hdr);
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02006832 hlua_class_function(gL.T, "res_set_status", hlua_http_res_set_status);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01006833
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02006834 lua_rawset(gL.T, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01006835
6836 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01006837 class_http_ref = hlua_register_metatable(gL.T, CLASS_HTTP);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01006838
6839 /*
6840 *
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006841 * Register class AppletTCP
6842 *
6843 */
6844
6845 /* Create and fill the metatable. */
6846 lua_newtable(gL.T);
6847
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006848 /* Create and fille the __index entry. */
6849 lua_pushstring(gL.T, "__index");
6850 lua_newtable(gL.T);
6851
6852 /* Register Lua functions. */
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01006853 hlua_class_function(gL.T, "getline", hlua_applet_tcp_getline);
6854 hlua_class_function(gL.T, "receive", hlua_applet_tcp_recv);
6855 hlua_class_function(gL.T, "send", hlua_applet_tcp_send);
6856 hlua_class_function(gL.T, "set_priv", hlua_applet_tcp_set_priv);
6857 hlua_class_function(gL.T, "get_priv", hlua_applet_tcp_get_priv);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006858
6859 lua_settable(gL.T, -3);
6860
6861 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01006862 class_applet_tcp_ref = hlua_register_metatable(gL.T, CLASS_APPLET_TCP);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006863
6864 /*
6865 *
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006866 * Register class AppletHTTP
6867 *
6868 */
6869
6870 /* Create and fill the metatable. */
6871 lua_newtable(gL.T);
6872
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006873 /* Create and fille the __index entry. */
6874 lua_pushstring(gL.T, "__index");
6875 lua_newtable(gL.T);
6876
6877 /* Register Lua functions. */
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01006878 hlua_class_function(gL.T, "set_priv", hlua_applet_http_set_priv);
6879 hlua_class_function(gL.T, "get_priv", hlua_applet_http_get_priv);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006880 hlua_class_function(gL.T, "getline", hlua_applet_http_getline);
6881 hlua_class_function(gL.T, "receive", hlua_applet_http_recv);
6882 hlua_class_function(gL.T, "send", hlua_applet_http_send);
6883 hlua_class_function(gL.T, "add_header", hlua_applet_http_addheader);
6884 hlua_class_function(gL.T, "set_status", hlua_applet_http_status);
6885 hlua_class_function(gL.T, "start_response", hlua_applet_http_start_response);
6886
6887 lua_settable(gL.T, -3);
6888
6889 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01006890 class_applet_http_ref = hlua_register_metatable(gL.T, CLASS_APPLET_HTTP);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006891
6892 /*
6893 *
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01006894 * Register class TXN
6895 *
6896 */
6897
6898 /* Create and fill the metatable. */
6899 lua_newtable(gL.T);
6900
6901 /* Create and fille the __index entry. */
6902 lua_pushstring(gL.T, "__index");
6903 lua_newtable(gL.T);
6904
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01006905 /* Register Lua functions. */
Willy Tarreau59551662015-03-10 14:23:13 +01006906 hlua_class_function(gL.T, "set_priv", hlua_set_priv);
6907 hlua_class_function(gL.T, "get_priv", hlua_get_priv);
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02006908 hlua_class_function(gL.T, "set_var", hlua_set_var);
6909 hlua_class_function(gL.T, "get_var", hlua_get_var);
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02006910 hlua_class_function(gL.T, "done", hlua_txn_done);
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01006911 hlua_class_function(gL.T, "set_loglevel",hlua_txn_set_loglevel);
6912 hlua_class_function(gL.T, "set_tos", hlua_txn_set_tos);
6913 hlua_class_function(gL.T, "set_mark", hlua_txn_set_mark);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01006914 hlua_class_function(gL.T, "deflog", hlua_txn_deflog);
6915 hlua_class_function(gL.T, "log", hlua_txn_log);
6916 hlua_class_function(gL.T, "Debug", hlua_txn_log_debug);
6917 hlua_class_function(gL.T, "Info", hlua_txn_log_info);
6918 hlua_class_function(gL.T, "Warning", hlua_txn_log_warning);
6919 hlua_class_function(gL.T, "Alert", hlua_txn_log_alert);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01006920
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02006921 lua_rawset(gL.T, -3);
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01006922
6923 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01006924 class_txn_ref = hlua_register_metatable(gL.T, CLASS_TXN);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01006925
6926 /*
6927 *
6928 * Register class Socket
6929 *
6930 */
6931
6932 /* Create and fill the metatable. */
6933 lua_newtable(gL.T);
6934
6935 /* Create and fille the __index entry. */
6936 lua_pushstring(gL.T, "__index");
6937 lua_newtable(gL.T);
6938
Baptiste Assmann84bb4932015-03-02 21:40:06 +01006939#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01006940 hlua_class_function(gL.T, "connect_ssl", hlua_socket_connect_ssl);
Baptiste Assmann84bb4932015-03-02 21:40:06 +01006941#endif
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01006942 hlua_class_function(gL.T, "connect", hlua_socket_connect);
6943 hlua_class_function(gL.T, "send", hlua_socket_send);
6944 hlua_class_function(gL.T, "receive", hlua_socket_receive);
6945 hlua_class_function(gL.T, "close", hlua_socket_close);
6946 hlua_class_function(gL.T, "getpeername", hlua_socket_getpeername);
6947 hlua_class_function(gL.T, "getsockname", hlua_socket_getsockname);
6948 hlua_class_function(gL.T, "setoption", hlua_socket_setoption);
6949 hlua_class_function(gL.T, "settimeout", hlua_socket_settimeout);
6950
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02006951 lua_rawset(gL.T, -3); /* Push the last 2 entries in the table at index -3 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01006952
6953 /* Register the garbage collector entry. */
6954 lua_pushstring(gL.T, "__gc");
6955 lua_pushcclosure(gL.T, hlua_socket_gc, 0);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02006956 lua_rawset(gL.T, -3); /* Push the last 2 entries in the table at index -3 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01006957
6958 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01006959 class_socket_ref = hlua_register_metatable(gL.T, CLASS_SOCKET);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01006960
6961 /* Proxy and server configuration initialisation. */
6962 memset(&socket_proxy, 0, sizeof(socket_proxy));
6963 init_new_proxy(&socket_proxy);
6964 socket_proxy.parent = NULL;
6965 socket_proxy.last_change = now.tv_sec;
6966 socket_proxy.id = "LUA-SOCKET";
6967 socket_proxy.cap = PR_CAP_FE | PR_CAP_BE;
6968 socket_proxy.maxconn = 0;
6969 socket_proxy.accept = NULL;
6970 socket_proxy.options2 |= PR_O2_INDEPSTR;
6971 socket_proxy.srv = NULL;
6972 socket_proxy.conn_retries = 0;
6973 socket_proxy.timeout.connect = 5000; /* By default the timeout connection is 5s. */
6974
6975 /* Init TCP server: unchanged parameters */
6976 memset(&socket_tcp, 0, sizeof(socket_tcp));
6977 socket_tcp.next = NULL;
6978 socket_tcp.proxy = &socket_proxy;
6979 socket_tcp.obj_type = OBJ_TYPE_SERVER;
6980 LIST_INIT(&socket_tcp.actconns);
6981 LIST_INIT(&socket_tcp.pendconns);
Willy Tarreau600802a2015-08-04 17:19:06 +02006982 LIST_INIT(&socket_tcp.priv_conns);
Willy Tarreau173a1c62015-08-05 10:31:57 +02006983 LIST_INIT(&socket_tcp.idle_conns);
Willy Tarreau7017cb02015-08-05 16:35:23 +02006984 LIST_INIT(&socket_tcp.safe_conns);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01006985 socket_tcp.state = SRV_ST_RUNNING; /* early server setup */
6986 socket_tcp.last_change = 0;
6987 socket_tcp.id = "LUA-TCP-CONN";
6988 socket_tcp.check.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
6989 socket_tcp.agent.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
6990 socket_tcp.pp_opts = 0; /* Remove proxy protocol. */
6991
6992 /* XXX: Copy default parameter from default server,
6993 * but the default server is not initialized.
6994 */
6995 socket_tcp.maxqueue = socket_proxy.defsrv.maxqueue;
6996 socket_tcp.minconn = socket_proxy.defsrv.minconn;
6997 socket_tcp.maxconn = socket_proxy.defsrv.maxconn;
6998 socket_tcp.slowstart = socket_proxy.defsrv.slowstart;
6999 socket_tcp.onerror = socket_proxy.defsrv.onerror;
7000 socket_tcp.onmarkeddown = socket_proxy.defsrv.onmarkeddown;
7001 socket_tcp.onmarkedup = socket_proxy.defsrv.onmarkedup;
7002 socket_tcp.consecutive_errors_limit = socket_proxy.defsrv.consecutive_errors_limit;
7003 socket_tcp.uweight = socket_proxy.defsrv.iweight;
7004 socket_tcp.iweight = socket_proxy.defsrv.iweight;
7005
7006 socket_tcp.check.status = HCHK_STATUS_INI;
7007 socket_tcp.check.rise = socket_proxy.defsrv.check.rise;
7008 socket_tcp.check.fall = socket_proxy.defsrv.check.fall;
7009 socket_tcp.check.health = socket_tcp.check.rise; /* socket, but will fall down at first failure */
7010 socket_tcp.check.server = &socket_tcp;
7011
7012 socket_tcp.agent.status = HCHK_STATUS_INI;
7013 socket_tcp.agent.rise = socket_proxy.defsrv.agent.rise;
7014 socket_tcp.agent.fall = socket_proxy.defsrv.agent.fall;
7015 socket_tcp.agent.health = socket_tcp.agent.rise; /* socket, but will fall down at first failure */
7016 socket_tcp.agent.server = &socket_tcp;
7017
7018 socket_tcp.xprt = &raw_sock;
7019
7020#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007021 /* Init TCP server: unchanged parameters */
7022 memset(&socket_ssl, 0, sizeof(socket_ssl));
7023 socket_ssl.next = NULL;
7024 socket_ssl.proxy = &socket_proxy;
7025 socket_ssl.obj_type = OBJ_TYPE_SERVER;
7026 LIST_INIT(&socket_ssl.actconns);
7027 LIST_INIT(&socket_ssl.pendconns);
Willy Tarreau600802a2015-08-04 17:19:06 +02007028 LIST_INIT(&socket_ssl.priv_conns);
Willy Tarreau173a1c62015-08-05 10:31:57 +02007029 LIST_INIT(&socket_ssl.idle_conns);
Willy Tarreau7017cb02015-08-05 16:35:23 +02007030 LIST_INIT(&socket_ssl.safe_conns);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007031 socket_ssl.state = SRV_ST_RUNNING; /* early server setup */
7032 socket_ssl.last_change = 0;
7033 socket_ssl.id = "LUA-SSL-CONN";
7034 socket_ssl.check.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
7035 socket_ssl.agent.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
7036 socket_ssl.pp_opts = 0; /* Remove proxy protocol. */
7037
7038 /* XXX: Copy default parameter from default server,
7039 * but the default server is not initialized.
7040 */
7041 socket_ssl.maxqueue = socket_proxy.defsrv.maxqueue;
7042 socket_ssl.minconn = socket_proxy.defsrv.minconn;
7043 socket_ssl.maxconn = socket_proxy.defsrv.maxconn;
7044 socket_ssl.slowstart = socket_proxy.defsrv.slowstart;
7045 socket_ssl.onerror = socket_proxy.defsrv.onerror;
7046 socket_ssl.onmarkeddown = socket_proxy.defsrv.onmarkeddown;
7047 socket_ssl.onmarkedup = socket_proxy.defsrv.onmarkedup;
7048 socket_ssl.consecutive_errors_limit = socket_proxy.defsrv.consecutive_errors_limit;
7049 socket_ssl.uweight = socket_proxy.defsrv.iweight;
7050 socket_ssl.iweight = socket_proxy.defsrv.iweight;
7051
7052 socket_ssl.check.status = HCHK_STATUS_INI;
7053 socket_ssl.check.rise = socket_proxy.defsrv.check.rise;
7054 socket_ssl.check.fall = socket_proxy.defsrv.check.fall;
7055 socket_ssl.check.health = socket_ssl.check.rise; /* socket, but will fall down at first failure */
7056 socket_ssl.check.server = &socket_ssl;
7057
7058 socket_ssl.agent.status = HCHK_STATUS_INI;
7059 socket_ssl.agent.rise = socket_proxy.defsrv.agent.rise;
7060 socket_ssl.agent.fall = socket_proxy.defsrv.agent.fall;
7061 socket_ssl.agent.health = socket_ssl.agent.rise; /* socket, but will fall down at first failure */
7062 socket_ssl.agent.server = &socket_ssl;
7063
Thierry FOURNIER36d13742015-03-17 16:48:53 +01007064 socket_ssl.use_ssl = 1;
7065 socket_ssl.xprt = &ssl_sock;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007066
Thierry FOURNIER36d13742015-03-17 16:48:53 +01007067 for (idx = 0; args[idx] != NULL; idx++) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007068 if ((kw = srv_find_kw(args[idx])) != NULL) { /* Maybe it's registered server keyword */
7069 /*
7070 *
7071 * If the keyword is not known, we can search in the registered
7072 * server keywords. This is usefull to configure special SSL
7073 * features like client certificates and ssl_verify.
7074 *
7075 */
7076 tmp_error = kw->parse(args, &idx, &socket_proxy, &socket_ssl, &error);
7077 if (tmp_error != 0) {
7078 fprintf(stderr, "INTERNAL ERROR: %s\n", error);
7079 abort(); /* This must be never arrives because the command line
7080 not editable by the user. */
7081 }
7082 idx += kw->skip;
7083 }
7084 }
7085
7086 /* Initialize SSL server. */
Thierry FOURNIER36d13742015-03-17 16:48:53 +01007087 ssl_sock_prepare_srv_ctx(&socket_ssl, &socket_proxy);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007088#endif
Thierry Fournier75933d42016-01-21 09:30:18 +01007089
7090 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +01007091}