blob: 77e5a9d5cf6b5ce5b4e0fa714c2142acf3a3da8c [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 FOURNIERc798b5d2015-03-17 01:09:57 +010013#include <ctype.h>
Thierry FOURNIERbabae282015-09-17 11:36:37 +020014#include <setjmp.h>
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +010015
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +010016#include <lauxlib.h>
17#include <lua.h>
18#include <lualib.h>
19
Thierry FOURNIER463119c2015-03-10 00:35:36 +010020#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 503
21#error "Requires Lua 5.3 or later."
Cyril Bontédc0306e2015-03-02 00:08:40 +010022#endif
23
Thierry FOURNIER380d0932015-01-23 14:27:52 +010024#include <ebpttree.h>
25
26#include <common/cfgparse.h>
27
William Lallemand9ed62032016-11-21 17:49:11 +010028#include <types/cli.h>
Thierry FOURNIER380d0932015-01-23 14:27:52 +010029#include <types/hlua.h>
30#include <types/proxy.h>
William Lallemand9ed62032016-11-21 17:49:11 +010031#include <types/stats.h>
Thierry FOURNIER380d0932015-01-23 14:27:52 +010032
Thierry FOURNIER55da1652015-01-23 11:36:30 +010033#include <proto/arg.h>
Willy Tarreau8a8d83b2015-04-13 13:24:54 +020034#include <proto/applet.h>
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010035#include <proto/channel.h>
William Lallemand9ed62032016-11-21 17:49:11 +010036#include <proto/cli.h>
Willy Tarreaua71f6422016-11-16 17:00:14 +010037#include <proto/connection.h>
William Lallemand9ed62032016-11-21 17:49:11 +010038#include <proto/stats.h>
Thierry FOURNIER9a819e72015-02-16 20:22:55 +010039#include <proto/hdr_idx.h>
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +010040#include <proto/hlua.h>
Thierry Fournierfb0b5462016-01-21 09:28:58 +010041#include <proto/hlua_fcn.h>
Thierry FOURNIER3def3932015-04-07 11:27:54 +020042#include <proto/map.h>
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010043#include <proto/obj_type.h>
Thierry FOURNIER83758bb2015-02-04 13:21:04 +010044#include <proto/pattern.h>
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +010045#include <proto/payload.h>
46#include <proto/proto_http.h>
47#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/stream_interface.h>
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +010052#include <proto/task.h>
Willy Tarreau39713102016-11-25 15:49:32 +010053#include <proto/tcp_rules.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 FOURNIERebed6e92016-12-16 11:54:07 +0100138/* This is the memory pool containing struct lua for applets
139 * (including cli).
140 */
141struct pool_head *pool2_hlua;
142
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100143/* This is the memory pool containing all the signal structs. These
144 * struct are used to store each requiered signal between two tasks.
145 */
146struct pool_head *pool2_hlua_com;
147
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +0100148/* Used for Socket connection. */
149static struct proxy socket_proxy;
150static struct server socket_tcp;
151#ifdef USE_OPENSSL
152static struct server socket_ssl;
153#endif
154
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +0100155/* List head of the function called at the initialisation time. */
156struct list hlua_init_functions = LIST_HEAD_INIT(hlua_init_functions);
157
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +0100158/* The following variables contains the reference of the different
159 * Lua classes. These references are useful for identify metadata
160 * associated with an object.
161 */
Thierry FOURNIER65f34c62015-02-16 20:11:43 +0100162static int class_txn_ref;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +0100163static int class_socket_ref;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +0100164static int class_channel_ref;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +0100165static int class_fetches_ref;
Thierry FOURNIER594afe72015-03-10 23:58:30 +0100166static int class_converters_ref;
Thierry FOURNIER08504f42015-03-16 14:17:08 +0100167static int class_http_ref;
Thierry FOURNIER3def3932015-04-07 11:27:54 +0200168static int class_map_ref;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200169static int class_applet_tcp_ref;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200170static int class_applet_http_ref;
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +0100171
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100172/* Global Lua execution timeout. By default Lua, execution linked
Willy Tarreau87b09662015-04-03 00:22:06 +0200173 * with stream (actions, sample-fetches and converters) have a
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100174 * short timeout. Lua linked with tasks doesn't have a timeout
175 * because a task may remain alive during all the haproxy execution.
176 */
177static unsigned int hlua_timeout_session = 4000; /* session timeout. */
178static unsigned int hlua_timeout_task = TICK_ETERNITY; /* task timeout. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200179static unsigned int hlua_timeout_applet = 4000; /* applet timeout. */
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100180
Thierry FOURNIERee9f8022015-03-03 17:37:37 +0100181/* Interrupts the Lua processing each "hlua_nb_instruction" instructions.
182 * it is used for preventing infinite loops.
183 *
184 * I test the scheer with an infinite loop containing one incrementation
185 * and one test. I run this loop between 10 seconds, I raise a ceil of
186 * 710M loops from one interrupt each 9000 instructions, so I fix the value
187 * to one interrupt each 10 000 instructions.
188 *
189 * configured | Number of
190 * instructions | loops executed
191 * between two | in milions
192 * forced yields |
193 * ---------------+---------------
194 * 10 | 160
195 * 500 | 670
196 * 1000 | 680
197 * 5000 | 700
198 * 7000 | 700
199 * 8000 | 700
200 * 9000 | 710 <- ceil
201 * 10000 | 710
202 * 100000 | 710
203 * 1000000 | 710
204 *
205 */
206static unsigned int hlua_nb_instruction = 10000;
207
Willy Tarreau32f61e22015-03-18 17:54:59 +0100208/* Descriptor for the memory allocation state. If limit is not null, it will
209 * be enforced on any memory allocation.
210 */
211struct hlua_mem_allocator {
212 size_t allocated;
213 size_t limit;
214};
215
216static struct hlua_mem_allocator hlua_global_allocator;
217
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200218static const char error_500[] =
Jarno Huuskonen16ad94a2017-01-09 14:17:10 +0200219 "HTTP/1.0 500 Internal Server Error\r\n"
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200220 "Cache-Control: no-cache\r\n"
221 "Connection: close\r\n"
222 "Content-Type: text/html\r\n"
223 "\r\n"
Jarno Huuskonen16ad94a2017-01-09 14:17:10 +0200224 "<html><body><h1>500 Internal Server Error</h1>\nAn internal server error occured.\n</body></html>\n";
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200225
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100226/* These functions converts types between HAProxy internal args or
227 * sample and LUA types. Another function permits to check if the
228 * LUA stack contains arguments according with an required ARG_T
229 * format.
230 */
231static int hlua_arg2lua(lua_State *L, const struct arg *arg);
232static int hlua_lua2arg(lua_State *L, int ud, struct arg *arg);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100233__LJMP static int hlua_lua2arg_check(lua_State *L, int first, struct arg *argp,
David Carlier0c437f42016-04-27 16:21:56 +0100234 uint64_t mask, struct proxy *p);
Willy Tarreau5eadada2015-03-10 17:28:54 +0100235static int hlua_smp2lua(lua_State *L, struct sample *smp);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100236static int hlua_smp2lua_str(lua_State *L, struct sample *smp);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100237static int hlua_lua2smp(lua_State *L, int ud, struct sample *smp);
238
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200239__LJMP static int hlua_http_get_headers(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg);
240
Thierry FOURNIER23bc3752015-09-11 19:15:43 +0200241#define SEND_ERR(__be, __fmt, __args...) \
242 do { \
243 send_log(__be, LOG_ERR, __fmt, ## __args); \
244 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) \
245 Alert(__fmt, ## __args); \
246 } while (0)
247
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100248/* Used to check an Lua function type in the stack. It creates and
249 * returns a reference of the function. This function throws an
250 * error if the rgument is not a "function".
251 */
252__LJMP unsigned int hlua_checkfunction(lua_State *L, int argno)
253{
254 if (!lua_isfunction(L, argno)) {
255 const char *msg = lua_pushfstring(L, "function expected, got %s", luaL_typename(L, -1));
256 WILL_LJMP(luaL_argerror(L, argno, msg));
257 }
258 lua_pushvalue(L, argno);
259 return luaL_ref(L, LUA_REGISTRYINDEX);
260}
261
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200262/* Return the string that is of the top of the stack. */
263const char *hlua_get_top_error_string(lua_State *L)
264{
265 if (lua_gettop(L) < 1)
266 return "unknown error";
267 if (lua_type(L, -1) != LUA_TSTRING)
268 return "unknown error";
269 return lua_tostring(L, -1);
270}
271
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100272/* This function check the number of arguments available in the
273 * stack. If the number of arguments available is not the same
274 * then <nb> an error is throwed.
275 */
276__LJMP static inline void check_args(lua_State *L, int nb, char *fcn)
277{
278 if (lua_gettop(L) == nb)
279 return;
280 WILL_LJMP(luaL_error(L, "'%s' needs %d arguments", fcn, nb));
281}
282
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100283/* This fucntion push an error string prefixed by the file name
284 * and the line number where the error is encountered.
285 */
286static int hlua_pusherror(lua_State *L, const char *fmt, ...)
287{
288 va_list argp;
289 va_start(argp, fmt);
290 luaL_where(L, 1);
291 lua_pushvfstring(L, fmt, argp);
292 va_end(argp);
293 lua_concat(L, 2);
294 return 1;
295}
296
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100297/* This function register a new signal. "lua" is the current lua
298 * execution context. It contains a pointer to the associated task.
299 * "link" is a list head attached to an other task that must be wake
300 * the lua task if an event occurs. This is useful with external
301 * events like TCP I/O or sleep functions. This funcion allocate
302 * memory for the signal.
303 */
Thierry FOURNIER847ca662016-12-16 13:07:22 +0100304static struct hlua_com *hlua_com_new(struct list *purge, struct list *event, struct task *wakeup)
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100305{
306 struct hlua_com *com = pool_alloc2(pool2_hlua_com);
307 if (!com)
Thierry FOURNIER847ca662016-12-16 13:07:22 +0100308 return NULL;
309 LIST_ADDQ(purge, &com->purge_me);
310 LIST_ADDQ(event, &com->wake_me);
311 com->task = wakeup;
312 return com;
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100313}
314
315/* This function purge all the pending signals when the LUA execution
316 * is finished. This prevent than a coprocess try to wake a deleted
317 * task. This function remove the memory associated to the signal.
318 */
Thierry FOURNIER847ca662016-12-16 13:07:22 +0100319static void hlua_com_purge(struct list *purge)
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100320{
321 struct hlua_com *com, *back;
322
323 /* Delete all pending communication signals. */
Thierry FOURNIER847ca662016-12-16 13:07:22 +0100324 list_for_each_entry_safe(com, back, purge, purge_me) {
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100325 LIST_DEL(&com->purge_me);
326 LIST_DEL(&com->wake_me);
327 pool_free2(pool2_hlua_com, com);
328 }
329}
330
331/* This function sends signals. It wakes all the tasks attached
332 * to a list head, and remove the signal, and free the used
333 * memory.
334 */
335static void hlua_com_wake(struct list *wake)
336{
337 struct hlua_com *com, *back;
338
339 /* Wake task and delete all pending communication signals. */
340 list_for_each_entry_safe(com, back, wake, wake_me) {
341 LIST_DEL(&com->purge_me);
342 LIST_DEL(&com->wake_me);
343 task_wakeup(com->task, TASK_WOKEN_MSG);
344 pool_free2(pool2_hlua_com, com);
345 }
346}
347
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100348/* This functions is used with sample fetch and converters. It
349 * converts the HAProxy configuration argument in a lua stack
350 * values.
351 *
352 * It takes an array of "arg", and each entry of the array is
353 * converted and pushed in the LUA stack.
354 */
355static int hlua_arg2lua(lua_State *L, const struct arg *arg)
356{
357 switch (arg->type) {
358 case ARGT_SINT:
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100359 case ARGT_TIME:
360 case ARGT_SIZE:
Thierry FOURNIERf90838b2015-03-06 13:48:32 +0100361 lua_pushinteger(L, arg->data.sint);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100362 break;
363
364 case ARGT_STR:
365 lua_pushlstring(L, arg->data.str.str, arg->data.str.len);
366 break;
367
368 case ARGT_IPV4:
369 case ARGT_IPV6:
370 case ARGT_MSK4:
371 case ARGT_MSK6:
372 case ARGT_FE:
373 case ARGT_BE:
374 case ARGT_TAB:
375 case ARGT_SRV:
376 case ARGT_USR:
377 case ARGT_MAP:
378 default:
379 lua_pushnil(L);
380 break;
381 }
382 return 1;
383}
384
385/* This function take one entrie in an LUA stack at the index "ud",
386 * and try to convert it in an HAProxy argument entry. This is useful
387 * with sample fetch wrappers. The input arguments are gived to the
388 * lua wrapper and converted as arg list by thi function.
389 */
390static int hlua_lua2arg(lua_State *L, int ud, struct arg *arg)
391{
392 switch (lua_type(L, ud)) {
393
394 case LUA_TNUMBER:
395 case LUA_TBOOLEAN:
396 arg->type = ARGT_SINT;
397 arg->data.sint = lua_tointeger(L, ud);
398 break;
399
400 case LUA_TSTRING:
401 arg->type = ARGT_STR;
402 arg->data.str.str = (char *)lua_tolstring(L, ud, (size_t *)&arg->data.str.len);
403 break;
404
405 case LUA_TUSERDATA:
406 case LUA_TNIL:
407 case LUA_TTABLE:
408 case LUA_TFUNCTION:
409 case LUA_TTHREAD:
410 case LUA_TLIGHTUSERDATA:
411 arg->type = ARGT_SINT;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +0200412 arg->data.sint = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100413 break;
414 }
415 return 1;
416}
417
418/* the following functions are used to convert a struct sample
419 * in Lua type. This useful to convert the return of the
420 * fetchs or converters.
421 */
Willy Tarreau5eadada2015-03-10 17:28:54 +0100422static int hlua_smp2lua(lua_State *L, struct sample *smp)
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100423{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200424 switch (smp->data.type) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100425 case SMP_T_SINT:
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100426 case SMP_T_BOOL:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200427 lua_pushinteger(L, smp->data.u.sint);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100428 break;
429
430 case SMP_T_BIN:
431 case SMP_T_STR:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200432 lua_pushlstring(L, smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100433 break;
434
435 case SMP_T_METH:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200436 switch (smp->data.u.meth.meth) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100437 case HTTP_METH_OPTIONS: lua_pushstring(L, "OPTIONS"); break;
438 case HTTP_METH_GET: lua_pushstring(L, "GET"); break;
439 case HTTP_METH_HEAD: lua_pushstring(L, "HEAD"); break;
440 case HTTP_METH_POST: lua_pushstring(L, "POST"); break;
441 case HTTP_METH_PUT: lua_pushstring(L, "PUT"); break;
442 case HTTP_METH_DELETE: lua_pushstring(L, "DELETE"); break;
443 case HTTP_METH_TRACE: lua_pushstring(L, "TRACE"); break;
444 case HTTP_METH_CONNECT: lua_pushstring(L, "CONNECT"); break;
445 case HTTP_METH_OTHER:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200446 lua_pushlstring(L, smp->data.u.meth.str.str, smp->data.u.meth.str.len);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100447 break;
448 default:
449 lua_pushnil(L);
450 break;
451 }
452 break;
453
454 case SMP_T_IPV4:
455 case SMP_T_IPV6:
456 case SMP_T_ADDR: /* This type is never used to qualify a sample. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200457 if (sample_casts[smp->data.type][SMP_T_STR] &&
458 sample_casts[smp->data.type][SMP_T_STR](smp))
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200459 lua_pushlstring(L, smp->data.u.str.str, smp->data.u.str.len);
Willy Tarreau5eadada2015-03-10 17:28:54 +0100460 else
461 lua_pushnil(L);
462 break;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100463 default:
464 lua_pushnil(L);
465 break;
466 }
467 return 1;
468}
469
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100470/* the following functions are used to convert a struct sample
471 * in Lua strings. This is useful to convert the return of the
472 * fetchs or converters.
473 */
474static int hlua_smp2lua_str(lua_State *L, struct sample *smp)
475{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200476 switch (smp->data.type) {
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100477
478 case SMP_T_BIN:
479 case SMP_T_STR:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200480 lua_pushlstring(L, smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100481 break;
482
483 case SMP_T_METH:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200484 switch (smp->data.u.meth.meth) {
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100485 case HTTP_METH_OPTIONS: lua_pushstring(L, "OPTIONS"); break;
486 case HTTP_METH_GET: lua_pushstring(L, "GET"); break;
487 case HTTP_METH_HEAD: lua_pushstring(L, "HEAD"); break;
488 case HTTP_METH_POST: lua_pushstring(L, "POST"); break;
489 case HTTP_METH_PUT: lua_pushstring(L, "PUT"); break;
490 case HTTP_METH_DELETE: lua_pushstring(L, "DELETE"); break;
491 case HTTP_METH_TRACE: lua_pushstring(L, "TRACE"); break;
492 case HTTP_METH_CONNECT: lua_pushstring(L, "CONNECT"); break;
493 case HTTP_METH_OTHER:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200494 lua_pushlstring(L, smp->data.u.meth.str.str, smp->data.u.meth.str.len);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100495 break;
496 default:
497 lua_pushstring(L, "");
498 break;
499 }
500 break;
501
502 case SMP_T_SINT:
503 case SMP_T_BOOL:
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100504 case SMP_T_IPV4:
505 case SMP_T_IPV6:
506 case SMP_T_ADDR: /* This type is never used to qualify a sample. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200507 if (sample_casts[smp->data.type][SMP_T_STR] &&
508 sample_casts[smp->data.type][SMP_T_STR](smp))
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200509 lua_pushlstring(L, smp->data.u.str.str, smp->data.u.str.len);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100510 else
511 lua_pushstring(L, "");
512 break;
513 default:
514 lua_pushstring(L, "");
515 break;
516 }
517 return 1;
518}
519
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100520/* the following functions are used to convert an Lua type in a
521 * struct sample. This is useful to provide data from a converter
522 * to the LUA code.
523 */
524static int hlua_lua2smp(lua_State *L, int ud, struct sample *smp)
525{
526 switch (lua_type(L, ud)) {
527
528 case LUA_TNUMBER:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200529 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200530 smp->data.u.sint = lua_tointeger(L, ud);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100531 break;
532
533
534 case LUA_TBOOLEAN:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200535 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200536 smp->data.u.sint = lua_toboolean(L, ud);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100537 break;
538
539 case LUA_TSTRING:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200540 smp->data.type = SMP_T_STR;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100541 smp->flags |= SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200542 smp->data.u.str.str = (char *)lua_tolstring(L, ud, (size_t *)&smp->data.u.str.len);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100543 break;
544
545 case LUA_TUSERDATA:
546 case LUA_TNIL:
547 case LUA_TTABLE:
548 case LUA_TFUNCTION:
549 case LUA_TTHREAD:
550 case LUA_TLIGHTUSERDATA:
Thierry FOURNIER93405e12015-08-26 14:19:03 +0200551 case LUA_TNONE:
552 default:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200553 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200554 smp->data.u.sint = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100555 break;
556 }
557 return 1;
558}
559
560/* This function check the "argp" builded by another conversion function
561 * is in accord with the expected argp defined by the "mask". The fucntion
562 * returns true or false. It can be adjust the types if there compatibles.
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100563 *
564 * This function assumes thant the argp argument contains ARGM_NBARGS + 1
565 * entries.
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100566 */
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100567__LJMP int hlua_lua2arg_check(lua_State *L, int first, struct arg *argp,
David Carlier0c437f42016-04-27 16:21:56 +0100568 uint64_t mask, struct proxy *p)
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100569{
570 int min_arg;
571 int idx;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100572 struct proxy *px;
573 char *sname, *pname;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100574
575 idx = 0;
576 min_arg = ARGM(mask);
577 mask >>= ARGM_BITS;
578
579 while (1) {
580
581 /* Check oversize. */
582 if (idx >= ARGM_NBARGS && argp[idx].type != ARGT_STOP) {
Cyril Bonté577a36a2015-03-02 00:08:38 +0100583 WILL_LJMP(luaL_argerror(L, first + idx, "Malformed argument mask"));
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100584 }
585
586 /* Check for mandatory arguments. */
587 if (argp[idx].type == ARGT_STOP) {
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100588 if (idx < min_arg) {
589
590 /* If miss other argument than the first one, we return an error. */
591 if (idx > 0)
592 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
593
594 /* If first argument have a certain type, some default values
595 * may be used. See the function smp_resolve_args().
596 */
597 switch (mask & ARGT_MASK) {
598
599 case ARGT_FE:
600 if (!(p->cap & PR_CAP_FE))
601 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
602 argp[idx].data.prx = p;
603 argp[idx].type = ARGT_FE;
604 argp[idx+1].type = ARGT_STOP;
605 break;
606
607 case ARGT_BE:
608 if (!(p->cap & PR_CAP_BE))
609 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
610 argp[idx].data.prx = p;
611 argp[idx].type = ARGT_BE;
612 argp[idx+1].type = ARGT_STOP;
613 break;
614
615 case ARGT_TAB:
616 argp[idx].data.prx = p;
617 argp[idx].type = ARGT_TAB;
618 argp[idx+1].type = ARGT_STOP;
619 break;
620
621 default:
622 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
623 break;
624 }
625 }
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100626 return 0;
627 }
628
629 /* Check for exceed the number of requiered argument. */
630 if ((mask & ARGT_MASK) == ARGT_STOP &&
631 argp[idx].type != ARGT_STOP) {
632 WILL_LJMP(luaL_argerror(L, first + idx, "Last argument expected"));
633 }
634
635 if ((mask & ARGT_MASK) == ARGT_STOP &&
636 argp[idx].type == ARGT_STOP) {
637 return 0;
638 }
639
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100640 /* Convert some argument types. */
641 switch (mask & ARGT_MASK) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100642 case ARGT_SINT:
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100643 if (argp[idx].type != ARGT_SINT)
644 WILL_LJMP(luaL_argerror(L, first + idx, "integer expected"));
645 argp[idx].type = ARGT_SINT;
646 break;
647
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100648 case ARGT_TIME:
649 if (argp[idx].type != ARGT_SINT)
650 WILL_LJMP(luaL_argerror(L, first + idx, "integer expected"));
Thierry FOURNIER29176f32015-07-07 00:41:29 +0200651 argp[idx].type = ARGT_TIME;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100652 break;
653
654 case ARGT_SIZE:
655 if (argp[idx].type != ARGT_SINT)
656 WILL_LJMP(luaL_argerror(L, first + idx, "integer expected"));
Thierry FOURNIER29176f32015-07-07 00:41:29 +0200657 argp[idx].type = ARGT_SIZE;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100658 break;
659
660 case ARGT_FE:
661 if (argp[idx].type != ARGT_STR)
662 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
663 memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
664 trash.str[argp[idx].data.str.len] = 0;
Willy Tarreau9e0bb102015-05-26 11:24:42 +0200665 argp[idx].data.prx = proxy_fe_by_name(trash.str);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100666 if (!argp[idx].data.prx)
667 WILL_LJMP(luaL_argerror(L, first + idx, "frontend doesn't exist"));
668 argp[idx].type = ARGT_FE;
669 break;
670
671 case ARGT_BE:
672 if (argp[idx].type != ARGT_STR)
673 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
674 memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
675 trash.str[argp[idx].data.str.len] = 0;
Willy Tarreau9e0bb102015-05-26 11:24:42 +0200676 argp[idx].data.prx = proxy_be_by_name(trash.str);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100677 if (!argp[idx].data.prx)
678 WILL_LJMP(luaL_argerror(L, first + idx, "backend doesn't exist"));
679 argp[idx].type = ARGT_BE;
680 break;
681
682 case ARGT_TAB:
683 if (argp[idx].type != ARGT_STR)
684 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
685 memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
686 trash.str[argp[idx].data.str.len] = 0;
Willy Tarreaue2dc1fa2015-05-26 12:08:07 +0200687 argp[idx].data.prx = proxy_tbl_by_name(trash.str);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100688 if (!argp[idx].data.prx)
689 WILL_LJMP(luaL_argerror(L, first + idx, "table doesn't exist"));
690 argp[idx].type = ARGT_TAB;
691 break;
692
693 case ARGT_SRV:
694 if (argp[idx].type != ARGT_STR)
695 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
696 memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
697 trash.str[argp[idx].data.str.len] = 0;
698 sname = strrchr(trash.str, '/');
699 if (sname) {
700 *sname++ = '\0';
701 pname = trash.str;
Willy Tarreau9e0bb102015-05-26 11:24:42 +0200702 px = proxy_be_by_name(pname);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100703 if (!px)
704 WILL_LJMP(luaL_argerror(L, first + idx, "backend doesn't exist"));
705 }
706 else {
707 sname = trash.str;
708 px = p;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100709 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100710 argp[idx].data.srv = findserver(px, sname);
711 if (!argp[idx].data.srv)
712 WILL_LJMP(luaL_argerror(L, first + idx, "server doesn't exist"));
713 argp[idx].type = ARGT_SRV;
714 break;
715
716 case ARGT_IPV4:
717 memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
718 trash.str[argp[idx].data.str.len] = 0;
719 if (inet_pton(AF_INET, trash.str, &argp[idx].data.ipv4))
720 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv4 address"));
721 argp[idx].type = ARGT_IPV4;
722 break;
723
724 case ARGT_MSK4:
725 memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
726 trash.str[argp[idx].data.str.len] = 0;
727 if (!str2mask(trash.str, &argp[idx].data.ipv4))
728 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv4 mask"));
729 argp[idx].type = ARGT_MSK4;
730 break;
731
732 case ARGT_IPV6:
733 memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
734 trash.str[argp[idx].data.str.len] = 0;
735 if (inet_pton(AF_INET6, trash.str, &argp[idx].data.ipv6))
736 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv6 address"));
737 argp[idx].type = ARGT_IPV6;
738 break;
739
740 case ARGT_MSK6:
741 case ARGT_MAP:
742 case ARGT_REG:
743 case ARGT_USR:
744 WILL_LJMP(luaL_argerror(L, first + idx, "type not yet supported"));
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100745 break;
746 }
747
748 /* Check for type of argument. */
749 if ((mask & ARGT_MASK) != argp[idx].type) {
750 const char *msg = lua_pushfstring(L, "'%s' expected, got '%s'",
751 arg_type_names[(mask & ARGT_MASK)],
752 arg_type_names[argp[idx].type & ARGT_MASK]);
753 WILL_LJMP(luaL_argerror(L, first + idx, msg));
754 }
755
756 /* Next argument. */
757 mask >>= ARGT_BITS;
758 idx++;
759 }
760}
761
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100762/*
763 * The following functions are used to make correspondance between the the
764 * executed lua pointer and the "struct hlua *" that contain the context.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100765 *
766 * - hlua_gethlua : return the hlua context associated with an lua_State.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100767 * - hlua_sethlua : create the association between hlua context and lua_state.
768 */
769static inline struct hlua *hlua_gethlua(lua_State *L)
770{
Thierry FOURNIER38c5fd62015-03-10 02:40:29 +0100771 struct hlua **hlua = lua_getextraspace(L);
772 return *hlua;
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100773}
774static inline void hlua_sethlua(struct hlua *hlua)
775{
Thierry FOURNIER38c5fd62015-03-10 02:40:29 +0100776 struct hlua **hlua_store = lua_getextraspace(hlua->T);
777 *hlua_store = hlua;
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100778}
779
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100780/* This function is used to send logs. It try to send on screen (stderr)
781 * and on the default syslog server.
782 */
783static inline void hlua_sendlog(struct proxy *px, int level, const char *msg)
784{
785 struct tm tm;
786 char *p;
787
788 /* Cleanup the log message. */
789 p = trash.str;
790 for (; *msg != '\0'; msg++, p++) {
Thierry FOURNIERccf00632015-09-16 12:47:03 +0200791 if (p >= trash.str + trash.size - 1) {
792 /* Break the message if exceed the buffer size. */
793 *(p-4) = ' ';
794 *(p-3) = '.';
795 *(p-2) = '.';
796 *(p-1) = '.';
797 break;
798 }
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100799 if (isprint(*msg))
800 *p = *msg;
801 else
802 *p = '.';
803 }
804 *p = '\0';
805
Thierry FOURNIER5554e292015-09-09 11:21:37 +0200806 send_log(px, level, "%s\n", trash.str);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100807 if (!(global.mode & MODE_QUIET) || (global.mode & (MODE_VERBOSE | MODE_STARTING))) {
Willy Tarreaua678b432015-08-28 10:14:59 +0200808 get_localtime(date.tv_sec, &tm);
809 fprintf(stderr, "[%s] %03d/%02d%02d%02d (%d) : %s\n",
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100810 log_levels[level], tm.tm_yday, tm.tm_hour, tm.tm_min, tm.tm_sec,
811 (int)getpid(), trash.str);
812 fflush(stderr);
813 }
814}
815
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100816/* This function just ensure that the yield will be always
817 * returned with a timeout and permit to set some flags
818 */
819__LJMP void hlua_yieldk(lua_State *L, int nresults, int ctx,
Thierry FOURNIERf90838b2015-03-06 13:48:32 +0100820 lua_KFunction k, int timeout, unsigned int flags)
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100821{
822 struct hlua *hlua = hlua_gethlua(L);
823
824 /* Set the wake timeout. If timeout is required, we set
825 * the expiration time.
826 */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +0200827 hlua->wake_time = timeout;
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100828
Thierry FOURNIER4abd3ae2015-03-03 17:29:06 +0100829 hlua->flags |= flags;
830
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100831 /* Process the yield. */
832 WILL_LJMP(lua_yieldk(L, nresults, ctx, k));
833}
834
Willy Tarreau87b09662015-04-03 00:22:06 +0200835/* This function initialises the Lua environment stored in the stream.
836 * It must be called at the start of the stream. This function creates
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100837 * an LUA coroutine. It can not be use to crete the main LUA context.
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200838 *
839 * This function is particular. it initialises a new Lua thread. If the
840 * initialisation fails (example: out of memory error), the lua function
841 * throws an error (longjmp).
842 *
843 * This function manipulates two Lua stack: the main and the thread. Only
844 * the main stack can fail. The thread is not manipulated. This function
845 * MUST NOT manipulate the created thread stack state, because is not
846 * proctected agains error throwed by the thread stack.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100847 */
848int hlua_ctx_init(struct hlua *lua, struct task *task)
849{
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200850 if (!SET_SAFE_LJMP(gL.T)) {
851 lua->Tref = LUA_REFNIL;
852 return 0;
853 }
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100854 lua->Mref = LUA_REFNIL;
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +0100855 lua->flags = 0;
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100856 LIST_INIT(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100857 lua->T = lua_newthread(gL.T);
858 if (!lua->T) {
859 lua->Tref = LUA_REFNIL;
860 return 0;
861 }
862 hlua_sethlua(lua);
863 lua->Tref = luaL_ref(gL.T, LUA_REGISTRYINDEX);
864 lua->task = task;
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200865 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100866 return 1;
867}
868
Willy Tarreau87b09662015-04-03 00:22:06 +0200869/* Used to destroy the Lua coroutine when the attached stream or task
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100870 * is destroyed. The destroy also the memory context. The struct "lua"
871 * is not freed.
872 */
873void hlua_ctx_destroy(struct hlua *lua)
874{
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +0100875 if (!lua)
Thierry FOURNIERa718b292015-03-04 16:48:34 +0100876 return;
877
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +0100878 if (!lua->T)
879 goto end;
880
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100881 /* Purge all the pending signals. */
Thierry FOURNIER847ca662016-12-16 13:07:22 +0100882 hlua_com_purge(&lua->com);
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100883
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100884 luaL_unref(lua->T, LUA_REGISTRYINDEX, lua->Mref);
885 luaL_unref(gL.T, LUA_REGISTRYINDEX, lua->Tref);
Thierry FOURNIER5a50a852015-09-23 16:59:28 +0200886
887 /* Forces a garbage collecting process. If the Lua program is finished
888 * without error, we run the GC on the thread pointer. Its freed all
889 * the unused memory.
890 * If the thread is finnish with an error or is currently yielded,
891 * it seems that the GC applied on the thread doesn't clean anything,
892 * so e run the GC on the main thread.
893 * NOTE: maybe this action locks all the Lua threads untiml the en of
894 * the garbage collection.
895 */
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +0200896 if (lua->flags & HLUA_MUST_GC) {
897 lua_gc(lua->T, LUA_GCCOLLECT, 0);
898 if (lua_status(lua->T) != LUA_OK)
899 lua_gc(gL.T, LUA_GCCOLLECT, 0);
900 }
Thierry FOURNIER5a50a852015-09-23 16:59:28 +0200901
Thierry FOURNIERa7b536b2015-09-21 22:50:24 +0200902 lua->T = NULL;
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +0100903
904end:
905 pool_free2(pool2_hlua, lua);
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100906}
907
908/* This function is used to restore the Lua context when a coroutine
909 * fails. This function copy the common memory between old coroutine
910 * and the new coroutine. The old coroutine is destroyed, and its
911 * replaced by the new coroutine.
912 * If the flag "keep_msg" is set, the last entry of the old is assumed
913 * as string error message and it is copied in the new stack.
914 */
915static int hlua_ctx_renew(struct hlua *lua, int keep_msg)
916{
917 lua_State *T;
918 int new_ref;
919
920 /* Renew the main LUA stack doesn't have sense. */
921 if (lua == &gL)
922 return 0;
923
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100924 /* New Lua coroutine. */
925 T = lua_newthread(gL.T);
926 if (!T)
927 return 0;
928
929 /* Copy last error message. */
930 if (keep_msg)
931 lua_xmove(lua->T, T, 1);
932
933 /* Copy data between the coroutines. */
934 lua_rawgeti(lua->T, LUA_REGISTRYINDEX, lua->Mref);
935 lua_xmove(lua->T, T, 1);
936 new_ref = luaL_ref(T, LUA_REGISTRYINDEX); /* Valur poped. */
937
938 /* Destroy old data. */
939 luaL_unref(lua->T, LUA_REGISTRYINDEX, lua->Mref);
940
941 /* The thread is garbage collected by Lua. */
942 luaL_unref(gL.T, LUA_REGISTRYINDEX, lua->Tref);
943
944 /* Fill the struct with the new coroutine values. */
945 lua->Mref = new_ref;
946 lua->T = T;
947 lua->Tref = luaL_ref(gL.T, LUA_REGISTRYINDEX);
948
949 /* Set context. */
950 hlua_sethlua(lua);
951
952 return 1;
953}
954
Thierry FOURNIERee9f8022015-03-03 17:37:37 +0100955void hlua_hook(lua_State *L, lua_Debug *ar)
956{
Thierry FOURNIERcae49c92015-03-06 14:05:24 +0100957 struct hlua *hlua = hlua_gethlua(L);
958
959 /* Lua cannot yield when its returning from a function,
960 * so, we can fix the interrupt hook to 1 instruction,
961 * expecting that the function is finnished.
962 */
963 if (lua_gethookmask(L) & LUA_MASKRET) {
964 lua_sethook(hlua->T, hlua_hook, LUA_MASKCOUNT, 1);
965 return;
966 }
967
968 /* restore the interrupt condition. */
969 lua_sethook(hlua->T, hlua_hook, LUA_MASKCOUNT, hlua_nb_instruction);
970
971 /* If we interrupt the Lua processing in yieldable state, we yield.
972 * If the state is not yieldable, trying yield causes an error.
973 */
974 if (lua_isyieldable(L))
975 WILL_LJMP(hlua_yieldk(L, 0, 0, NULL, TICK_ETERNITY, HLUA_CTRLYIELD));
976
Thierry FOURNIERa85cfb12015-03-13 14:50:06 +0100977 /* If we cannot yield, update the clock and check the timeout. */
978 tv_update_date(0, 1);
Thierry FOURNIER10770fa2015-09-29 01:59:42 +0200979 hlua->run_time += now_ms - hlua->start_time;
980 if (hlua->max_time && hlua->run_time >= hlua->max_time) {
Thierry FOURNIERcae49c92015-03-06 14:05:24 +0100981 lua_pushfstring(L, "execution timeout");
982 WILL_LJMP(lua_error(L));
983 }
984
Thierry FOURNIER10770fa2015-09-29 01:59:42 +0200985 /* Update the start time. */
986 hlua->start_time = now_ms;
987
Thierry FOURNIERcae49c92015-03-06 14:05:24 +0100988 /* Try to interrupt the process at the end of the current
989 * unyieldable function.
990 */
991 lua_sethook(hlua->T, hlua_hook, LUA_MASKRET|LUA_MASKCOUNT, hlua_nb_instruction);
Thierry FOURNIERee9f8022015-03-03 17:37:37 +0100992}
993
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100994/* This function start or resumes the Lua stack execution. If the flag
995 * "yield_allowed" if no set and the LUA stack execution returns a yield
996 * The function return an error.
997 *
998 * The function can returns 4 values:
999 * - HLUA_E_OK : The execution is terminated without any errors.
1000 * - HLUA_E_AGAIN : The execution must continue at the next associated
1001 * task wakeup.
1002 * - HLUA_E_ERRMSG : An error has occured, an error message is set in
1003 * the top of the stack.
1004 * - HLUA_E_ERR : An error has occured without error message.
1005 *
1006 * If an error occured, the stack is renewed and it is ready to run new
1007 * LUA code.
1008 */
1009static enum hlua_exec hlua_ctx_resume(struct hlua *lua, int yield_allowed)
1010{
1011 int ret;
1012 const char *msg;
1013
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001014 /* Initialise run time counter. */
1015 if (!HLUA_IS_RUNNING(lua))
1016 lua->run_time = 0;
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001017
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001018resume_execution:
1019
1020 /* This hook interrupts the Lua processing each 'hlua_nb_instruction'
1021 * instructions. it is used for preventing infinite loops.
1022 */
1023 lua_sethook(lua->T, hlua_hook, LUA_MASKCOUNT, hlua_nb_instruction);
1024
Thierry FOURNIER1bfc09b2015-03-05 17:10:14 +01001025 /* Remove all flags except the running flags. */
Thierry FOURNIER2f3867f2015-09-28 01:02:01 +02001026 HLUA_SET_RUN(lua);
1027 HLUA_CLR_CTRLYIELD(lua);
1028 HLUA_CLR_WAKERESWR(lua);
1029 HLUA_CLR_WAKEREQWR(lua);
Thierry FOURNIER1bfc09b2015-03-05 17:10:14 +01001030
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001031 /* Update the start time. */
1032 lua->start_time = now_ms;
1033
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001034 /* Call the function. */
1035 ret = lua_resume(lua->T, gL.T, lua->nargs);
1036 switch (ret) {
1037
1038 case LUA_OK:
1039 ret = HLUA_E_OK;
1040 break;
1041
1042 case LUA_YIELD:
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001043 /* Check if the execution timeout is expired. It it is the case, we
1044 * break the Lua execution.
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001045 */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001046 tv_update_date(0, 1);
1047 lua->run_time += now_ms - lua->start_time;
1048 if (lua->max_time && lua->run_time > lua->max_time) {
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001049 lua_settop(lua->T, 0); /* Empty the stack. */
1050 if (!lua_checkstack(lua->T, 1)) {
1051 ret = HLUA_E_ERR;
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001052 break;
1053 }
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001054 lua_pushfstring(lua->T, "execution timeout");
1055 ret = HLUA_E_ERRMSG;
1056 break;
1057 }
1058 /* Process the forced yield. if the general yield is not allowed or
1059 * if no task were associated this the current Lua execution
1060 * coroutine, we resume the execution. Else we want to return in the
1061 * scheduler and we want to be waked up again, to continue the
1062 * current Lua execution. So we schedule our own task.
1063 */
1064 if (HLUA_IS_CTRLYIELDING(lua)) {
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001065 if (!yield_allowed || !lua->task)
1066 goto resume_execution;
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001067 task_wakeup(lua->task, TASK_WOKEN_MSG);
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001068 }
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001069 if (!yield_allowed) {
1070 lua_settop(lua->T, 0); /* Empty the stack. */
1071 if (!lua_checkstack(lua->T, 1)) {
1072 ret = HLUA_E_ERR;
1073 break;
1074 }
1075 lua_pushfstring(lua->T, "yield not allowed");
1076 ret = HLUA_E_ERRMSG;
1077 break;
1078 }
1079 ret = HLUA_E_AGAIN;
1080 break;
1081
1082 case LUA_ERRRUN:
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001083
1084 /* Special exit case. The traditionnal exit is returned as an error
1085 * because the errors ares the only one mean to return immediately
1086 * from and lua execution.
1087 */
1088 if (lua->flags & HLUA_EXIT) {
1089 ret = HLUA_E_OK;
Thierry FOURNIERe1587b32015-08-28 09:54:13 +02001090 hlua_ctx_renew(lua, 0);
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001091 break;
1092 }
1093
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001094 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001095 if (!lua_checkstack(lua->T, 1)) {
1096 ret = HLUA_E_ERR;
1097 break;
1098 }
1099 msg = lua_tostring(lua->T, -1);
1100 lua_settop(lua->T, 0); /* Empty the stack. */
1101 lua_pop(lua->T, 1);
1102 if (msg)
1103 lua_pushfstring(lua->T, "runtime error: %s", msg);
1104 else
1105 lua_pushfstring(lua->T, "unknown runtime error");
1106 ret = HLUA_E_ERRMSG;
1107 break;
1108
1109 case LUA_ERRMEM:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001110 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001111 lua_settop(lua->T, 0); /* Empty the stack. */
1112 if (!lua_checkstack(lua->T, 1)) {
1113 ret = HLUA_E_ERR;
1114 break;
1115 }
1116 lua_pushfstring(lua->T, "out of memory error");
1117 ret = HLUA_E_ERRMSG;
1118 break;
1119
1120 case LUA_ERRERR:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001121 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001122 if (!lua_checkstack(lua->T, 1)) {
1123 ret = HLUA_E_ERR;
1124 break;
1125 }
1126 msg = lua_tostring(lua->T, -1);
1127 lua_settop(lua->T, 0); /* Empty the stack. */
1128 lua_pop(lua->T, 1);
1129 if (msg)
1130 lua_pushfstring(lua->T, "message handler error: %s", msg);
1131 else
1132 lua_pushfstring(lua->T, "message handler error");
1133 ret = HLUA_E_ERRMSG;
1134 break;
1135
1136 default:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001137 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001138 lua_settop(lua->T, 0); /* Empty the stack. */
1139 if (!lua_checkstack(lua->T, 1)) {
1140 ret = HLUA_E_ERR;
1141 break;
1142 }
1143 lua_pushfstring(lua->T, "unknonwn error");
1144 ret = HLUA_E_ERRMSG;
1145 break;
1146 }
1147
Thierry FOURNIER6ab4d8e2015-09-27 22:17:19 +02001148 /* This GC permits to destroy some object when a Lua timeout strikes. */
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +02001149 if (lua->flags & HLUA_MUST_GC &&
1150 ret != HLUA_E_AGAIN)
Thierry FOURNIER6ab4d8e2015-09-27 22:17:19 +02001151 lua_gc(lua->T, LUA_GCCOLLECT, 0);
1152
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001153 switch (ret) {
1154 case HLUA_E_AGAIN:
1155 break;
1156
1157 case HLUA_E_ERRMSG:
Thierry FOURNIER847ca662016-12-16 13:07:22 +01001158 hlua_com_purge(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001159 hlua_ctx_renew(lua, 1);
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001160 HLUA_CLR_RUN(lua);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001161 break;
1162
1163 case HLUA_E_ERR:
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001164 HLUA_CLR_RUN(lua);
Thierry FOURNIER847ca662016-12-16 13:07:22 +01001165 hlua_com_purge(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001166 hlua_ctx_renew(lua, 0);
1167 break;
1168
1169 case HLUA_E_OK:
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001170 HLUA_CLR_RUN(lua);
Thierry FOURNIER847ca662016-12-16 13:07:22 +01001171 hlua_com_purge(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001172 break;
1173 }
1174
1175 return ret;
1176}
1177
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001178/* This function exit the current code. */
1179__LJMP static int hlua_done(lua_State *L)
1180{
1181 struct hlua *hlua = hlua_gethlua(L);
1182
1183 hlua->flags |= HLUA_EXIT;
1184 WILL_LJMP(lua_error(L));
1185
1186 return 0;
1187}
1188
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001189/* This function is an LUA binding. It provides a function
1190 * for deleting ACL from a referenced ACL file.
1191 */
1192__LJMP static int hlua_del_acl(lua_State *L)
1193{
1194 const char *name;
1195 const char *key;
1196 struct pat_ref *ref;
1197
1198 MAY_LJMP(check_args(L, 2, "del_acl"));
1199
1200 name = MAY_LJMP(luaL_checkstring(L, 1));
1201 key = MAY_LJMP(luaL_checkstring(L, 2));
1202
1203 ref = pat_ref_lookup(name);
1204 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001205 WILL_LJMP(luaL_error(L, "'del_acl': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001206
1207 pat_ref_delete(ref, key);
1208 return 0;
1209}
1210
1211/* This function is an LUA binding. It provides a function
1212 * for deleting map entry from a referenced map file.
1213 */
1214static int hlua_del_map(lua_State *L)
1215{
1216 const char *name;
1217 const char *key;
1218 struct pat_ref *ref;
1219
1220 MAY_LJMP(check_args(L, 2, "del_map"));
1221
1222 name = MAY_LJMP(luaL_checkstring(L, 1));
1223 key = MAY_LJMP(luaL_checkstring(L, 2));
1224
1225 ref = pat_ref_lookup(name);
1226 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001227 WILL_LJMP(luaL_error(L, "'del_map': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001228
1229 pat_ref_delete(ref, key);
1230 return 0;
1231}
1232
1233/* This function is an LUA binding. It provides a function
1234 * for adding ACL pattern from a referenced ACL file.
1235 */
1236static int hlua_add_acl(lua_State *L)
1237{
1238 const char *name;
1239 const char *key;
1240 struct pat_ref *ref;
1241
1242 MAY_LJMP(check_args(L, 2, "add_acl"));
1243
1244 name = MAY_LJMP(luaL_checkstring(L, 1));
1245 key = MAY_LJMP(luaL_checkstring(L, 2));
1246
1247 ref = pat_ref_lookup(name);
1248 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001249 WILL_LJMP(luaL_error(L, "'add_acl': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001250
1251 if (pat_ref_find_elt(ref, key) == NULL)
1252 pat_ref_add(ref, key, NULL, NULL);
1253 return 0;
1254}
1255
1256/* This function is an LUA binding. It provides a function
1257 * for setting map pattern and sample from a referenced map
1258 * file.
1259 */
1260static int hlua_set_map(lua_State *L)
1261{
1262 const char *name;
1263 const char *key;
1264 const char *value;
1265 struct pat_ref *ref;
1266
1267 MAY_LJMP(check_args(L, 3, "set_map"));
1268
1269 name = MAY_LJMP(luaL_checkstring(L, 1));
1270 key = MAY_LJMP(luaL_checkstring(L, 2));
1271 value = MAY_LJMP(luaL_checkstring(L, 3));
1272
1273 ref = pat_ref_lookup(name);
1274 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001275 WILL_LJMP(luaL_error(L, "'set_map': unknown map file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001276
1277 if (pat_ref_find_elt(ref, key) != NULL)
1278 pat_ref_set(ref, key, value, NULL);
1279 else
1280 pat_ref_add(ref, key, value, NULL);
1281 return 0;
1282}
1283
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01001284/* A class is a lot of memory that contain data. This data can be a table,
1285 * an integer or user data. This data is associated with a metatable. This
1286 * metatable have an original version registred in the global context with
1287 * the name of the object (_G[<name>] = <metable> ).
1288 *
1289 * A metable is a table that modify the standard behavior of a standard
1290 * access to the associated data. The entries of this new metatable are
1291 * defined as is:
1292 *
1293 * http://lua-users.org/wiki/MetatableEvents
1294 *
1295 * __index
1296 *
1297 * we access an absent field in a table, the result is nil. This is
1298 * true, but it is not the whole truth. Actually, such access triggers
1299 * the interpreter to look for an __index metamethod: If there is no
1300 * such method, as usually happens, then the access results in nil;
1301 * otherwise, the metamethod will provide the result.
1302 *
1303 * Control 'prototype' inheritance. When accessing "myTable[key]" and
1304 * the key does not appear in the table, but the metatable has an __index
1305 * property:
1306 *
1307 * - if the value is a function, the function is called, passing in the
1308 * table and the key; the return value of that function is returned as
1309 * the result.
1310 *
1311 * - if the value is another table, the value of the key in that table is
1312 * asked for and returned (and if it doesn't exist in that table, but that
1313 * table's metatable has an __index property, then it continues on up)
1314 *
1315 * - Use "rawget(myTable,key)" to skip this metamethod.
1316 *
1317 * http://www.lua.org/pil/13.4.1.html
1318 *
1319 * __newindex
1320 *
1321 * Like __index, but control property assignment.
1322 *
1323 * __mode - Control weak references. A string value with one or both
1324 * of the characters 'k' and 'v' which specifies that the the
1325 * keys and/or values in the table are weak references.
1326 *
1327 * __call - Treat a table like a function. When a table is followed by
1328 * parenthesis such as "myTable( 'foo' )" and the metatable has
1329 * a __call key pointing to a function, that function is invoked
1330 * (passing any specified arguments) and the return value is
1331 * returned.
1332 *
1333 * __metatable - Hide the metatable. When "getmetatable( myTable )" is
1334 * called, if the metatable for myTable has a __metatable
1335 * key, the value of that key is returned instead of the
1336 * actual metatable.
1337 *
1338 * __tostring - Control string representation. When the builtin
1339 * "tostring( myTable )" function is called, if the metatable
1340 * for myTable has a __tostring property set to a function,
1341 * that function is invoked (passing myTable to it) and the
1342 * return value is used as the string representation.
1343 *
1344 * __len - Control table length. When the table length is requested using
1345 * the length operator ( '#' ), if the metatable for myTable has
1346 * a __len key pointing to a function, that function is invoked
1347 * (passing myTable to it) and the return value used as the value
1348 * of "#myTable".
1349 *
1350 * __gc - Userdata finalizer code. When userdata is set to be garbage
1351 * collected, if the metatable has a __gc field pointing to a
1352 * function, that function is first invoked, passing the userdata
1353 * to it. The __gc metamethod is not called for tables.
1354 * (See http://lua-users.org/lists/lua-l/2006-11/msg00508.html)
1355 *
1356 * Special metamethods for redefining standard operators:
1357 * http://www.lua.org/pil/13.1.html
1358 *
1359 * __add "+"
1360 * __sub "-"
1361 * __mul "*"
1362 * __div "/"
1363 * __unm "!"
1364 * __pow "^"
1365 * __concat ".."
1366 *
1367 * Special methods for redfining standar relations
1368 * http://www.lua.org/pil/13.2.html
1369 *
1370 * __eq "=="
1371 * __lt "<"
1372 * __le "<="
1373 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001374
1375/*
1376 *
1377 *
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001378 * Class Map
1379 *
1380 *
1381 */
1382
1383/* Returns a struct hlua_map if the stack entry "ud" is
1384 * a class session, otherwise it throws an error.
1385 */
1386__LJMP static struct map_descriptor *hlua_checkmap(lua_State *L, int ud)
1387{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02001388 return MAY_LJMP(hlua_checkudata(L, ud, class_map_ref));
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001389}
1390
1391/* This function is the map constructor. It don't need
1392 * the class Map object. It creates and return a new Map
1393 * object. It must be called only during "body" or "init"
1394 * context because it process some filesystem accesses.
1395 */
1396__LJMP static int hlua_map_new(struct lua_State *L)
1397{
1398 const char *fn;
1399 int match = PAT_MATCH_STR;
1400 struct sample_conv conv;
1401 const char *file = "";
1402 int line = 0;
1403 lua_Debug ar;
1404 char *err = NULL;
1405 struct arg args[2];
1406
1407 if (lua_gettop(L) < 1 || lua_gettop(L) > 2)
1408 WILL_LJMP(luaL_error(L, "'new' needs at least 1 argument."));
1409
1410 fn = MAY_LJMP(luaL_checkstring(L, 1));
1411
1412 if (lua_gettop(L) >= 2) {
1413 match = MAY_LJMP(luaL_checkinteger(L, 2));
1414 if (match < 0 || match >= PAT_MATCH_NUM)
1415 WILL_LJMP(luaL_error(L, "'new' needs a valid match method."));
1416 }
1417
1418 /* Get Lua filename and line number. */
1419 if (lua_getstack(L, 1, &ar)) { /* check function at level */
1420 lua_getinfo(L, "Sl", &ar); /* get info about it */
1421 if (ar.currentline > 0) { /* is there info? */
1422 file = ar.short_src;
1423 line = ar.currentline;
1424 }
1425 }
1426
1427 /* fill fake sample_conv struct. */
1428 conv.kw = ""; /* unused. */
1429 conv.process = NULL; /* unused. */
1430 conv.arg_mask = 0; /* unused. */
1431 conv.val_args = NULL; /* unused. */
1432 conv.out_type = SMP_T_STR;
1433 conv.private = (void *)(long)match;
1434 switch (match) {
1435 case PAT_MATCH_STR: conv.in_type = SMP_T_STR; break;
1436 case PAT_MATCH_BEG: conv.in_type = SMP_T_STR; break;
1437 case PAT_MATCH_SUB: conv.in_type = SMP_T_STR; break;
1438 case PAT_MATCH_DIR: conv.in_type = SMP_T_STR; break;
1439 case PAT_MATCH_DOM: conv.in_type = SMP_T_STR; break;
1440 case PAT_MATCH_END: conv.in_type = SMP_T_STR; break;
1441 case PAT_MATCH_REG: conv.in_type = SMP_T_STR; break;
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001442 case PAT_MATCH_INT: conv.in_type = SMP_T_SINT; break;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001443 case PAT_MATCH_IP: conv.in_type = SMP_T_ADDR; break;
1444 default:
1445 WILL_LJMP(luaL_error(L, "'new' doesn't support this match mode."));
1446 }
1447
1448 /* fill fake args. */
1449 args[0].type = ARGT_STR;
1450 args[0].data.str.str = (char *)fn;
1451 args[1].type = ARGT_STOP;
1452
1453 /* load the map. */
1454 if (!sample_load_map(args, &conv, file, line, &err)) {
1455 /* error case: we cant use luaL_error because we must
1456 * free the err variable.
1457 */
1458 luaL_where(L, 1);
1459 lua_pushfstring(L, "'new': %s.", err);
1460 lua_concat(L, 2);
1461 free(err);
1462 WILL_LJMP(lua_error(L));
1463 }
1464
1465 /* create the lua object. */
1466 lua_newtable(L);
1467 lua_pushlightuserdata(L, args[0].data.map);
1468 lua_rawseti(L, -2, 0);
1469
1470 /* Pop a class Map metatable and affect it to the userdata. */
1471 lua_rawgeti(L, LUA_REGISTRYINDEX, class_map_ref);
1472 lua_setmetatable(L, -2);
1473
1474
1475 return 1;
1476}
1477
1478__LJMP static inline int _hlua_map_lookup(struct lua_State *L, int str)
1479{
1480 struct map_descriptor *desc;
1481 struct pattern *pat;
1482 struct sample smp;
1483
1484 MAY_LJMP(check_args(L, 2, "lookup"));
1485 desc = MAY_LJMP(hlua_checkmap(L, 1));
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001486 if (desc->pat.expect_type == SMP_T_SINT) {
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001487 smp.data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001488 smp.data.u.sint = MAY_LJMP(luaL_checkinteger(L, 2));
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001489 }
1490 else {
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001491 smp.data.type = SMP_T_STR;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001492 smp.flags = SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001493 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 +02001494 }
1495
1496 pat = pattern_exec_match(&desc->pat, &smp, 1);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001497 if (!pat || !pat->data) {
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001498 if (str)
1499 lua_pushstring(L, "");
1500 else
1501 lua_pushnil(L);
1502 return 1;
1503 }
1504
1505 /* The Lua pattern must return a string, so we can't check the returned type */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001506 lua_pushlstring(L, pat->data->u.str.str, pat->data->u.str.len);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001507 return 1;
1508}
1509
1510__LJMP static int hlua_map_lookup(struct lua_State *L)
1511{
1512 return _hlua_map_lookup(L, 0);
1513}
1514
1515__LJMP static int hlua_map_slookup(struct lua_State *L)
1516{
1517 return _hlua_map_lookup(L, 1);
1518}
1519
1520/*
1521 *
1522 *
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001523 * Class Socket
1524 *
1525 *
1526 */
1527
1528__LJMP static struct hlua_socket *hlua_checksocket(lua_State *L, int ud)
1529{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02001530 return MAY_LJMP(hlua_checkudata(L, ud, class_socket_ref));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001531}
1532
1533/* This function is the handler called for each I/O on the established
1534 * connection. It is used for notify space avalaible to send or data
1535 * received.
1536 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02001537static void hlua_socket_handler(struct appctx *appctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001538{
Willy Tarreau00a37f02015-04-13 12:05:19 +02001539 struct stream_interface *si = appctx->owner;
Willy Tarreau50fe03b2014-11-28 13:59:31 +01001540 struct connection *c = objt_conn(si_opposite(si)->end);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001541
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001542 /* If the connection object is not avalaible, close all the
1543 * streams and wakeup everithing waiting for.
1544 */
1545 if (!c) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001546 si_shutw(si);
1547 si_shutr(si);
Willy Tarreau2bb4a962014-11-28 11:11:05 +01001548 si_ic(si)->flags |= CF_READ_NULL;
Thierry FOURNIER18d09902016-12-16 09:25:38 +01001549 hlua_com_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1550 hlua_com_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Willy Tarreaud4da1962015-04-20 01:31:23 +02001551 return;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001552 }
1553
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001554 /* If we cant write, wakeup the pending write signals. */
1555 if (channel_output_closed(si_ic(si)))
Thierry FOURNIER18d09902016-12-16 09:25:38 +01001556 hlua_com_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001557
1558 /* If we cant read, wakeup the pending read signals. */
1559 if (channel_input_closed(si_oc(si)))
Thierry FOURNIER18d09902016-12-16 09:25:38 +01001560 hlua_com_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001561
Thierry FOURNIER316e3192015-09-04 18:25:53 +02001562 /* if the connection is not estabkished, inform the stream that we want
1563 * to be notified whenever the connection completes.
1564 */
1565 if (!(c->flags & CO_FL_CONNECTED)) {
1566 si_applet_cant_get(si);
1567 si_applet_cant_put(si);
Willy Tarreaud4da1962015-04-20 01:31:23 +02001568 return;
Thierry FOURNIER316e3192015-09-04 18:25:53 +02001569 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001570
1571 /* This function is called after the connect. */
Thierry FOURNIER18d09902016-12-16 09:25:38 +01001572 appctx->ctx.hlua_cosocket.connected = 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001573
1574 /* Wake the tasks which wants to write if the buffer have avalaible space. */
Thierry FOURNIEReba6f642015-09-26 22:01:07 +02001575 if (channel_may_recv(si_ic(si)))
Thierry FOURNIER18d09902016-12-16 09:25:38 +01001576 hlua_com_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001577
1578 /* Wake the tasks which wants to read if the buffer contains data. */
Thierry FOURNIEReba6f642015-09-26 22:01:07 +02001579 if (!channel_is_empty(si_oc(si)))
Thierry FOURNIER18d09902016-12-16 09:25:38 +01001580 hlua_com_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001581}
1582
Willy Tarreau87b09662015-04-03 00:22:06 +02001583/* This function is called when the "struct stream" is destroyed.
1584 * Remove the link from the object to this stream.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001585 * Wake all the pending signals.
1586 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02001587static void hlua_socket_release(struct appctx *appctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001588{
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001589 /* Remove my link in the original object. */
Thierry FOURNIER18d09902016-12-16 09:25:38 +01001590 if (appctx->ctx.hlua_cosocket.socket)
1591 appctx->ctx.hlua_cosocket.socket->s = NULL;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001592
1593 /* Wake all the task waiting for me. */
Thierry FOURNIER18d09902016-12-16 09:25:38 +01001594 hlua_com_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1595 hlua_com_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001596}
1597
1598/* If the garbage collectio of the object is launch, nobody
Willy Tarreau87b09662015-04-03 00:22:06 +02001599 * uses this object. If the stream does not exists, just quit.
1600 * Send the shutdown signal to the stream. In some cases,
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001601 * pending signal can rest in the read and write lists. destroy
1602 * it.
1603 */
1604__LJMP static int hlua_socket_gc(lua_State *L)
1605{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001606 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001607 struct appctx *appctx;
1608
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001609 MAY_LJMP(check_args(L, 1, "__gc"));
1610
1611 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001612 if (!socket->s)
1613 return 0;
1614
Willy Tarreau87b09662015-04-03 00:22:06 +02001615 /* Remove all reference between the Lua stack and the coroutine stream. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001616 appctx = objt_appctx(socket->s->si[0].end);
Willy Tarreaue7dff022015-04-03 01:14:29 +02001617 stream_shutdown(socket->s, SF_ERR_KILLED);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001618 socket->s = NULL;
Thierry FOURNIER18d09902016-12-16 09:25:38 +01001619 appctx->ctx.hlua_cosocket.socket = NULL;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001620
1621 return 0;
1622}
1623
1624/* The close function send shutdown signal and break the
Willy Tarreau87b09662015-04-03 00:22:06 +02001625 * links between the stream and the object.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001626 */
1627__LJMP static int hlua_socket_close(lua_State *L)
1628{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001629 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001630 struct appctx *appctx;
1631
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001632 MAY_LJMP(check_args(L, 1, "close"));
1633
1634 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001635 if (!socket->s)
1636 return 0;
1637
Willy Tarreau87b09662015-04-03 00:22:06 +02001638 /* Close the stream and remove the associated stop task. */
Willy Tarreaue7dff022015-04-03 01:14:29 +02001639 stream_shutdown(socket->s, SF_ERR_KILLED);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001640 appctx = objt_appctx(socket->s->si[0].end);
Thierry FOURNIER18d09902016-12-16 09:25:38 +01001641 appctx->ctx.hlua_cosocket.socket = NULL;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001642 socket->s = NULL;
1643
1644 return 0;
1645}
1646
1647/* This Lua function assumes that the stack contain three parameters.
1648 * 1 - USERDATA containing a struct socket
1649 * 2 - INTEGER with values of the macro defined below
1650 * If the integer is -1, we must read at most one line.
1651 * If the integer is -2, we ust read all the data until the
1652 * end of the stream.
1653 * If the integer is positive value, we must read a number of
1654 * bytes corresponding to this value.
1655 */
1656#define HLSR_READ_LINE (-1)
1657#define HLSR_READ_ALL (-2)
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001658__LJMP static int hlua_socket_receive_yield(struct lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001659{
1660 struct hlua_socket *socket = MAY_LJMP(hlua_checksocket(L, 1));
1661 int wanted = lua_tointeger(L, 2);
1662 struct hlua *hlua = hlua_gethlua(L);
1663 struct appctx *appctx;
1664 int len;
1665 int nblk;
1666 char *blk1;
1667 int len1;
1668 char *blk2;
1669 int len2;
Thierry FOURNIER00543922015-03-09 18:35:06 +01001670 int skip_at_end = 0;
Willy Tarreau81389672015-03-10 12:03:52 +01001671 struct channel *oc;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001672
1673 /* Check if this lua stack is schedulable. */
1674 if (!hlua || !hlua->task)
1675 WILL_LJMP(luaL_error(L, "The 'receive' function is only allowed in "
1676 "'frontend', 'backend' or 'task'"));
1677
1678 /* check for connection closed. If some data where read, return it. */
1679 if (!socket->s)
1680 goto connection_closed;
1681
Willy Tarreau94aa6172015-03-13 14:19:06 +01001682 oc = &socket->s->res;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001683 if (wanted == HLSR_READ_LINE) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001684 /* Read line. */
Willy Tarreau81389672015-03-10 12:03:52 +01001685 nblk = bo_getline_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001686 if (nblk < 0) /* Connection close. */
1687 goto connection_closed;
1688 if (nblk == 0) /* No data avalaible. */
1689 goto connection_empty;
Thierry FOURNIER00543922015-03-09 18:35:06 +01001690
1691 /* remove final \r\n. */
1692 if (nblk == 1) {
1693 if (blk1[len1-1] == '\n') {
1694 len1--;
1695 skip_at_end++;
1696 if (blk1[len1-1] == '\r') {
1697 len1--;
1698 skip_at_end++;
1699 }
1700 }
1701 }
1702 else {
1703 if (blk2[len2-1] == '\n') {
1704 len2--;
1705 skip_at_end++;
1706 if (blk2[len2-1] == '\r') {
1707 len2--;
1708 skip_at_end++;
1709 }
1710 }
1711 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001712 }
1713
1714 else if (wanted == HLSR_READ_ALL) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001715 /* Read all the available data. */
Willy Tarreau81389672015-03-10 12:03:52 +01001716 nblk = bo_getblk_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001717 if (nblk < 0) /* Connection close. */
1718 goto connection_closed;
1719 if (nblk == 0) /* No data avalaible. */
1720 goto connection_empty;
1721 }
1722
1723 else {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001724 /* Read a block of data. */
Willy Tarreau81389672015-03-10 12:03:52 +01001725 nblk = bo_getblk_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001726 if (nblk < 0) /* Connection close. */
1727 goto connection_closed;
1728 if (nblk == 0) /* No data avalaible. */
1729 goto connection_empty;
1730
1731 if (len1 > wanted) {
1732 nblk = 1;
1733 len1 = wanted;
1734 } if (nblk == 2 && len1 + len2 > wanted)
1735 len2 = wanted - len1;
1736 }
1737
1738 len = len1;
1739
1740 luaL_addlstring(&socket->b, blk1, len1);
1741 if (nblk == 2) {
1742 len += len2;
1743 luaL_addlstring(&socket->b, blk2, len2);
1744 }
1745
1746 /* Consume data. */
Willy Tarreau81389672015-03-10 12:03:52 +01001747 bo_skip(oc, len + skip_at_end);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001748
1749 /* Don't wait anything. */
Willy Tarreaude70fa12015-09-26 11:25:05 +02001750 stream_int_notify(&socket->s->si[0]);
1751 stream_int_update_applet(&socket->s->si[0]);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001752
1753 /* If the pattern reclaim to read all the data
1754 * in the connection, got out.
1755 */
1756 if (wanted == HLSR_READ_ALL)
1757 goto connection_empty;
1758 else if (wanted >= 0 && len < wanted)
1759 goto connection_empty;
1760
1761 /* Return result. */
1762 luaL_pushresult(&socket->b);
1763 return 1;
1764
1765connection_closed:
1766
1767 /* If the buffer containds data. */
1768 if (socket->b.n > 0) {
1769 luaL_pushresult(&socket->b);
1770 return 1;
1771 }
1772 lua_pushnil(L);
1773 lua_pushstring(L, "connection closed.");
1774 return 2;
1775
1776connection_empty:
1777
1778 appctx = objt_appctx(socket->s->si[0].end);
Thierry FOURNIER847ca662016-12-16 13:07:22 +01001779 if (!hlua_com_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_read, hlua->task))
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001780 WILL_LJMP(luaL_error(L, "out of memory"));
Thierry FOURNIER4abd3ae2015-03-03 17:29:06 +01001781 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_receive_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001782 return 0;
1783}
1784
1785/* This Lus function gets two parameters. The first one can be string
1786 * or a number. If the string is "*l", the user require one line. If
1787 * the string is "*a", the user require all the content of the stream.
1788 * If the value is a number, the user require a number of bytes equal
1789 * to the value. The default value is "*l" (a line).
1790 *
1791 * This paraeter with a variable type is converted in integer. This
1792 * integer takes this values:
1793 * -1 : read a line
1794 * -2 : read all the stream
1795 * >0 : amount if bytes.
1796 *
1797 * The second parameter is optinal. It contains a string that must be
1798 * concatenated with the read data.
1799 */
1800__LJMP static int hlua_socket_receive(struct lua_State *L)
1801{
1802 int wanted = HLSR_READ_LINE;
1803 const char *pattern;
1804 int type;
1805 char *error;
1806 size_t len;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001807 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001808
1809 if (lua_gettop(L) < 1 || lua_gettop(L) > 3)
1810 WILL_LJMP(luaL_error(L, "The 'receive' function requires between 1 and 3 arguments."));
1811
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001812 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001813
1814 /* check for pattern. */
1815 if (lua_gettop(L) >= 2) {
1816 type = lua_type(L, 2);
1817 if (type == LUA_TSTRING) {
1818 pattern = lua_tostring(L, 2);
1819 if (strcmp(pattern, "*a") == 0)
1820 wanted = HLSR_READ_ALL;
1821 else if (strcmp(pattern, "*l") == 0)
1822 wanted = HLSR_READ_LINE;
1823 else {
1824 wanted = strtoll(pattern, &error, 10);
1825 if (*error != '\0')
1826 WILL_LJMP(luaL_error(L, "Unsupported pattern."));
1827 }
1828 }
1829 else if (type == LUA_TNUMBER) {
1830 wanted = lua_tointeger(L, 2);
1831 if (wanted < 0)
1832 WILL_LJMP(luaL_error(L, "Unsupported size."));
1833 }
1834 }
1835
1836 /* Set pattern. */
1837 lua_pushinteger(L, wanted);
1838 lua_replace(L, 2);
1839
1840 /* init bufffer, and fiil it wih prefix. */
1841 luaL_buffinit(L, &socket->b);
1842
1843 /* Check prefix. */
1844 if (lua_gettop(L) >= 3) {
1845 if (lua_type(L, 3) != LUA_TSTRING)
1846 WILL_LJMP(luaL_error(L, "Expect a 'string' for the prefix"));
1847 pattern = lua_tolstring(L, 3, &len);
1848 luaL_addlstring(&socket->b, pattern, len);
1849 }
1850
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001851 return __LJMP(hlua_socket_receive_yield(L, 0, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001852}
1853
1854/* Write the Lua input string in the output buffer.
1855 * This fucntion returns a yield if no space are available.
1856 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001857static int hlua_socket_write_yield(struct lua_State *L,int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001858{
1859 struct hlua_socket *socket;
1860 struct hlua *hlua = hlua_gethlua(L);
1861 struct appctx *appctx;
1862 size_t buf_len;
1863 const char *buf;
1864 int len;
1865 int send_len;
1866 int sent;
1867
1868 /* Check if this lua stack is schedulable. */
1869 if (!hlua || !hlua->task)
1870 WILL_LJMP(luaL_error(L, "The 'write' function is only allowed in "
1871 "'frontend', 'backend' or 'task'"));
1872
1873 /* Get object */
1874 socket = MAY_LJMP(hlua_checksocket(L, 1));
1875 buf = MAY_LJMP(luaL_checklstring(L, 2, &buf_len));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001876 sent = MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001877
1878 /* Check for connection close. */
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01001879 if (!socket->s || channel_output_closed(&socket->s->req)) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001880 lua_pushinteger(L, -1);
1881 return 1;
1882 }
1883
1884 /* Update the input buffer data. */
1885 buf += sent;
1886 send_len = buf_len - sent;
1887
1888 /* All the data are sent. */
1889 if (sent >= buf_len)
1890 return 1; /* Implicitly return the length sent. */
1891
Thierry FOURNIER486d52a2015-03-09 17:51:43 +01001892 /* Check if the buffer is avalaible because HAProxy doesn't allocate
1893 * the request buffer if its not required.
1894 */
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01001895 if (socket->s->req.buf->size == 0) {
Christopher Faulet33834b12016-12-19 09:29:06 +01001896 appctx = hlua->task->context;
1897 if (!channel_alloc_buffer(&socket->s->req, &appctx->buffer_wait))
1898 goto hlua_socket_write_yield_return;
Thierry FOURNIER486d52a2015-03-09 17:51:43 +01001899 }
1900
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001901 /* Check for avalaible space. */
Willy Tarreau94aa6172015-03-13 14:19:06 +01001902 len = buffer_total_space(socket->s->req.buf);
Christopher Faulet33834b12016-12-19 09:29:06 +01001903 if (len <= 0) {
1904 appctx = objt_appctx(socket->s->si[0].end);
1905 if (!hlua_com_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task))
1906 WILL_LJMP(luaL_error(L, "out of memory"));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001907 goto hlua_socket_write_yield_return;
Christopher Faulet33834b12016-12-19 09:29:06 +01001908 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001909
1910 /* send data */
1911 if (len < send_len)
1912 send_len = len;
Willy Tarreau94aa6172015-03-13 14:19:06 +01001913 len = bi_putblk(&socket->s->req, buf+sent, send_len);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001914
1915 /* "Not enough space" (-1), "Buffer too little to contain
1916 * the data" (-2) are not expected because the available length
1917 * is tested.
1918 * Other unknown error are also not expected.
1919 */
1920 if (len <= 0) {
Willy Tarreaubc18da12015-03-13 14:00:47 +01001921 if (len == -1)
Willy Tarreau94aa6172015-03-13 14:19:06 +01001922 socket->s->req.flags |= CF_WAKE_WRITE;
Willy Tarreaubc18da12015-03-13 14:00:47 +01001923
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001924 MAY_LJMP(hlua_socket_close(L));
1925 lua_pop(L, 1);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001926 lua_pushinteger(L, -1);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001927 return 1;
1928 }
1929
1930 /* update buffers. */
Willy Tarreaude70fa12015-09-26 11:25:05 +02001931 stream_int_notify(&socket->s->si[0]);
1932 stream_int_update_applet(&socket->s->si[0]);
1933
Willy Tarreau94aa6172015-03-13 14:19:06 +01001934 socket->s->req.rex = TICK_ETERNITY;
1935 socket->s->res.wex = TICK_ETERNITY;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001936
1937 /* Update length sent. */
1938 lua_pop(L, 1);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001939 lua_pushinteger(L, sent + len);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001940
1941 /* All the data buffer is sent ? */
1942 if (sent + len >= buf_len)
1943 return 1;
1944
1945hlua_socket_write_yield_return:
Thierry FOURNIER4abd3ae2015-03-03 17:29:06 +01001946 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_write_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001947 return 0;
1948}
1949
1950/* This function initiate the send of data. It just check the input
1951 * parameters and push an integer in the Lua stack that contain the
1952 * amount of data writed in the buffer. This is used by the function
1953 * "hlua_socket_write_yield" that can yield.
1954 *
1955 * The Lua function gets between 3 and 4 parameters. The first one is
1956 * the associated object. The second is a string buffer. The third is
1957 * a facultative integer that represents where is the buffer position
1958 * of the start of the data that can send. The first byte is the
1959 * position "1". The default value is "1". The fourth argument is a
1960 * facultative integer that represents where is the buffer position
1961 * of the end of the data that can send. The default is the last byte.
1962 */
1963static int hlua_socket_send(struct lua_State *L)
1964{
1965 int i;
1966 int j;
1967 const char *buf;
1968 size_t buf_len;
1969
1970 /* Check number of arguments. */
1971 if (lua_gettop(L) < 2 || lua_gettop(L) > 4)
1972 WILL_LJMP(luaL_error(L, "'send' needs between 2 and 4 arguments"));
1973
1974 /* Get the string. */
1975 buf = MAY_LJMP(luaL_checklstring(L, 2, &buf_len));
1976
1977 /* Get and check j. */
1978 if (lua_gettop(L) == 4) {
1979 j = MAY_LJMP(luaL_checkinteger(L, 4));
1980 if (j < 0)
1981 j = buf_len + j + 1;
1982 if (j > buf_len)
1983 j = buf_len + 1;
1984 lua_pop(L, 1);
1985 }
1986 else
1987 j = buf_len;
1988
1989 /* Get and check i. */
1990 if (lua_gettop(L) == 3) {
1991 i = MAY_LJMP(luaL_checkinteger(L, 3));
1992 if (i < 0)
1993 i = buf_len + i + 1;
1994 if (i > buf_len)
1995 i = buf_len + 1;
1996 lua_pop(L, 1);
1997 } else
1998 i = 1;
1999
2000 /* Check bth i and j. */
2001 if (i > j) {
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002002 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002003 return 1;
2004 }
2005 if (i == 0 && j == 0) {
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002006 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002007 return 1;
2008 }
2009 if (i == 0)
2010 i = 1;
2011 if (j == 0)
2012 j = 1;
2013
2014 /* Pop the string. */
2015 lua_pop(L, 1);
2016
2017 /* Update the buffer length. */
2018 buf += i - 1;
2019 buf_len = j - i + 1;
2020 lua_pushlstring(L, buf, buf_len);
2021
2022 /* This unsigned is used to remember the amount of sent data. */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002023 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002024
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002025 return MAY_LJMP(hlua_socket_write_yield(L, 0, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002026}
2027
Willy Tarreau22b0a682015-06-17 19:43:49 +02002028#define SOCKET_INFO_MAX_LEN sizeof("[0000:0000:0000:0000:0000:0000:0000:0000]:12345")
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002029__LJMP static inline int hlua_socket_info(struct lua_State *L, struct sockaddr_storage *addr)
2030{
2031 static char buffer[SOCKET_INFO_MAX_LEN];
2032 int ret;
2033 int len;
2034 char *p;
2035
2036 ret = addr_to_str(addr, buffer+1, SOCKET_INFO_MAX_LEN-1);
2037 if (ret <= 0) {
2038 lua_pushnil(L);
2039 return 1;
2040 }
2041
2042 if (ret == AF_UNIX) {
2043 lua_pushstring(L, buffer+1);
2044 return 1;
2045 }
2046 else if (ret == AF_INET6) {
2047 buffer[0] = '[';
2048 len = strlen(buffer);
2049 buffer[len] = ']';
2050 len++;
2051 buffer[len] = ':';
2052 len++;
2053 p = buffer;
2054 }
2055 else if (ret == AF_INET) {
2056 p = buffer + 1;
2057 len = strlen(p);
2058 p[len] = ':';
2059 len++;
2060 }
2061 else {
2062 lua_pushnil(L);
2063 return 1;
2064 }
2065
2066 if (port_to_str(addr, p + len, SOCKET_INFO_MAX_LEN-1 - len) <= 0) {
2067 lua_pushnil(L);
2068 return 1;
2069 }
2070
2071 lua_pushstring(L, p);
2072 return 1;
2073}
2074
2075/* Returns information about the peer of the connection. */
2076__LJMP static int hlua_socket_getpeername(struct lua_State *L)
2077{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002078 struct hlua_socket *socket;
2079 struct connection *conn;
2080
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002081 MAY_LJMP(check_args(L, 1, "getpeername"));
2082
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002083 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002084
2085 /* Check if the tcp object is avalaible. */
2086 if (!socket->s) {
2087 lua_pushnil(L);
2088 return 1;
2089 }
2090
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002091 conn = objt_conn(socket->s->si[1].end);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002092 if (!conn) {
2093 lua_pushnil(L);
2094 return 1;
2095 }
2096
Willy Tarreaua71f6422016-11-16 17:00:14 +01002097 conn_get_to_addr(conn);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002098 if (!(conn->flags & CO_FL_ADDR_TO_SET)) {
Willy Tarreaua71f6422016-11-16 17:00:14 +01002099 lua_pushnil(L);
2100 return 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002101 }
2102
2103 return MAY_LJMP(hlua_socket_info(L, &conn->addr.to));
2104}
2105
2106/* Returns information about my connection side. */
2107static int hlua_socket_getsockname(struct lua_State *L)
2108{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002109 struct hlua_socket *socket;
2110 struct connection *conn;
2111
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002112 MAY_LJMP(check_args(L, 1, "getsockname"));
2113
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002114 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002115
2116 /* Check if the tcp object is avalaible. */
2117 if (!socket->s) {
2118 lua_pushnil(L);
2119 return 1;
2120 }
2121
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002122 conn = objt_conn(socket->s->si[1].end);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002123 if (!conn) {
2124 lua_pushnil(L);
2125 return 1;
2126 }
2127
Willy Tarreaua71f6422016-11-16 17:00:14 +01002128 conn_get_from_addr(conn);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002129 if (!(conn->flags & CO_FL_ADDR_FROM_SET)) {
Willy Tarreaua71f6422016-11-16 17:00:14 +01002130 lua_pushnil(L);
2131 return 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002132 }
2133
2134 return hlua_socket_info(L, &conn->addr.from);
2135}
2136
2137/* This struct define the applet. */
Willy Tarreau30576452015-04-13 13:50:30 +02002138static struct applet update_applet = {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002139 .obj_type = OBJ_TYPE_APPLET,
2140 .name = "<LUA_TCP>",
2141 .fct = hlua_socket_handler,
2142 .release = hlua_socket_release,
2143};
2144
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002145__LJMP static int hlua_socket_connect_yield(struct lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002146{
2147 struct hlua_socket *socket = MAY_LJMP(hlua_checksocket(L, 1));
2148 struct hlua *hlua = hlua_gethlua(L);
2149 struct appctx *appctx;
2150
2151 /* Check for connection close. */
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01002152 if (!hlua || !socket->s || channel_output_closed(&socket->s->req)) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002153 lua_pushnil(L);
2154 lua_pushstring(L, "Can't connect");
2155 return 2;
2156 }
2157
2158 appctx = objt_appctx(socket->s->si[0].end);
2159
2160 /* Check for connection established. */
Thierry FOURNIER18d09902016-12-16 09:25:38 +01002161 if (appctx->ctx.hlua_cosocket.connected) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002162 lua_pushinteger(L, 1);
2163 return 1;
2164 }
2165
Thierry FOURNIER847ca662016-12-16 13:07:22 +01002166 if (!hlua_com_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task))
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002167 WILL_LJMP(luaL_error(L, "out of memory error"));
Thierry FOURNIER4abd3ae2015-03-03 17:29:06 +01002168 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_connect_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002169 return 0;
2170}
2171
2172/* This function fail or initite the connection. */
2173__LJMP static int hlua_socket_connect(struct lua_State *L)
2174{
2175 struct hlua_socket *socket;
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002176 int port = -1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002177 const char *ip;
2178 struct connection *conn;
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002179 struct hlua *hlua;
2180 struct appctx *appctx;
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002181 int low, high;
2182 struct sockaddr_storage *addr;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002183
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002184 if (lua_gettop(L) < 2)
2185 WILL_LJMP(luaL_error(L, "connect: need at least 2 arguments"));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002186
2187 /* Get args. */
2188 socket = MAY_LJMP(hlua_checksocket(L, 1));
2189 ip = MAY_LJMP(luaL_checkstring(L, 2));
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002190 if (lua_gettop(L) >= 3)
2191 port = MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002192
Willy Tarreau973a5422015-08-05 21:47:23 +02002193 conn = si_alloc_conn(&socket->s->si[1]);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002194 if (!conn)
2195 WILL_LJMP(luaL_error(L, "connect: internal error"));
2196
Willy Tarreau3adac082015-09-26 17:51:09 +02002197 /* needed for the connection not to be closed */
2198 conn->target = socket->s->target;
2199
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002200 /* Parse ip address. */
Willy Tarreau48ef4c92017-01-06 18:32:38 +01002201 addr = str2sa_range(ip, NULL, &low, &high, NULL, NULL, NULL, 0);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002202 if (!addr)
2203 WILL_LJMP(luaL_error(L, "connect: cannot parse destination address '%s'", ip));
2204 if (low != high)
2205 WILL_LJMP(luaL_error(L, "connect: port ranges not supported : address '%s'", ip));
2206 memcpy(&conn->addr.to, addr, sizeof(struct sockaddr_storage));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002207
2208 /* Set port. */
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002209 if (low == 0) {
2210 if (conn->addr.to.ss_family == AF_INET) {
2211 if (port == -1)
2212 WILL_LJMP(luaL_error(L, "connect: port missing"));
2213 ((struct sockaddr_in *)&conn->addr.to)->sin_port = htons(port);
2214 } else if (conn->addr.to.ss_family == AF_INET6) {
2215 if (port == -1)
2216 WILL_LJMP(luaL_error(L, "connect: port missing"));
2217 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_port = htons(port);
2218 }
2219 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002220
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002221 hlua = hlua_gethlua(L);
2222 appctx = objt_appctx(socket->s->si[0].end);
Willy Tarreaubdc97a82015-08-24 15:42:28 +02002223
2224 /* inform the stream that we want to be notified whenever the
2225 * connection completes.
2226 */
2227 si_applet_cant_get(&socket->s->si[0]);
2228 si_applet_cant_put(&socket->s->si[0]);
Thierry FOURNIER8c8fbbe2015-09-26 17:02:35 +02002229 appctx_wakeup(appctx);
Willy Tarreaubdc97a82015-08-24 15:42:28 +02002230
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +02002231 hlua->flags |= HLUA_MUST_GC;
2232
Thierry FOURNIER847ca662016-12-16 13:07:22 +01002233 if (!hlua_com_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task))
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002234 WILL_LJMP(luaL_error(L, "out of memory"));
Thierry FOURNIER4abd3ae2015-03-03 17:29:06 +01002235 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_connect_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002236
2237 return 0;
2238}
2239
Baptiste Assmann84bb4932015-03-02 21:40:06 +01002240#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002241__LJMP static int hlua_socket_connect_ssl(struct lua_State *L)
2242{
2243 struct hlua_socket *socket;
2244
2245 MAY_LJMP(check_args(L, 3, "connect_ssl"));
2246 socket = MAY_LJMP(hlua_checksocket(L, 1));
2247 socket->s->target = &socket_ssl.obj_type;
2248 return MAY_LJMP(hlua_socket_connect(L));
2249}
Baptiste Assmann84bb4932015-03-02 21:40:06 +01002250#endif
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002251
2252__LJMP static int hlua_socket_setoption(struct lua_State *L)
2253{
2254 return 0;
2255}
2256
2257__LJMP static int hlua_socket_settimeout(struct lua_State *L)
2258{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002259 struct hlua_socket *socket;
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002260 int tmout;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002261
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002262 MAY_LJMP(check_args(L, 2, "settimeout"));
2263
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002264 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002265 tmout = MAY_LJMP(luaL_checkinteger(L, 2)) * 1000;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002266
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01002267 socket->s->req.rto = tmout;
2268 socket->s->req.wto = tmout;
2269 socket->s->res.rto = tmout;
2270 socket->s->res.wto = tmout;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002271
2272 return 0;
2273}
2274
2275__LJMP static int hlua_socket_new(lua_State *L)
2276{
2277 struct hlua_socket *socket;
2278 struct appctx *appctx;
Willy Tarreau15b5e142015-04-04 14:38:25 +02002279 struct session *sess;
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002280 struct stream *strm;
Willy Tarreaud420a972015-04-06 00:39:18 +02002281 struct task *task;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002282
2283 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002284 if (!lua_checkstack(L, 3)) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002285 hlua_pusherror(L, "socket: full stack");
2286 goto out_fail_conf;
2287 }
2288
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002289 /* Create the object: obj[0] = userdata. */
2290 lua_newtable(L);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002291 socket = MAY_LJMP(lua_newuserdata(L, sizeof(*socket)));
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002292 lua_rawseti(L, -2, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002293 memset(socket, 0, sizeof(*socket));
2294
Thierry FOURNIER4a6170c2015-03-09 17:07:10 +01002295 /* Check if the various memory pools are intialized. */
Willy Tarreau87b09662015-04-03 00:22:06 +02002296 if (!pool2_stream || !pool2_buffer) {
Thierry FOURNIER4a6170c2015-03-09 17:07:10 +01002297 hlua_pusherror(L, "socket: uninitialized pools.");
2298 goto out_fail_conf;
2299 }
2300
Willy Tarreau87b09662015-04-03 00:22:06 +02002301 /* Pop a class stream metatable and affect it to the userdata. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002302 lua_rawgeti(L, LUA_REGISTRYINDEX, class_socket_ref);
2303 lua_setmetatable(L, -2);
2304
Willy Tarreaud420a972015-04-06 00:39:18 +02002305 /* Create the applet context */
2306 appctx = appctx_new(&update_applet);
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002307 if (!appctx) {
2308 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaufeb76402015-04-03 14:10:06 +02002309 goto out_fail_conf;
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002310 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002311
Thierry FOURNIER18d09902016-12-16 09:25:38 +01002312 appctx->ctx.hlua_cosocket.socket = socket;
2313 appctx->ctx.hlua_cosocket.connected = 0;
2314 LIST_INIT(&appctx->ctx.hlua_cosocket.wake_on_write);
2315 LIST_INIT(&appctx->ctx.hlua_cosocket.wake_on_read);
Willy Tarreaub2bf8332015-04-04 15:58:58 +02002316
Willy Tarreaud420a972015-04-06 00:39:18 +02002317 /* Now create a session, task and stream for this applet */
2318 sess = session_new(&socket_proxy, NULL, &appctx->obj_type);
2319 if (!sess) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002320 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaud420a972015-04-06 00:39:18 +02002321 goto out_fail_sess;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002322 }
2323
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002324 task = task_new();
2325 if (!task) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002326 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaufeb76402015-04-03 14:10:06 +02002327 goto out_fail_task;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002328 }
Willy Tarreaud420a972015-04-06 00:39:18 +02002329 task->nice = 0;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002330
Willy Tarreau73b65ac2015-04-08 18:26:29 +02002331 strm = stream_new(sess, task, &appctx->obj_type);
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002332 if (!strm) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002333 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaud420a972015-04-06 00:39:18 +02002334 goto out_fail_stream;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002335 }
2336
Willy Tarreaud420a972015-04-06 00:39:18 +02002337 /* Configure an empty Lua for the stream. */
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002338 socket->s = strm;
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01002339 strm->hlua = NULL;
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 FOURNIER11cfb3d2016-12-13 13:06:23 +01002406/* This function is called before the Lua execution. It stores
2407 * the differents parsers state before executing some Lua code.
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002408 */
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01002409static inline void consistency_set(struct stream *stream, int opt, struct hlua_consistency *c)
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002410{
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01002411 c->mode = stream->be->mode;
2412 switch (c->mode) {
2413 case PR_MODE_HTTP:
2414 c->data.http.dir = opt & SMP_OPT_DIR;
2415 if (c->data.http.dir == SMP_OPT_DIR_REQ)
2416 c->data.http.state = stream->txn->req.msg_state;
2417 else
2418 c->data.http.state = stream->txn->rsp.msg_state;
2419 break;
2420 default:
2421 break;
2422 }
2423}
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002424
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01002425/* This function is called after the Lua execution. it
2426 * returns true if the parser state is consistent, otherwise,
2427 * it return false.
2428 *
2429 * In HTTP mode, the parser state must be in the same state
2430 * or greater when we exit the function. Even if we do a
2431 * control yield. This prevent to break the HTTP message
2432 * from the Lua code.
2433 */
2434static inline int consistency_check(struct stream *stream, int opt, struct hlua_consistency *c)
2435{
2436 if (c->mode != stream->be->mode)
2437 return 0;
2438
2439 switch (c->mode) {
2440 case PR_MODE_HTTP:
2441 if (c->data.http.dir != (opt & SMP_OPT_DIR))
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002442 return 0;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01002443 if (c->data.http.dir == SMP_OPT_DIR_REQ)
2444 return stream->txn->req.msg_state >= c->data.http.state;
2445 else
2446 return stream->txn->rsp.msg_state >= c->data.http.state;
2447 default:
2448 return 1;
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002449 }
2450 return 1;
2451}
2452
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002453/* Returns the struct hlua_channel join to the class channel in the
2454 * stack entry "ud" or throws an argument error.
2455 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002456__LJMP static struct channel *hlua_checkchannel(lua_State *L, int ud)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002457{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002458 return MAY_LJMP(hlua_checkudata(L, ud, class_channel_ref));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002459}
2460
Willy Tarreau47860ed2015-03-10 14:07:50 +01002461/* Pushes the channel onto the top of the stack. If the stask does not have a
2462 * free slots, the function fails and returns 0;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002463 */
Willy Tarreau2a71af42015-03-10 13:51:50 +01002464static int hlua_channel_new(lua_State *L, struct channel *channel)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002465{
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002466 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002467 if (!lua_checkstack(L, 3))
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002468 return 0;
2469
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002470 lua_newtable(L);
Willy Tarreau47860ed2015-03-10 14:07:50 +01002471 lua_pushlightuserdata(L, channel);
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002472 lua_rawseti(L, -2, 0);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002473
2474 /* Pop a class sesison metatable and affect it to the userdata. */
2475 lua_rawgeti(L, LUA_REGISTRYINDEX, class_channel_ref);
2476 lua_setmetatable(L, -2);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002477 return 1;
2478}
2479
2480/* Duplicate all the data present in the input channel and put it
2481 * in a string LUA variables. Returns -1 and push a nil value in
2482 * the stack if the channel is closed and all the data are consumed,
2483 * returns 0 if no data are available, otherwise it returns the length
2484 * of the builded string.
2485 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002486static inline int _hlua_channel_dup(struct channel *chn, lua_State *L)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002487{
2488 char *blk1;
2489 char *blk2;
2490 int len1;
2491 int len2;
2492 int ret;
2493 luaL_Buffer b;
2494
Willy Tarreau47860ed2015-03-10 14:07:50 +01002495 ret = bi_getblk_nc(chn, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002496 if (unlikely(ret == 0))
2497 return 0;
2498
2499 if (unlikely(ret < 0)) {
2500 lua_pushnil(L);
2501 return -1;
2502 }
2503
2504 luaL_buffinit(L, &b);
2505 luaL_addlstring(&b, blk1, len1);
2506 if (unlikely(ret == 2))
2507 luaL_addlstring(&b, blk2, len2);
2508 luaL_pushresult(&b);
2509
2510 if (unlikely(ret == 2))
2511 return len1 + len2;
2512 return len1;
2513}
2514
2515/* "_hlua_channel_dup" wrapper. If no data are available, it returns
2516 * a yield. This function keep the data in the buffer.
2517 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002518__LJMP static int hlua_channel_dup_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002519{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002520 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002521
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002522 chn = MAY_LJMP(hlua_checkchannel(L, 1));
2523
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002524 if (_hlua_channel_dup(chn, L) == 0)
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002525 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_dup_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002526 return 1;
2527}
2528
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002529/* Check arguments for the function "hlua_channel_dup_yield". */
2530__LJMP static int hlua_channel_dup(lua_State *L)
2531{
2532 MAY_LJMP(check_args(L, 1, "dup"));
2533 MAY_LJMP(hlua_checkchannel(L, 1));
2534 return MAY_LJMP(hlua_channel_dup_yield(L, 0, 0));
2535}
2536
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002537/* "_hlua_channel_dup" wrapper. If no data are available, it returns
2538 * a yield. This function consumes the data in the buffer. It returns
2539 * a string containing the data or a nil pointer if no data are available
2540 * and the channel is closed.
2541 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002542__LJMP static int hlua_channel_get_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002543{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002544 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002545 int ret;
2546
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002547 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002548
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002549 ret = _hlua_channel_dup(chn, L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002550 if (unlikely(ret == 0))
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002551 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_get_yield, TICK_ETERNITY, 0));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002552
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002553 if (unlikely(ret == -1))
2554 return 1;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002555
Willy Tarreau47860ed2015-03-10 14:07:50 +01002556 chn->buf->i -= ret;
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002557 hlua_resynchonize_proto(chn_strm(chn), !!(chn->flags & CF_ISRESP));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002558 return 1;
2559}
2560
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002561/* Check arguments for the fucntion "hlua_channel_get_yield". */
2562__LJMP static int hlua_channel_get(lua_State *L)
2563{
2564 MAY_LJMP(check_args(L, 1, "get"));
2565 MAY_LJMP(hlua_checkchannel(L, 1));
2566 return MAY_LJMP(hlua_channel_get_yield(L, 0, 0));
2567}
2568
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002569/* This functions consumes and returns one line. If the channel is closed,
2570 * and the last data does not contains a final '\n', the data are returned
2571 * without the final '\n'. When no more data are avalaible, it returns nil
2572 * value.
2573 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002574__LJMP static int hlua_channel_getline_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002575{
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002576 char *blk1;
2577 char *blk2;
2578 int len1;
2579 int len2;
2580 int len;
Willy Tarreau47860ed2015-03-10 14:07:50 +01002581 struct channel *chn;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002582 int ret;
2583 luaL_Buffer b;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002584
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002585 chn = MAY_LJMP(hlua_checkchannel(L, 1));
2586
Willy Tarreau47860ed2015-03-10 14:07:50 +01002587 ret = bi_getline_nc(chn, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002588 if (ret == 0)
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002589 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_getline_yield, TICK_ETERNITY, 0));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002590
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002591 if (ret == -1) {
2592 lua_pushnil(L);
2593 return 1;
2594 }
2595
2596 luaL_buffinit(L, &b);
2597 luaL_addlstring(&b, blk1, len1);
2598 len = len1;
2599 if (unlikely(ret == 2)) {
2600 luaL_addlstring(&b, blk2, len2);
2601 len += len2;
2602 }
2603 luaL_pushresult(&b);
Willy Tarreau47860ed2015-03-10 14:07:50 +01002604 buffer_replace2(chn->buf, chn->buf->p, chn->buf->p + len, NULL, 0);
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002605 hlua_resynchonize_proto(chn_strm(chn), !!(chn->flags & CF_ISRESP));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002606 return 1;
2607}
2608
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002609/* Check arguments for the fucntion "hlua_channel_getline_yield". */
2610__LJMP static int hlua_channel_getline(lua_State *L)
2611{
2612 MAY_LJMP(check_args(L, 1, "getline"));
2613 MAY_LJMP(hlua_checkchannel(L, 1));
2614 return MAY_LJMP(hlua_channel_getline_yield(L, 0, 0));
2615}
2616
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002617/* This function takes a string as input, and append it at the
2618 * input side of channel. If the data is too big, but a space
2619 * is probably available after sending some data, the function
2620 * yield. If the data is bigger than the buffer, or if the
2621 * channel is closed, it returns -1. otherwise, it returns the
2622 * amount of data writed.
2623 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002624__LJMP static int hlua_channel_append_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002625{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002626 struct channel *chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002627 size_t len;
2628 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
2629 int l = MAY_LJMP(luaL_checkinteger(L, 3));
2630 int ret;
2631 int max;
2632
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002633 /* Check if the buffer is avalaible because HAProxy doesn't allocate
2634 * the request buffer if its not required.
2635 */
2636 if (chn->buf->size == 0) {
2637 si_applet_cant_put(chn_prod(chn));
2638 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
2639 }
2640
Willy Tarreau47860ed2015-03-10 14:07:50 +01002641 max = channel_recv_limit(chn) - buffer_len(chn->buf);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002642 if (max > len - l)
2643 max = len - l;
2644
Willy Tarreau47860ed2015-03-10 14:07:50 +01002645 ret = bi_putblk(chn, str + l, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002646 if (ret == -2 || ret == -3) {
2647 lua_pushinteger(L, -1);
2648 return 1;
2649 }
Willy Tarreaubc18da12015-03-13 14:00:47 +01002650 if (ret == -1) {
2651 chn->flags |= CF_WAKE_WRITE;
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002652 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
Willy Tarreaubc18da12015-03-13 14:00:47 +01002653 }
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002654 l += ret;
2655 lua_pop(L, 1);
2656 lua_pushinteger(L, l);
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002657 hlua_resynchonize_proto(chn_strm(chn), !!(chn->flags & CF_ISRESP));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002658
Willy Tarreau47860ed2015-03-10 14:07:50 +01002659 max = channel_recv_limit(chn) - buffer_len(chn->buf);
2660 if (max == 0 && chn->buf->o == 0) {
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002661 /* There are no space avalaible, and the output buffer is empty.
2662 * in this case, we cannot add more data, so we cannot yield,
2663 * we return the amount of copyied data.
2664 */
2665 return 1;
2666 }
2667 if (l < len)
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002668 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002669 return 1;
2670}
2671
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002672/* just a wrapper of "hlua_channel_append_yield". It returns the length
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002673 * of the writed string, or -1 if the channel is closed or if the
2674 * buffer size is too little for the data.
2675 */
2676__LJMP static int hlua_channel_append(lua_State *L)
2677{
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002678 size_t len;
2679
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002680 MAY_LJMP(check_args(L, 2, "append"));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002681 MAY_LJMP(hlua_checkchannel(L, 1));
2682 MAY_LJMP(luaL_checklstring(L, 2, &len));
2683 MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002684 lua_pushinteger(L, 0);
2685
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002686 return MAY_LJMP(hlua_channel_append_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002687}
2688
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002689/* just a wrapper of "hlua_channel_append_yield". This wrapper starts
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002690 * his process by cleaning the buffer. The result is a replacement
2691 * of the current data. It returns the length of the writed string,
2692 * or -1 if the channel is closed or if the buffer size is too
2693 * little for the data.
2694 */
2695__LJMP static int hlua_channel_set(lua_State *L)
2696{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002697 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002698
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002699 MAY_LJMP(check_args(L, 2, "set"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002700 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002701 lua_pushinteger(L, 0);
2702
Willy Tarreau47860ed2015-03-10 14:07:50 +01002703 chn->buf->i = 0;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002704
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002705 return MAY_LJMP(hlua_channel_append_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002706}
2707
2708/* Append data in the output side of the buffer. This data is immediatly
2709 * sent. The fcuntion returns the ammount of data writed. If the buffer
2710 * cannot contains the data, the function yield. The function returns -1
2711 * if the channel is closed.
2712 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002713__LJMP static int hlua_channel_send_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002714{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002715 struct channel *chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002716 size_t len;
2717 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
2718 int l = MAY_LJMP(luaL_checkinteger(L, 3));
2719 int max;
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01002720 struct hlua *hlua = hlua_gethlua(L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002721
Willy Tarreau47860ed2015-03-10 14:07:50 +01002722 if (unlikely(channel_output_closed(chn))) {
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002723 lua_pushinteger(L, -1);
2724 return 1;
2725 }
2726
Thierry FOURNIER3e3a6082015-03-05 17:06:12 +01002727 /* Check if the buffer is avalaible because HAProxy doesn't allocate
2728 * the request buffer if its not required.
2729 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002730 if (chn->buf->size == 0) {
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002731 si_applet_cant_put(chn_prod(chn));
2732 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIER3e3a6082015-03-05 17:06:12 +01002733 }
2734
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01002735 /* the writed data will be immediatly sent, so we can check
2736 * the avalaible space without taking in account the reserve.
2737 * The reserve is guaranted for the processing of incoming
2738 * data, because the buffer will be flushed.
2739 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002740 max = chn->buf->size - buffer_len(chn->buf);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01002741
2742 /* If there are no space avalaible, and the output buffer is empty.
2743 * in this case, we cannot add more data, so we cannot yield,
2744 * we return the amount of copyied data.
2745 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002746 if (max == 0 && chn->buf->o == 0)
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01002747 return 1;
2748
2749 /* Adjust the real required length. */
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002750 if (max > len - l)
2751 max = len - l;
2752
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01002753 /* The buffer avalaible size may be not contiguous. This test
2754 * detects a non contiguous buffer and realign it.
2755 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002756 if (bi_space_for_replace(chn->buf) < max)
2757 buffer_slow_realign(chn->buf);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01002758
2759 /* Copy input data in the buffer. */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002760 max = buffer_replace2(chn->buf, chn->buf->p, chn->buf->p, str + l, max);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01002761
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002762 /* buffer replace considers that the input part is filled.
2763 * so, I must forward these new data in the output part.
2764 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002765 b_adv(chn->buf, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002766
2767 l += max;
2768 lua_pop(L, 1);
2769 lua_pushinteger(L, l);
2770
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01002771 /* If there are no space avalaible, and the output buffer is empty.
2772 * in this case, we cannot add more data, so we cannot yield,
2773 * we return the amount of copyied data.
2774 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002775 max = chn->buf->size - buffer_len(chn->buf);
2776 if (max == 0 && chn->buf->o == 0)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002777 return 1;
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01002778
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01002779 if (l < len) {
2780 /* If we are waiting for space in the response buffer, we
2781 * must set the flag WAKERESWR. This flag required the task
2782 * wake up if any activity is detected on the response buffer.
2783 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002784 if (chn->flags & CF_ISRESP)
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01002785 HLUA_SET_WAKERESWR(hlua);
Thierry FOURNIER53e08ec2015-03-06 00:35:53 +01002786 else
2787 HLUA_SET_WAKEREQWR(hlua);
2788 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01002789 }
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002790
2791 return 1;
2792}
2793
2794/* Just a wraper of "_hlua_channel_send". This wrapper permits
2795 * yield the LUA process, and resume it without checking the
2796 * input arguments.
2797 */
2798__LJMP static int hlua_channel_send(lua_State *L)
2799{
2800 MAY_LJMP(check_args(L, 2, "send"));
2801 lua_pushinteger(L, 0);
2802
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002803 return MAY_LJMP(hlua_channel_send_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002804}
2805
2806/* This function forward and amount of butes. The data pass from
2807 * the input side of the buffer to the output side, and can be
2808 * forwarded. This function never fails.
2809 *
2810 * The Lua function takes an amount of bytes to be forwarded in
2811 * imput. It returns the number of bytes forwarded.
2812 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002813__LJMP static int hlua_channel_forward_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002814{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002815 struct channel *chn;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002816 int len;
2817 int l;
2818 int max;
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01002819 struct hlua *hlua = hlua_gethlua(L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002820
2821 chn = MAY_LJMP(hlua_checkchannel(L, 1));
2822 len = MAY_LJMP(luaL_checkinteger(L, 2));
2823 l = MAY_LJMP(luaL_checkinteger(L, -1));
2824
2825 max = len - l;
Willy Tarreau47860ed2015-03-10 14:07:50 +01002826 if (max > chn->buf->i)
2827 max = chn->buf->i;
2828 channel_forward(chn, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002829 l += max;
2830
2831 lua_pop(L, 1);
2832 lua_pushinteger(L, l);
2833
2834 /* Check if it miss bytes to forward. */
2835 if (l < len) {
2836 /* The the input channel or the output channel are closed, we
2837 * must return the amount of data forwarded.
2838 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002839 if (channel_input_closed(chn) || channel_output_closed(chn))
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002840 return 1;
2841
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01002842 /* If we are waiting for space data in the response buffer, we
2843 * must set the flag WAKERESWR. This flag required the task
2844 * wake up if any activity is detected on the response buffer.
2845 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002846 if (chn->flags & CF_ISRESP)
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01002847 HLUA_SET_WAKERESWR(hlua);
Thierry FOURNIER53e08ec2015-03-06 00:35:53 +01002848 else
2849 HLUA_SET_WAKEREQWR(hlua);
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01002850
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002851 /* Otherwise, we can yield waiting for new data in the inpout side. */
Thierry FOURNIER4abd3ae2015-03-03 17:29:06 +01002852 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_forward_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002853 }
2854
2855 return 1;
2856}
2857
2858/* Just check the input and prepare the stack for the previous
2859 * function "hlua_channel_forward_yield"
2860 */
2861__LJMP static int hlua_channel_forward(lua_State *L)
2862{
2863 MAY_LJMP(check_args(L, 2, "forward"));
2864 MAY_LJMP(hlua_checkchannel(L, 1));
2865 MAY_LJMP(luaL_checkinteger(L, 2));
2866
2867 lua_pushinteger(L, 0);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002868 return MAY_LJMP(hlua_channel_forward_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002869}
2870
2871/* Just returns the number of bytes available in the input
2872 * side of the buffer. This function never fails.
2873 */
2874__LJMP static int hlua_channel_get_in_len(lua_State *L)
2875{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002876 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002877
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002878 MAY_LJMP(check_args(L, 1, "get_in_len"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002879 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Willy Tarreau47860ed2015-03-10 14:07:50 +01002880 lua_pushinteger(L, chn->buf->i);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002881 return 1;
2882}
2883
Thierry FOURNIER / OZON.IO65192f32016-11-07 15:28:40 +01002884/* Returns true if the channel is full. */
2885__LJMP static int hlua_channel_is_full(lua_State *L)
2886{
2887 struct channel *chn;
2888 int rem;
2889
2890 MAY_LJMP(check_args(L, 1, "is_full"));
2891 chn = MAY_LJMP(hlua_checkchannel(L, 1));
2892
2893 rem = chn->buf->size;
2894 rem -= chn->buf->o; /* Output size */
2895 rem -= chn->buf->i; /* Input size */
2896 rem -= global.tune.maxrewrite; /* Rewrite reserved size */
2897
2898 lua_pushboolean(L, rem <= 0);
2899 return 1;
2900}
2901
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002902/* Just returns the number of bytes available in the output
2903 * side of the buffer. This function never fails.
2904 */
2905__LJMP static int hlua_channel_get_out_len(lua_State *L)
2906{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002907 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002908
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002909 MAY_LJMP(check_args(L, 1, "get_out_len"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002910 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Willy Tarreau47860ed2015-03-10 14:07:50 +01002911 lua_pushinteger(L, chn->buf->o);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002912 return 1;
2913}
2914
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002915/*
2916 *
2917 *
2918 * Class Fetches
2919 *
2920 *
2921 */
2922
2923/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02002924 * a class stream, otherwise it throws an error.
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002925 */
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01002926__LJMP static struct hlua_smp *hlua_checkfetches(lua_State *L, int ud)
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002927{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002928 return MAY_LJMP(hlua_checkudata(L, ud, class_fetches_ref));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002929}
2930
2931/* This function creates and push in the stack a fetch object according
2932 * with a current TXN.
2933 */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01002934static int hlua_fetches_new(lua_State *L, struct hlua_txn *txn, unsigned int flags)
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002935{
Willy Tarreau7073c472015-04-06 11:15:40 +02002936 struct hlua_smp *hsmp;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002937
2938 /* Check stack size. */
2939 if (!lua_checkstack(L, 3))
2940 return 0;
2941
2942 /* Create the object: obj[0] = userdata.
2943 * Note that the base of the Fetches object is the
2944 * transaction object.
2945 */
2946 lua_newtable(L);
Willy Tarreau7073c472015-04-06 11:15:40 +02002947 hsmp = lua_newuserdata(L, sizeof(*hsmp));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002948 lua_rawseti(L, -2, 0);
2949
Willy Tarreau7073c472015-04-06 11:15:40 +02002950 hsmp->s = txn->s;
2951 hsmp->p = txn->p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01002952 hsmp->dir = txn->dir;
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01002953 hsmp->flags = flags;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002954
2955 /* Pop a class sesison metatable and affect it to the userdata. */
2956 lua_rawgeti(L, LUA_REGISTRYINDEX, class_fetches_ref);
2957 lua_setmetatable(L, -2);
2958
2959 return 1;
2960}
2961
2962/* This function is an LUA binding. It is called with each sample-fetch.
2963 * It uses closure argument to store the associated sample-fetch. It
2964 * returns only one argument or throws an error. An error is thrown
2965 * only if an error is encountered during the argument parsing. If
2966 * the "sample-fetch" function fails, nil is returned.
2967 */
2968__LJMP static int hlua_run_sample_fetch(lua_State *L)
2969{
Willy Tarreaub2ccb562015-04-06 11:11:15 +02002970 struct hlua_smp *hsmp;
Willy Tarreau2ec22742015-03-10 14:27:20 +01002971 struct sample_fetch *f;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002972 struct arg args[ARGM_NBARGS + 1];
2973 int i;
2974 struct sample smp;
2975
2976 /* Get closure arguments. */
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002977 f = lua_touserdata(L, lua_upvalueindex(1));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002978
2979 /* Get traditionnal arguments. */
Willy Tarreaub2ccb562015-04-06 11:11:15 +02002980 hsmp = MAY_LJMP(hlua_checkfetches(L, 1));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002981
Thierry FOURNIERca988662015-12-20 18:43:03 +01002982 /* Check execution authorization. */
2983 if (f->use & SMP_USE_HTTP_ANY &&
2984 !(hsmp->flags & HLUA_F_MAY_USE_HTTP)) {
2985 lua_pushfstring(L, "the sample-fetch '%s' needs an HTTP parser which "
2986 "is not available in Lua services", f->kw);
2987 WILL_LJMP(lua_error(L));
2988 }
2989
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002990 /* Get extra arguments. */
2991 for (i = 0; i < lua_gettop(L) - 1; i++) {
2992 if (i >= ARGM_NBARGS)
2993 break;
2994 hlua_lua2arg(L, i + 2, &args[i]);
2995 }
2996 args[i].type = ARGT_STOP;
David Carlierabdb00f2016-04-27 16:14:50 +01002997 args[i].data.str.str = NULL;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01002998
2999 /* Check arguments. */
Willy Tarreaub2ccb562015-04-06 11:11:15 +02003000 MAY_LJMP(hlua_lua2arg_check(L, 2, args, f->arg_mask, hsmp->p));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003001
3002 /* Run the special args checker. */
Willy Tarreau2ec22742015-03-10 14:27:20 +01003003 if (f->val_args && !f->val_args(args, NULL)) {
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003004 lua_pushfstring(L, "error in arguments");
3005 WILL_LJMP(lua_error(L));
3006 }
3007
3008 /* Initialise the sample. */
3009 memset(&smp, 0, sizeof(smp));
3010
3011 /* Run the sample fetch process. */
Willy Tarreau1777ea62016-03-10 16:15:46 +01003012 smp_set_owner(&smp, hsmp->p, hsmp->s->sess, hsmp->s, hsmp->dir & SMP_OPT_DIR);
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003013 if (!f->process(args, &smp, f->kw, f->private)) {
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003014 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003015 lua_pushstring(L, "");
3016 else
3017 lua_pushnil(L);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003018 return 1;
3019 }
3020
3021 /* Convert the returned sample in lua value. */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003022 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003023 hlua_smp2lua_str(L, &smp);
3024 else
3025 hlua_smp2lua(L, &smp);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003026 return 1;
3027}
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003028
3029/*
3030 *
3031 *
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003032 * Class Converters
3033 *
3034 *
3035 */
3036
3037/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02003038 * a class stream, otherwise it throws an error.
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003039 */
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003040__LJMP static struct hlua_smp *hlua_checkconverters(lua_State *L, int ud)
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003041{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003042 return MAY_LJMP(hlua_checkudata(L, ud, class_converters_ref));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003043}
3044
3045/* This function creates and push in the stack a Converters object
3046 * according with a current TXN.
3047 */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003048static int hlua_converters_new(lua_State *L, struct hlua_txn *txn, unsigned int flags)
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003049{
Willy Tarreau7073c472015-04-06 11:15:40 +02003050 struct hlua_smp *hsmp;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003051
3052 /* Check stack size. */
3053 if (!lua_checkstack(L, 3))
3054 return 0;
3055
3056 /* Create the object: obj[0] = userdata.
3057 * Note that the base of the Converters object is the
3058 * same than the TXN object.
3059 */
3060 lua_newtable(L);
Willy Tarreau7073c472015-04-06 11:15:40 +02003061 hsmp = lua_newuserdata(L, sizeof(*hsmp));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003062 lua_rawseti(L, -2, 0);
3063
Willy Tarreau7073c472015-04-06 11:15:40 +02003064 hsmp->s = txn->s;
3065 hsmp->p = txn->p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01003066 hsmp->dir = txn->dir;
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003067 hsmp->flags = flags;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003068
Willy Tarreau87b09662015-04-03 00:22:06 +02003069 /* Pop a class stream metatable and affect it to the table. */
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003070 lua_rawgeti(L, LUA_REGISTRYINDEX, class_converters_ref);
3071 lua_setmetatable(L, -2);
3072
3073 return 1;
3074}
3075
3076/* This function is an LUA binding. It is called with each converter.
3077 * It uses closure argument to store the associated converter. It
3078 * returns only one argument or throws an error. An error is thrown
3079 * only if an error is encountered during the argument parsing. If
3080 * the converter function function fails, nil is returned.
3081 */
3082__LJMP static int hlua_run_sample_conv(lua_State *L)
3083{
Willy Tarreauda5f1082015-04-06 11:17:13 +02003084 struct hlua_smp *hsmp;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003085 struct sample_conv *conv;
3086 struct arg args[ARGM_NBARGS + 1];
3087 int i;
3088 struct sample smp;
3089
3090 /* Get closure arguments. */
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003091 conv = lua_touserdata(L, lua_upvalueindex(1));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003092
3093 /* Get traditionnal arguments. */
Willy Tarreauda5f1082015-04-06 11:17:13 +02003094 hsmp = MAY_LJMP(hlua_checkconverters(L, 1));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003095
3096 /* Get extra arguments. */
3097 for (i = 0; i < lua_gettop(L) - 2; i++) {
3098 if (i >= ARGM_NBARGS)
3099 break;
3100 hlua_lua2arg(L, i + 3, &args[i]);
3101 }
3102 args[i].type = ARGT_STOP;
David Carlierabdb00f2016-04-27 16:14:50 +01003103 args[i].data.str.str = NULL;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003104
3105 /* Check arguments. */
Willy Tarreauda5f1082015-04-06 11:17:13 +02003106 MAY_LJMP(hlua_lua2arg_check(L, 3, args, conv->arg_mask, hsmp->p));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003107
3108 /* Run the special args checker. */
3109 if (conv->val_args && !conv->val_args(args, conv, "", 0, NULL)) {
3110 hlua_pusherror(L, "error in arguments");
3111 WILL_LJMP(lua_error(L));
3112 }
3113
3114 /* Initialise the sample. */
3115 if (!hlua_lua2smp(L, 2, &smp)) {
3116 hlua_pusherror(L, "error in the input argument");
3117 WILL_LJMP(lua_error(L));
3118 }
3119
Willy Tarreau1777ea62016-03-10 16:15:46 +01003120 smp_set_owner(&smp, hsmp->p, hsmp->s->sess, hsmp->s, hsmp->dir & SMP_OPT_DIR);
3121
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003122 /* Apply expected cast. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003123 if (!sample_casts[smp.data.type][conv->in_type]) {
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003124 hlua_pusherror(L, "invalid input argument: cannot cast '%s' to '%s'",
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003125 smp_to_type[smp.data.type], smp_to_type[conv->in_type]);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003126 WILL_LJMP(lua_error(L));
3127 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003128 if (sample_casts[smp.data.type][conv->in_type] != c_none &&
3129 !sample_casts[smp.data.type][conv->in_type](&smp)) {
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003130 hlua_pusherror(L, "error during the input argument casting");
3131 WILL_LJMP(lua_error(L));
3132 }
3133
3134 /* Run the sample conversion process. */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003135 if (!conv->process(args, &smp, conv->private)) {
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003136 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003137 lua_pushstring(L, "");
3138 else
Willy Tarreaua678b432015-08-28 10:14:59 +02003139 lua_pushnil(L);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003140 return 1;
3141 }
3142
3143 /* Convert the returned sample in lua value. */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003144 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003145 hlua_smp2lua_str(L, &smp);
3146 else
3147 hlua_smp2lua(L, &smp);
Willy Tarreaua678b432015-08-28 10:14:59 +02003148 return 1;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003149}
3150
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003151/*
3152 *
3153 *
3154 * Class AppletTCP
3155 *
3156 *
3157 */
3158
3159/* Returns a struct hlua_txn if the stack entry "ud" is
3160 * a class stream, otherwise it throws an error.
3161 */
3162__LJMP static struct hlua_appctx *hlua_checkapplet_tcp(lua_State *L, int ud)
3163{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003164 return MAY_LJMP(hlua_checkudata(L, ud, class_applet_tcp_ref));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003165}
3166
3167/* This function creates and push in the stack an Applet object
3168 * according with a current TXN.
3169 */
3170static int hlua_applet_tcp_new(lua_State *L, struct appctx *ctx)
3171{
3172 struct hlua_appctx *appctx;
3173 struct stream_interface *si = ctx->owner;
3174 struct stream *s = si_strm(si);
3175 struct proxy *p = s->be;
3176
3177 /* Check stack size. */
3178 if (!lua_checkstack(L, 3))
3179 return 0;
3180
3181 /* Create the object: obj[0] = userdata.
3182 * Note that the base of the Converters object is the
3183 * same than the TXN object.
3184 */
3185 lua_newtable(L);
3186 appctx = lua_newuserdata(L, sizeof(*appctx));
3187 lua_rawseti(L, -2, 0);
3188 appctx->appctx = ctx;
3189 appctx->htxn.s = s;
3190 appctx->htxn.p = p;
3191
3192 /* Create the "f" field that contains a list of fetches. */
3193 lua_pushstring(L, "f");
3194 if (!hlua_fetches_new(L, &appctx->htxn, 0))
3195 return 0;
3196 lua_settable(L, -3);
3197
3198 /* Create the "sf" field that contains a list of stringsafe fetches. */
3199 lua_pushstring(L, "sf");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003200 if (!hlua_fetches_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003201 return 0;
3202 lua_settable(L, -3);
3203
3204 /* Create the "c" field that contains a list of converters. */
3205 lua_pushstring(L, "c");
3206 if (!hlua_converters_new(L, &appctx->htxn, 0))
3207 return 0;
3208 lua_settable(L, -3);
3209
3210 /* Create the "sc" field that contains a list of stringsafe converters. */
3211 lua_pushstring(L, "sc");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003212 if (!hlua_converters_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003213 return 0;
3214 lua_settable(L, -3);
3215
3216 /* Pop a class stream metatable and affect it to the table. */
3217 lua_rawgeti(L, LUA_REGISTRYINDEX, class_applet_tcp_ref);
3218 lua_setmetatable(L, -2);
3219
3220 return 1;
3221}
3222
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003223__LJMP static int hlua_applet_tcp_set_var(lua_State *L)
3224{
3225 struct hlua_appctx *appctx;
3226 struct stream *s;
3227 const char *name;
3228 size_t len;
3229 struct sample smp;
3230
3231 MAY_LJMP(check_args(L, 3, "set_var"));
3232
3233 /* It is useles to retrieve the stream, but this function
3234 * runs only in a stream context.
3235 */
3236 appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3237 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3238 s = appctx->htxn.s;
3239
3240 /* Converts the third argument in a sample. */
3241 hlua_lua2smp(L, 3, &smp);
3242
3243 /* Store the sample in a variable. */
3244 smp_set_owner(&smp, s->be, s->sess, s, 0);
3245 vars_set_by_name(name, len, &smp);
3246 return 0;
3247}
3248
3249__LJMP static int hlua_applet_tcp_unset_var(lua_State *L)
3250{
3251 struct hlua_appctx *appctx;
3252 struct stream *s;
3253 const char *name;
3254 size_t len;
3255 struct sample smp;
3256
3257 MAY_LJMP(check_args(L, 2, "unset_var"));
3258
3259 /* It is useles to retrieve the stream, but this function
3260 * runs only in a stream context.
3261 */
3262 appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3263 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3264 s = appctx->htxn.s;
3265
3266 /* Unset the variable. */
3267 smp_set_owner(&smp, s->be, s->sess, s, 0);
3268 vars_unset_by_name(name, len, &smp);
3269 return 0;
3270}
3271
3272__LJMP static int hlua_applet_tcp_get_var(lua_State *L)
3273{
3274 struct hlua_appctx *appctx;
3275 struct stream *s;
3276 const char *name;
3277 size_t len;
3278 struct sample smp;
3279
3280 MAY_LJMP(check_args(L, 2, "get_var"));
3281
3282 /* It is useles to retrieve the stream, but this function
3283 * runs only in a stream context.
3284 */
3285 appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3286 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3287 s = appctx->htxn.s;
3288
3289 smp_set_owner(&smp, s->be, s->sess, s, 0);
3290 if (!vars_get_by_name(name, len, &smp)) {
3291 lua_pushnil(L);
3292 return 1;
3293 }
3294
3295 return hlua_smp2lua(L, &smp);
3296}
3297
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003298__LJMP static int hlua_applet_tcp_set_priv(lua_State *L)
3299{
3300 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3301 struct stream *s = appctx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01003302 struct hlua *hlua;
3303
3304 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01003305 if (!s->hlua)
3306 return 0;
3307 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003308
3309 MAY_LJMP(check_args(L, 2, "set_priv"));
3310
3311 /* Remove previous value. */
3312 if (hlua->Mref != -1)
3313 luaL_unref(L, hlua->Mref, LUA_REGISTRYINDEX);
3314
3315 /* Get and store new value. */
3316 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
3317 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
3318
3319 return 0;
3320}
3321
3322__LJMP static int hlua_applet_tcp_get_priv(lua_State *L)
3323{
3324 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3325 struct stream *s = appctx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01003326 struct hlua *hlua;
3327
3328 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01003329 if (!s->hlua) {
3330 lua_pushnil(L);
3331 return 1;
3332 }
3333 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003334
3335 /* Push configuration index in the stack. */
3336 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
3337
3338 return 1;
3339}
3340
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003341/* If expected data not yet available, it returns a yield. This function
3342 * consumes the data in the buffer. It returns a string containing the
3343 * data. This string can be empty.
3344 */
3345__LJMP static int hlua_applet_tcp_getline_yield(lua_State *L, int status, lua_KContext ctx)
3346{
3347 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3348 struct stream_interface *si = appctx->appctx->owner;
3349 int ret;
3350 char *blk1;
3351 int len1;
3352 char *blk2;
3353 int len2;
3354
3355 /* Read the maximum amount of data avalaible. */
3356 ret = bo_getline_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
3357
3358 /* Data not yet avalaible. return yield. */
3359 if (ret == 0) {
3360 si_applet_cant_get(si);
3361 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_getline_yield, TICK_ETERNITY, 0));
3362 }
3363
3364 /* End of data: commit the total strings and return. */
3365 if (ret < 0) {
3366 luaL_pushresult(&appctx->b);
3367 return 1;
3368 }
3369
3370 /* Ensure that the block 2 length is usable. */
3371 if (ret == 1)
3372 len2 = 0;
3373
3374 /* dont check the max length read and dont check. */
3375 luaL_addlstring(&appctx->b, blk1, len1);
3376 luaL_addlstring(&appctx->b, blk2, len2);
3377
3378 /* Consume input channel output buffer data. */
3379 bo_skip(si_oc(si), len1 + len2);
3380 luaL_pushresult(&appctx->b);
3381 return 1;
3382}
3383
3384/* Check arguments for the fucntion "hlua_channel_get_yield". */
3385__LJMP static int hlua_applet_tcp_getline(lua_State *L)
3386{
3387 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3388
3389 /* Initialise the string catenation. */
3390 luaL_buffinit(L, &appctx->b);
3391
3392 return MAY_LJMP(hlua_applet_tcp_getline_yield(L, 0, 0));
3393}
3394
3395/* If expected data not yet available, it returns a yield. This function
3396 * consumes the data in the buffer. It returns a string containing the
3397 * data. This string can be empty.
3398 */
3399__LJMP static int hlua_applet_tcp_recv_yield(lua_State *L, int status, lua_KContext ctx)
3400{
3401 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3402 struct stream_interface *si = appctx->appctx->owner;
3403 int len = MAY_LJMP(luaL_checkinteger(L, 2));
3404 int ret;
3405 char *blk1;
3406 int len1;
3407 char *blk2;
3408 int len2;
3409
3410 /* Read the maximum amount of data avalaible. */
3411 ret = bo_getblk_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
3412
3413 /* Data not yet avalaible. return yield. */
3414 if (ret == 0) {
3415 si_applet_cant_get(si);
3416 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
3417 }
3418
3419 /* End of data: commit the total strings and return. */
3420 if (ret < 0) {
3421 luaL_pushresult(&appctx->b);
3422 return 1;
3423 }
3424
3425 /* Ensure that the block 2 length is usable. */
3426 if (ret == 1)
3427 len2 = 0;
3428
3429 if (len == -1) {
3430
3431 /* If len == -1, catenate all the data avalaile and
3432 * yield because we want to get all the data until
3433 * the end of data stream.
3434 */
3435 luaL_addlstring(&appctx->b, blk1, len1);
3436 luaL_addlstring(&appctx->b, blk2, len2);
3437 bo_skip(si_oc(si), len1 + len2);
3438 si_applet_cant_get(si);
3439 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
3440
3441 } else {
3442
3443 /* Copy the fisrt block caping to the length required. */
3444 if (len1 > len)
3445 len1 = len;
3446 luaL_addlstring(&appctx->b, blk1, len1);
3447 len -= len1;
3448
3449 /* Copy the second block. */
3450 if (len2 > len)
3451 len2 = len;
3452 luaL_addlstring(&appctx->b, blk2, len2);
3453 len -= len2;
3454
3455 /* Consume input channel output buffer data. */
3456 bo_skip(si_oc(si), len1 + len2);
3457
3458 /* If we are no other data avalaible, yield waiting for new data. */
3459 if (len > 0) {
3460 lua_pushinteger(L, len);
3461 lua_replace(L, 2);
3462 si_applet_cant_get(si);
3463 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
3464 }
3465
3466 /* return the result. */
3467 luaL_pushresult(&appctx->b);
3468 return 1;
3469 }
3470
3471 /* we never executes this */
3472 hlua_pusherror(L, "Lua: internal error");
3473 WILL_LJMP(lua_error(L));
3474 return 0;
3475}
3476
3477/* Check arguments for the fucntion "hlua_channel_get_yield". */
3478__LJMP static int hlua_applet_tcp_recv(lua_State *L)
3479{
3480 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3481 int len = -1;
3482
3483 if (lua_gettop(L) > 2)
3484 WILL_LJMP(luaL_error(L, "The 'recv' function requires between 1 and 2 arguments."));
3485 if (lua_gettop(L) >= 2) {
3486 len = MAY_LJMP(luaL_checkinteger(L, 2));
3487 lua_pop(L, 1);
3488 }
3489
3490 /* Confirm or set the required length */
3491 lua_pushinteger(L, len);
3492
3493 /* Initialise the string catenation. */
3494 luaL_buffinit(L, &appctx->b);
3495
3496 return MAY_LJMP(hlua_applet_tcp_recv_yield(L, 0, 0));
3497}
3498
3499/* Append data in the output side of the buffer. This data is immediatly
3500 * sent. The fcuntion returns the ammount of data writed. If the buffer
3501 * cannot contains the data, the function yield. The function returns -1
3502 * if the channel is closed.
3503 */
3504__LJMP static int hlua_applet_tcp_send_yield(lua_State *L, int status, lua_KContext ctx)
3505{
3506 size_t len;
3507 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3508 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
3509 int l = MAY_LJMP(luaL_checkinteger(L, 3));
3510 struct stream_interface *si = appctx->appctx->owner;
3511 struct channel *chn = si_ic(si);
3512 int max;
3513
3514 /* Get the max amount of data which can write as input in the channel. */
3515 max = channel_recv_max(chn);
3516 if (max > (len - l))
3517 max = len - l;
3518
3519 /* Copy data. */
3520 bi_putblk(chn, str + l, max);
3521
3522 /* update counters. */
3523 l += max;
3524 lua_pop(L, 1);
3525 lua_pushinteger(L, l);
3526
3527 /* If some data is not send, declares the situation to the
3528 * applet, and returns a yield.
3529 */
3530 if (l < len) {
3531 si_applet_cant_put(si);
3532 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_send_yield, TICK_ETERNITY, 0));
3533 }
3534
3535 return 1;
3536}
3537
3538/* Just a wraper of "hlua_applet_tcp_send_yield". This wrapper permits
3539 * yield the LUA process, and resume it without checking the
3540 * input arguments.
3541 */
3542__LJMP static int hlua_applet_tcp_send(lua_State *L)
3543{
3544 MAY_LJMP(check_args(L, 2, "send"));
3545 lua_pushinteger(L, 0);
3546
3547 return MAY_LJMP(hlua_applet_tcp_send_yield(L, 0, 0));
3548}
3549
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003550/*
3551 *
3552 *
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003553 * Class AppletHTTP
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003554 *
3555 *
3556 */
3557
3558/* Returns a struct hlua_txn if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02003559 * a class stream, otherwise it throws an error.
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003560 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003561__LJMP static struct hlua_appctx *hlua_checkapplet_http(lua_State *L, int ud)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003562{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003563 return MAY_LJMP(hlua_checkudata(L, ud, class_applet_http_ref));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003564}
3565
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003566/* This function creates and push in the stack an Applet object
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003567 * according with a current TXN.
3568 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003569static int hlua_applet_http_new(lua_State *L, struct appctx *ctx)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003570{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003571 struct hlua_appctx *appctx;
Thierry FOURNIER841475e2015-12-11 17:10:09 +01003572 struct hlua_txn htxn;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003573 struct stream_interface *si = ctx->owner;
3574 struct stream *s = si_strm(si);
3575 struct proxy *px = s->be;
3576 struct http_txn *txn = s->txn;
3577 const char *path;
3578 const char *end;
3579 const char *p;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003580
3581 /* Check stack size. */
3582 if (!lua_checkstack(L, 3))
3583 return 0;
3584
3585 /* Create the object: obj[0] = userdata.
3586 * Note that the base of the Converters object is the
3587 * same than the TXN object.
3588 */
3589 lua_newtable(L);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003590 appctx = lua_newuserdata(L, sizeof(*appctx));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003591 lua_rawseti(L, -2, 0);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003592 appctx->appctx = ctx;
3593 appctx->appctx->ctx.hlua_apphttp.status = 200; /* Default status code returned. */
Robin H. Johnson52f5db22017-01-01 13:10:52 -08003594 appctx->appctx->ctx.hlua_apphttp.reason = NULL; /* Use default reason based on status */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003595 appctx->htxn.s = s;
3596 appctx->htxn.p = px;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003597
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003598 /* Create the "f" field that contains a list of fetches. */
3599 lua_pushstring(L, "f");
3600 if (!hlua_fetches_new(L, &appctx->htxn, 0))
3601 return 0;
3602 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003603
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003604 /* Create the "sf" field that contains a list of stringsafe fetches. */
3605 lua_pushstring(L, "sf");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003606 if (!hlua_fetches_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003607 return 0;
3608 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003609
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003610 /* Create the "c" field that contains a list of converters. */
3611 lua_pushstring(L, "c");
3612 if (!hlua_converters_new(L, &appctx->htxn, 0))
3613 return 0;
3614 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003615
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003616 /* Create the "sc" field that contains a list of stringsafe converters. */
3617 lua_pushstring(L, "sc");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003618 if (!hlua_converters_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003619 return 0;
3620 lua_settable(L, -3);
Willy Tarreaueee5b512015-04-03 23:46:31 +02003621
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003622 /* Stores the request method. */
3623 lua_pushstring(L, "method");
3624 lua_pushlstring(L, txn->req.chn->buf->p, txn->req.sl.rq.m_l);
3625 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003626
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003627 /* Stores the http version. */
3628 lua_pushstring(L, "version");
3629 lua_pushlstring(L, txn->req.chn->buf->p + txn->req.sl.rq.v, txn->req.sl.rq.v_l);
3630 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003631
Thierry FOURNIER841475e2015-12-11 17:10:09 +01003632 /* creates an array of headers. hlua_http_get_headers() crates and push
3633 * the array on the top of the stack.
3634 */
3635 lua_pushstring(L, "headers");
3636 htxn.s = s;
3637 htxn.p = px;
3638 htxn.dir = SMP_OPT_DIR_REQ;
3639 if (!hlua_http_get_headers(L, &htxn, &htxn.s->txn->req))
3640 return 0;
3641 lua_settable(L, -3);
3642
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003643 /* Get path and qs */
3644 path = http_get_path(txn);
Thierry FOURNIER7d388632017-02-22 02:06:16 +01003645 if (path) {
3646 end = txn->req.chn->buf->p + txn->req.sl.rq.u + txn->req.sl.rq.u_l;
3647 p = path;
3648 while (p < end && *p != '?')
3649 p++;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003650
Thierry FOURNIER7d388632017-02-22 02:06:16 +01003651 /* Stores the request path. */
3652 lua_pushstring(L, "path");
3653 lua_pushlstring(L, path, p - path);
3654 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003655
Thierry FOURNIER7d388632017-02-22 02:06:16 +01003656 /* Stores the query string. */
3657 lua_pushstring(L, "qs");
3658 if (*p == '?')
3659 p++;
3660 lua_pushlstring(L, p, end - p);
3661 lua_settable(L, -3);
3662 }
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01003663
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003664 /* Stores the request path. */
3665 lua_pushstring(L, "length");
3666 lua_pushinteger(L, txn->req.body_len);
3667 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01003668
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003669 /* Create an array of HTTP request headers. */
3670 lua_pushstring(L, "headers");
3671 MAY_LJMP(hlua_http_get_headers(L, &appctx->htxn, &appctx->htxn.s->txn->req));
3672 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01003673
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003674 /* Create an empty array of HTTP request headers. */
3675 lua_pushstring(L, "response");
3676 lua_newtable(L);
3677 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01003678
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003679 /* Pop a class stream metatable and affect it to the table. */
3680 lua_rawgeti(L, LUA_REGISTRYINDEX, class_applet_http_ref);
3681 lua_setmetatable(L, -2);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003682
3683 return 1;
3684}
3685
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003686__LJMP static int hlua_applet_http_set_var(lua_State *L)
3687{
3688 struct hlua_appctx *appctx;
3689 struct stream *s;
3690 const char *name;
3691 size_t len;
3692 struct sample smp;
3693
3694 MAY_LJMP(check_args(L, 3, "set_var"));
3695
3696 /* It is useles to retrieve the stream, but this function
3697 * runs only in a stream context.
3698 */
3699 appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3700 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3701 s = appctx->htxn.s;
3702
3703 /* Converts the third argument in a sample. */
3704 hlua_lua2smp(L, 3, &smp);
3705
3706 /* Store the sample in a variable. */
3707 smp_set_owner(&smp, s->be, s->sess, s, 0);
3708 vars_set_by_name(name, len, &smp);
3709 return 0;
3710}
3711
3712__LJMP static int hlua_applet_http_unset_var(lua_State *L)
3713{
3714 struct hlua_appctx *appctx;
3715 struct stream *s;
3716 const char *name;
3717 size_t len;
3718 struct sample smp;
3719
3720 MAY_LJMP(check_args(L, 2, "unset_var"));
3721
3722 /* It is useles to retrieve the stream, but this function
3723 * runs only in a stream context.
3724 */
3725 appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3726 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3727 s = appctx->htxn.s;
3728
3729 /* Unset the variable. */
3730 smp_set_owner(&smp, s->be, s->sess, s, 0);
3731 vars_unset_by_name(name, len, &smp);
3732 return 0;
3733}
3734
3735__LJMP static int hlua_applet_http_get_var(lua_State *L)
3736{
3737 struct hlua_appctx *appctx;
3738 struct stream *s;
3739 const char *name;
3740 size_t len;
3741 struct sample smp;
3742
3743 MAY_LJMP(check_args(L, 2, "get_var"));
3744
3745 /* It is useles to retrieve the stream, but this function
3746 * runs only in a stream context.
3747 */
3748 appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3749 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3750 s = appctx->htxn.s;
3751
3752 smp_set_owner(&smp, s->be, s->sess, s, 0);
3753 if (!vars_get_by_name(name, len, &smp)) {
3754 lua_pushnil(L);
3755 return 1;
3756 }
3757
3758 return hlua_smp2lua(L, &smp);
3759}
3760
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003761__LJMP static int hlua_applet_http_set_priv(lua_State *L)
3762{
3763 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3764 struct stream *s = appctx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01003765 struct hlua *hlua;
3766
3767 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01003768 if (!s->hlua)
3769 return 0;
3770 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003771
3772 MAY_LJMP(check_args(L, 2, "set_priv"));
3773
3774 /* Remove previous value. */
3775 if (hlua->Mref != -1)
3776 luaL_unref(L, hlua->Mref, LUA_REGISTRYINDEX);
3777
3778 /* Get and store new value. */
3779 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
3780 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
3781
3782 return 0;
3783}
3784
3785__LJMP static int hlua_applet_http_get_priv(lua_State *L)
3786{
3787 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3788 struct stream *s = appctx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01003789 struct hlua *hlua;
3790
3791 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01003792 if (!s->hlua) {
3793 lua_pushnil(L);
3794 return 1;
3795 }
3796 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003797
3798 /* Push configuration index in the stack. */
3799 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
3800
3801 return 1;
3802}
3803
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003804/* If expected data not yet available, it returns a yield. This function
3805 * consumes the data in the buffer. It returns a string containing the
3806 * data. This string can be empty.
3807 */
3808__LJMP static int hlua_applet_http_getline_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003809{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003810 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3811 struct stream_interface *si = appctx->appctx->owner;
3812 struct channel *chn = si_ic(si);
3813 int ret;
3814 char *blk1;
3815 int len1;
3816 char *blk2;
3817 int len2;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003818
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003819 /* Maybe we cant send a 100-continue ? */
3820 if (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_100C) {
3821 ret = bi_putblk(chn, HTTP_100C, strlen(HTTP_100C));
3822 /* if ret == -2 or -3 the channel closed or the message si too
3823 * big for the buffers. We cant send anything. So, we ignoring
3824 * the error, considers that the 100-continue is sent, and try
3825 * to receive.
3826 * If ret is -1, we dont have room in the buffer, so we yield.
3827 */
3828 if (ret == -1) {
3829 si_applet_cant_put(si);
3830 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_getline_yield, TICK_ETERNITY, 0));
3831 }
3832 appctx->appctx->ctx.hlua_apphttp.flags &= ~APPLET_100C;
3833 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003834
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003835 /* Check for the end of the data. */
3836 if (appctx->appctx->ctx.hlua_apphttp.left_bytes <= 0) {
3837 luaL_pushresult(&appctx->b);
3838 return 1;
3839 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003840
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003841 /* Read the maximum amount of data avalaible. */
3842 ret = bo_getline_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003843
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003844 /* Data not yet avalaible. return yield. */
3845 if (ret == 0) {
3846 si_applet_cant_get(si);
3847 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_getline_yield, TICK_ETERNITY, 0));
3848 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003849
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003850 /* End of data: commit the total strings and return. */
3851 if (ret < 0) {
3852 luaL_pushresult(&appctx->b);
3853 return 1;
3854 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003855
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003856 /* Ensure that the block 2 length is usable. */
3857 if (ret == 1)
3858 len2 = 0;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003859
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003860 /* Copy the fisrt block caping to the length required. */
3861 if (len1 > appctx->appctx->ctx.hlua_apphttp.left_bytes)
3862 len1 = appctx->appctx->ctx.hlua_apphttp.left_bytes;
3863 luaL_addlstring(&appctx->b, blk1, len1);
3864 appctx->appctx->ctx.hlua_apphttp.left_bytes -= len1;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003865
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003866 /* Copy the second block. */
3867 if (len2 > appctx->appctx->ctx.hlua_apphttp.left_bytes)
3868 len2 = appctx->appctx->ctx.hlua_apphttp.left_bytes;
3869 luaL_addlstring(&appctx->b, blk2, len2);
3870 appctx->appctx->ctx.hlua_apphttp.left_bytes -= len2;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003871
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003872 /* Consume input channel output buffer data. */
3873 bo_skip(si_oc(si), len1 + len2);
3874 luaL_pushresult(&appctx->b);
3875 return 1;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003876}
3877
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003878/* Check arguments for the fucntion "hlua_channel_get_yield". */
3879__LJMP static int hlua_applet_http_getline(lua_State *L)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003880{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003881 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003882
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003883 /* Initialise the string catenation. */
3884 luaL_buffinit(L, &appctx->b);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003885
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003886 return MAY_LJMP(hlua_applet_http_getline_yield(L, 0, 0));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003887}
3888
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003889/* If expected data not yet available, it returns a yield. This function
3890 * consumes the data in the buffer. It returns a string containing the
3891 * data. This string can be empty.
3892 */
3893__LJMP static int hlua_applet_http_recv_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003894{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003895 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3896 struct stream_interface *si = appctx->appctx->owner;
3897 int len = MAY_LJMP(luaL_checkinteger(L, 2));
3898 struct channel *chn = si_ic(si);
3899 int ret;
3900 char *blk1;
3901 int len1;
3902 char *blk2;
3903 int len2;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003904
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003905 /* Maybe we cant send a 100-continue ? */
3906 if (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_100C) {
3907 ret = bi_putblk(chn, HTTP_100C, strlen(HTTP_100C));
3908 /* if ret == -2 or -3 the channel closed or the message si too
3909 * big for the buffers. We cant send anything. So, we ignoring
3910 * the error, considers that the 100-continue is sent, and try
3911 * to receive.
3912 * If ret is -1, we dont have room in the buffer, so we yield.
3913 */
3914 if (ret == -1) {
3915 si_applet_cant_put(si);
3916 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_recv_yield, TICK_ETERNITY, 0));
3917 }
3918 appctx->appctx->ctx.hlua_apphttp.flags &= ~APPLET_100C;
3919 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003920
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003921 /* Read the maximum amount of data avalaible. */
3922 ret = bo_getblk_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003923
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003924 /* Data not yet avalaible. return yield. */
3925 if (ret == 0) {
3926 si_applet_cant_get(si);
3927 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_recv_yield, TICK_ETERNITY, 0));
3928 }
3929
3930 /* End of data: commit the total strings and return. */
3931 if (ret < 0) {
3932 luaL_pushresult(&appctx->b);
3933 return 1;
3934 }
3935
3936 /* Ensure that the block 2 length is usable. */
3937 if (ret == 1)
3938 len2 = 0;
3939
3940 /* Copy the fisrt block caping to the length required. */
3941 if (len1 > len)
3942 len1 = len;
3943 luaL_addlstring(&appctx->b, blk1, len1);
3944 len -= len1;
3945
3946 /* Copy the second block. */
3947 if (len2 > len)
3948 len2 = len;
3949 luaL_addlstring(&appctx->b, blk2, len2);
3950 len -= len2;
3951
3952 /* Consume input channel output buffer data. */
3953 bo_skip(si_oc(si), len1 + len2);
3954 if (appctx->appctx->ctx.hlua_apphttp.left_bytes != -1)
3955 appctx->appctx->ctx.hlua_apphttp.left_bytes -= len;
3956
3957 /* If we are no other data avalaible, yield waiting for new data. */
3958 if (len > 0) {
3959 lua_pushinteger(L, len);
3960 lua_replace(L, 2);
3961 si_applet_cant_get(si);
3962 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_recv_yield, TICK_ETERNITY, 0));
3963 }
3964
3965 /* return the result. */
3966 luaL_pushresult(&appctx->b);
3967 return 1;
3968}
3969
3970/* Check arguments for the fucntion "hlua_channel_get_yield". */
3971__LJMP static int hlua_applet_http_recv(lua_State *L)
3972{
3973 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3974 int len = -1;
3975
3976 /* Check arguments. */
3977 if (lua_gettop(L) > 2)
3978 WILL_LJMP(luaL_error(L, "The 'recv' function requires between 1 and 2 arguments."));
3979 if (lua_gettop(L) >= 2) {
3980 len = MAY_LJMP(luaL_checkinteger(L, 2));
3981 lua_pop(L, 1);
3982 }
3983
3984 /* Check the required length */
3985 if (len == -1 || len > appctx->appctx->ctx.hlua_apphttp.left_bytes)
3986 len = appctx->appctx->ctx.hlua_apphttp.left_bytes;
3987 lua_pushinteger(L, len);
3988
3989 /* Initialise the string catenation. */
3990 luaL_buffinit(L, &appctx->b);
3991
3992 return MAY_LJMP(hlua_applet_http_recv_yield(L, 0, 0));
3993}
3994
3995/* Append data in the output side of the buffer. This data is immediatly
3996 * sent. The fcuntion returns the ammount of data writed. If the buffer
3997 * cannot contains the data, the function yield. The function returns -1
3998 * if the channel is closed.
3999 */
4000__LJMP static int hlua_applet_http_send_yield(lua_State *L, int status, lua_KContext ctx)
4001{
4002 size_t len;
4003 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4004 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
4005 int l = MAY_LJMP(luaL_checkinteger(L, 3));
4006 struct stream_interface *si = appctx->appctx->owner;
4007 struct channel *chn = si_ic(si);
4008 int max;
4009
4010 /* Get the max amount of data which can write as input in the channel. */
4011 max = channel_recv_max(chn);
4012 if (max > (len - l))
4013 max = len - l;
4014
4015 /* Copy data. */
4016 bi_putblk(chn, str + l, max);
4017
4018 /* update counters. */
4019 l += max;
4020 lua_pop(L, 1);
4021 lua_pushinteger(L, l);
4022
4023 /* If some data is not send, declares the situation to the
4024 * applet, and returns a yield.
4025 */
4026 if (l < len) {
4027 si_applet_cant_put(si);
4028 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_send_yield, TICK_ETERNITY, 0));
4029 }
4030
4031 return 1;
4032}
4033
4034/* Just a wraper of "hlua_applet_send_yield". This wrapper permits
4035 * yield the LUA process, and resume it without checking the
4036 * input arguments.
4037 */
4038__LJMP static int hlua_applet_http_send(lua_State *L)
4039{
4040 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4041 size_t len;
4042 char hex[10];
4043
4044 MAY_LJMP(luaL_checklstring(L, 2, &len));
4045
4046 /* If transfer encoding chunked is selected, we surround the data
4047 * by chunk data.
4048 */
4049 if (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_CHUNKED) {
4050 snprintf(hex, 9, "%x", (unsigned int)len);
4051 lua_pushfstring(L, "%s\r\n", hex);
4052 lua_insert(L, 2); /* swap the last 2 entries. */
4053 lua_pushstring(L, "\r\n");
4054 lua_concat(L, 3);
4055 }
4056
4057 /* This interger is used for followinf the amount of data sent. */
4058 lua_pushinteger(L, 0);
4059
4060 /* We want to send some data. Headers must be sent. */
4061 if (!(appctx->appctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT)) {
4062 hlua_pusherror(L, "Lua: 'send' you must call start_response() before sending data.");
4063 WILL_LJMP(lua_error(L));
4064 }
4065
4066 return MAY_LJMP(hlua_applet_http_send_yield(L, 0, 0));
4067}
4068
4069__LJMP static int hlua_applet_http_addheader(lua_State *L)
4070{
4071 const char *name;
4072 int ret;
4073
4074 MAY_LJMP(hlua_checkapplet_http(L, 1));
4075 name = MAY_LJMP(luaL_checkstring(L, 2));
4076 MAY_LJMP(luaL_checkstring(L, 3));
4077
4078 /* Push in the stack the "response" entry. */
4079 ret = lua_getfield(L, 1, "response");
4080 if (ret != LUA_TTABLE) {
4081 hlua_pusherror(L, "Lua: 'add_header' internal error: AppletHTTP['response'] "
4082 "is expected as an array. %s found", lua_typename(L, ret));
4083 WILL_LJMP(lua_error(L));
4084 }
4085
4086 /* check if the header is already registered if it is not
4087 * the case, register it.
4088 */
4089 ret = lua_getfield(L, -1, name);
4090 if (ret == LUA_TNIL) {
4091
4092 /* Entry not found. */
4093 lua_pop(L, 1); /* remove the nil. The "response" table is the top of the stack. */
4094
4095 /* Insert the new header name in the array in the top of the stack.
4096 * It left the new array in the top of the stack.
4097 */
4098 lua_newtable(L);
4099 lua_pushvalue(L, 2);
4100 lua_pushvalue(L, -2);
4101 lua_settable(L, -4);
4102
4103 } else if (ret != LUA_TTABLE) {
4104
4105 /* corruption error. */
4106 hlua_pusherror(L, "Lua: 'add_header' internal error: AppletHTTP['response']['%s'] "
4107 "is expected as an array. %s found", name, lua_typename(L, ret));
4108 WILL_LJMP(lua_error(L));
4109 }
4110
4111 /* Now the top od thestack is an array of values. We push
4112 * the header value as new entry.
4113 */
4114 lua_pushvalue(L, 3);
4115 ret = lua_rawlen(L, -2);
4116 lua_rawseti(L, -2, ret + 1);
4117 lua_pushboolean(L, 1);
4118 return 1;
4119}
4120
4121__LJMP static int hlua_applet_http_status(lua_State *L)
4122{
4123 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4124 int status = MAY_LJMP(luaL_checkinteger(L, 2));
Robin H. Johnson52f5db22017-01-01 13:10:52 -08004125 const char *reason = MAY_LJMP(luaL_optlstring(L, 3, NULL, NULL));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004126
4127 if (status < 100 || status > 599) {
4128 lua_pushboolean(L, 0);
4129 return 1;
4130 }
4131
4132 appctx->appctx->ctx.hlua_apphttp.status = status;
Robin H. Johnson52f5db22017-01-01 13:10:52 -08004133 appctx->appctx->ctx.hlua_apphttp.reason = reason;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004134 lua_pushboolean(L, 1);
4135 return 1;
4136}
4137
4138/* We will build the status line and the headers of the HTTP response.
4139 * We will try send at once if its not possible, we give back the hand
4140 * waiting for more room.
4141 */
4142__LJMP static int hlua_applet_http_start_response_yield(lua_State *L, int status, lua_KContext ctx)
4143{
4144 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4145 struct stream_interface *si = appctx->appctx->owner;
4146 struct channel *chn = si_ic(si);
4147 int ret;
4148 size_t len;
4149 const char *msg;
4150
4151 /* Get the message as the first argument on the stack. */
4152 msg = MAY_LJMP(luaL_checklstring(L, 2, &len));
4153
4154 /* Send the message at once. */
4155 ret = bi_putblk(chn, msg, len);
4156
4157 /* if ret == -2 or -3 the channel closed or the message si too
4158 * big for the buffers.
4159 */
4160 if (ret == -2 || ret == -3) {
4161 hlua_pusherror(L, "Lua: 'start_response': response header block too big");
4162 WILL_LJMP(lua_error(L));
4163 }
4164
4165 /* If ret is -1, we dont have room in the buffer, so we yield. */
4166 if (ret == -1) {
4167 si_applet_cant_put(si);
4168 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_start_response_yield, TICK_ETERNITY, 0));
4169 }
4170
4171 /* Headers sent, set the flag. */
4172 appctx->appctx->ctx.hlua_apphttp.flags |= APPLET_HDR_SENT;
4173 return 0;
4174}
4175
4176__LJMP static int hlua_applet_http_start_response(lua_State *L)
4177{
4178 struct chunk *tmp = get_trash_chunk();
4179 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004180 const char *name;
4181 const char *value;
4182 int id;
4183 int hdr_connection = 0;
4184 int hdr_contentlength = -1;
4185 int hdr_chunked = 0;
Robin H. Johnson52f5db22017-01-01 13:10:52 -08004186 const char *reason = appctx->appctx->ctx.hlua_apphttp.reason;
4187
4188 if (reason == NULL)
4189 reason = get_reason(appctx->appctx->ctx.hlua_apphttp.status);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004190
4191 /* Use the same http version than the request. */
4192 chunk_appendf(tmp, "HTTP/1.%c %d %s\r\n",
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +01004193 appctx->appctx->ctx.hlua_apphttp.flags & APPLET_HTTP11 ? '1' : '0',
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004194 appctx->appctx->ctx.hlua_apphttp.status,
Robin H. Johnson52f5db22017-01-01 13:10:52 -08004195 reason);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004196
4197 /* Get the array associated to the field "response" in the object AppletHTTP. */
4198 lua_pushvalue(L, 0);
4199 if (lua_getfield(L, 1, "response") != LUA_TTABLE) {
4200 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response'] missing.\n",
4201 appctx->appctx->rule->arg.hlua_rule->fcn.name);
4202 WILL_LJMP(lua_error(L));
4203 }
4204
4205 /* Browse the list of headers. */
4206 lua_pushnil(L);
4207 while(lua_next(L, -2) != 0) {
4208
4209 /* We expect a string as -2. */
4210 if (lua_type(L, -2) != LUA_TSTRING) {
4211 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response'][] element must be a string. got %s.\n",
4212 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4213 lua_typename(L, lua_type(L, -2)));
4214 WILL_LJMP(lua_error(L));
4215 }
4216 name = lua_tostring(L, -2);
4217
4218 /* We expect an array as -1. */
4219 if (lua_type(L, -1) != LUA_TTABLE) {
4220 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'] element must be an table. got %s.\n",
4221 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4222 name,
4223 lua_typename(L, lua_type(L, -1)));
4224 WILL_LJMP(lua_error(L));
4225 }
4226
4227 /* Browse the table who is on the top of the stack. */
4228 lua_pushnil(L);
4229 while(lua_next(L, -2) != 0) {
4230
4231 /* We expect a number as -2. */
4232 if (lua_type(L, -2) != LUA_TNUMBER) {
4233 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'][] element must be a number. got %s.\n",
4234 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4235 name,
4236 lua_typename(L, lua_type(L, -2)));
4237 WILL_LJMP(lua_error(L));
4238 }
4239 id = lua_tointeger(L, -2);
4240
4241 /* We expect a string as -2. */
4242 if (lua_type(L, -1) != LUA_TSTRING) {
4243 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'][%d] element must be a string. got %s.\n",
4244 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4245 name, id,
4246 lua_typename(L, lua_type(L, -1)));
4247 WILL_LJMP(lua_error(L));
4248 }
4249 value = lua_tostring(L, -1);
4250
4251 /* Catenate a new header. */
4252 chunk_appendf(tmp, "%s: %s\r\n", name, value);
4253
4254 /* Protocol checks. */
4255
4256 /* Check if the header conneciton is present. */
4257 if (strcasecmp("connection", name) == 0)
4258 hdr_connection = 1;
4259
4260 /* Copy the header content length. The length conversion
4261 * is done without control. If it contains a ad value, this
4262 * is not our problem.
4263 */
4264 if (strcasecmp("content-length", name) == 0)
4265 hdr_contentlength = atoi(value);
4266
4267 /* Check if the client annouces a transfer-encoding chunked it self. */
4268 if (strcasecmp("transfer-encoding", name) == 0 &&
4269 strcasecmp("chunked", value) == 0)
4270 hdr_chunked = 1;
4271
4272 /* Remove the array from the stack, and get next element with a remaining string. */
4273 lua_pop(L, 1);
4274 }
4275
4276 /* Remove the array from the stack, and get next element with a remaining string. */
4277 lua_pop(L, 1);
4278 }
4279
4280 /* If the http protocol version is 1.1, we expect an header "connection" set
4281 * to "close" to be HAProxy/keeplive compliant. Otherwise, we expect nothing.
4282 * If the header conneciton is present, don't change it, if it is not present,
4283 * we must set.
4284 *
4285 * we set a "connection: close" header for ensuring that the keepalive will be
4286 * respected by haproxy. HAProcy considers that the application cloe the connection
4287 * and it keep the connection from the client open.
4288 */
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +01004289 if (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_HTTP11 && !hdr_connection)
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004290 chunk_appendf(tmp, "Connection: close\r\n");
4291
4292 /* If we dont have a content-length set, we must announce a transfer enconding
4293 * chunked. This is required by haproxy for the keepalive compliance.
4294 * If the applet annouce a transfer-encoding chunked itslef, don't
4295 * do anything.
4296 */
4297 if (hdr_contentlength == -1 && hdr_chunked == 0) {
4298 chunk_appendf(tmp, "Transfer-encoding: chunked\r\n");
4299 appctx->appctx->ctx.hlua_apphttp.flags |= APPLET_CHUNKED;
4300 }
4301
4302 /* Finalize headers. */
4303 chunk_appendf(tmp, "\r\n");
4304
4305 /* Remove the last entry and the array of headers */
4306 lua_pop(L, 2);
4307
4308 /* Push the headers block. */
4309 lua_pushlstring(L, tmp->str, tmp->len);
4310
4311 return MAY_LJMP(hlua_applet_http_start_response_yield(L, 0, 0));
4312}
4313
4314/*
4315 *
4316 *
4317 * Class HTTP
4318 *
4319 *
4320 */
4321
4322/* Returns a struct hlua_txn if the stack entry "ud" is
4323 * a class stream, otherwise it throws an error.
4324 */
4325__LJMP static struct hlua_txn *hlua_checkhttp(lua_State *L, int ud)
4326{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02004327 return MAY_LJMP(hlua_checkudata(L, ud, class_http_ref));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004328}
4329
4330/* This function creates and push in the stack a HTTP object
4331 * according with a current TXN.
4332 */
4333static int hlua_http_new(lua_State *L, struct hlua_txn *txn)
4334{
4335 struct hlua_txn *htxn;
4336
4337 /* Check stack size. */
4338 if (!lua_checkstack(L, 3))
4339 return 0;
4340
4341 /* Create the object: obj[0] = userdata.
4342 * Note that the base of the Converters object is the
4343 * same than the TXN object.
4344 */
4345 lua_newtable(L);
4346 htxn = lua_newuserdata(L, sizeof(*htxn));
4347 lua_rawseti(L, -2, 0);
4348
4349 htxn->s = txn->s;
4350 htxn->p = txn->p;
4351
4352 /* Pop a class stream metatable and affect it to the table. */
4353 lua_rawgeti(L, LUA_REGISTRYINDEX, class_http_ref);
4354 lua_setmetatable(L, -2);
4355
4356 return 1;
4357}
4358
4359/* This function creates ans returns an array of HTTP headers.
4360 * This function does not fails. It is used as wrapper with the
4361 * 2 following functions.
4362 */
4363__LJMP static int hlua_http_get_headers(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg)
4364{
4365 const char *cur_ptr, *cur_next, *p;
4366 int old_idx, cur_idx;
4367 struct hdr_idx_elem *cur_hdr;
4368 const char *hn, *hv;
4369 int hnl, hvl;
4370 int type;
4371 const char *in;
4372 char *out;
4373 int len;
4374
4375 /* Create the table. */
4376 lua_newtable(L);
4377
4378 if (!htxn->s->txn)
4379 return 1;
4380
Thierry FOURNIER / OZON.IOb84ae922016-08-02 23:44:58 +02004381 /* Check if a valid response is parsed */
4382 if (unlikely(msg->msg_state < HTTP_MSG_BODY))
4383 return 1;
4384
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004385 /* Build array of headers. */
4386 old_idx = 0;
4387 cur_next = msg->chn->buf->p + hdr_idx_first_pos(&htxn->s->txn->hdr_idx);
4388
4389 while (1) {
4390 cur_idx = htxn->s->txn->hdr_idx.v[old_idx].next;
4391 if (!cur_idx)
4392 break;
4393 old_idx = cur_idx;
4394
4395 cur_hdr = &htxn->s->txn->hdr_idx.v[cur_idx];
4396 cur_ptr = cur_next;
4397 cur_next = cur_ptr + cur_hdr->len + cur_hdr->cr + 1;
4398
4399 /* Now we have one full header at cur_ptr of len cur_hdr->len,
4400 * and the next header starts at cur_next. We'll check
4401 * this header in the list as well as against the default
4402 * rule.
4403 */
4404
4405 /* look for ': *'. */
4406 hn = cur_ptr;
4407 for (p = cur_ptr; p < cur_ptr + cur_hdr->len && *p != ':'; p++);
4408 if (p >= cur_ptr+cur_hdr->len)
4409 continue;
4410 hnl = p - hn;
4411 p++;
4412 while (p < cur_ptr+cur_hdr->len && ( *p == ' ' || *p == '\t' ))
4413 p++;
4414 if (p >= cur_ptr+cur_hdr->len)
4415 continue;
4416 hv = p;
4417 hvl = cur_ptr+cur_hdr->len-p;
4418
4419 /* Lowercase the key. Don't check the size of trash, it have
4420 * the size of one buffer and the input data contains in one
4421 * buffer.
4422 */
4423 out = trash.str;
4424 for (in=hn; in<hn+hnl; in++, out++)
4425 *out = tolower(*in);
4426 *out = '\0';
4427
4428 /* Check for existing entry:
4429 * assume that the table is on the top of the stack, and
4430 * push the key in the stack, the function lua_gettable()
4431 * perform the lookup.
4432 */
4433 lua_pushlstring(L, trash.str, hnl);
4434 lua_gettable(L, -2);
4435 type = lua_type(L, -1);
4436
4437 switch (type) {
4438 case LUA_TNIL:
4439 /* Table not found, create it. */
4440 lua_pop(L, 1); /* remove the nil value. */
4441 lua_pushlstring(L, trash.str, hnl); /* push the header name as key. */
4442 lua_newtable(L); /* create and push empty table. */
4443 lua_pushlstring(L, hv, hvl); /* push header value. */
4444 lua_rawseti(L, -2, 0); /* index header value (pop it). */
4445 lua_rawset(L, -3); /* index new table with header name (pop the values). */
4446 break;
4447
4448 case LUA_TTABLE:
4449 /* Entry found: push the value in the table. */
4450 len = lua_rawlen(L, -1);
4451 lua_pushlstring(L, hv, hvl); /* push header value. */
4452 lua_rawseti(L, -2, len+1); /* index header value (pop it). */
4453 lua_pop(L, 1); /* remove the table (it is stored in the main table). */
4454 break;
4455
4456 default:
4457 /* Other cases are errors. */
4458 hlua_pusherror(L, "internal error during the parsing of headers.");
4459 WILL_LJMP(lua_error(L));
4460 }
4461 }
4462
4463 return 1;
4464}
4465
4466__LJMP static int hlua_http_req_get_headers(lua_State *L)
4467{
4468 struct hlua_txn *htxn;
4469
4470 MAY_LJMP(check_args(L, 1, "req_get_headers"));
4471 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4472
4473 return hlua_http_get_headers(L, htxn, &htxn->s->txn->req);
4474}
4475
4476__LJMP static int hlua_http_res_get_headers(lua_State *L)
4477{
4478 struct hlua_txn *htxn;
4479
4480 MAY_LJMP(check_args(L, 1, "res_get_headers"));
4481 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4482
4483 return hlua_http_get_headers(L, htxn, &htxn->s->txn->rsp);
4484}
4485
4486/* This function replace full header, or just a value in
4487 * the request or in the response. It is a wrapper fir the
4488 * 4 following functions.
4489 */
4490__LJMP static inline int hlua_http_rep_hdr(lua_State *L, struct hlua_txn *htxn,
4491 struct http_msg *msg, int action)
4492{
4493 size_t name_len;
4494 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
4495 const char *reg = MAY_LJMP(luaL_checkstring(L, 3));
4496 const char *value = MAY_LJMP(luaL_checkstring(L, 4));
4497 struct my_regex re;
4498
Thierry FOURNIER / OZON.IOb84ae922016-08-02 23:44:58 +02004499 /* Check if a valid response is parsed */
4500 if (unlikely(msg->msg_state < HTTP_MSG_BODY))
4501 return 0;
4502
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004503 if (!regex_comp(reg, &re, 1, 1, NULL))
4504 WILL_LJMP(luaL_argerror(L, 3, "invalid regex"));
4505
4506 http_transform_header_str(htxn->s, msg, name, name_len, value, &re, action);
4507 regex_free(&re);
4508 return 0;
4509}
4510
4511__LJMP static int hlua_http_req_rep_hdr(lua_State *L)
4512{
4513 struct hlua_txn *htxn;
4514
4515 MAY_LJMP(check_args(L, 4, "req_rep_hdr"));
4516 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4517
4518 return MAY_LJMP(hlua_http_rep_hdr(L, htxn, &htxn->s->txn->req, ACT_HTTP_REPLACE_HDR));
4519}
4520
4521__LJMP static int hlua_http_res_rep_hdr(lua_State *L)
4522{
4523 struct hlua_txn *htxn;
4524
4525 MAY_LJMP(check_args(L, 4, "res_rep_hdr"));
4526 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4527
4528 return MAY_LJMP(hlua_http_rep_hdr(L, htxn, &htxn->s->txn->rsp, ACT_HTTP_REPLACE_HDR));
4529}
4530
4531__LJMP static int hlua_http_req_rep_val(lua_State *L)
4532{
4533 struct hlua_txn *htxn;
4534
4535 MAY_LJMP(check_args(L, 4, "req_rep_hdr"));
4536 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4537
4538 return MAY_LJMP(hlua_http_rep_hdr(L, htxn, &htxn->s->txn->req, ACT_HTTP_REPLACE_VAL));
4539}
4540
4541__LJMP static int hlua_http_res_rep_val(lua_State *L)
4542{
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004543 struct hlua_txn *htxn;
4544
4545 MAY_LJMP(check_args(L, 4, "res_rep_val"));
4546 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4547
Thierry FOURNIER0ea5c7f2015-08-05 19:05:19 +02004548 return MAY_LJMP(hlua_http_rep_hdr(L, htxn, &htxn->s->txn->rsp, ACT_HTTP_REPLACE_VAL));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004549}
4550
4551/* This function deletes all the occurences of an header.
4552 * It is a wrapper for the 2 following functions.
4553 */
4554__LJMP static inline int hlua_http_del_hdr(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg)
4555{
4556 size_t len;
4557 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &len));
4558 struct hdr_ctx ctx;
Willy Tarreaueee5b512015-04-03 23:46:31 +02004559 struct http_txn *txn = htxn->s->txn;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004560
Thierry FOURNIER / OZON.IOb84ae922016-08-02 23:44:58 +02004561 /* Check if a valid response is parsed */
4562 if (unlikely(msg->msg_state < HTTP_MSG_BODY))
4563 return 0;
4564
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004565 ctx.idx = 0;
4566 while (http_find_header2(name, len, msg->chn->buf->p, &txn->hdr_idx, &ctx))
4567 http_remove_header2(msg, &txn->hdr_idx, &ctx);
4568 return 0;
4569}
4570
4571__LJMP static int hlua_http_req_del_hdr(lua_State *L)
4572{
4573 struct hlua_txn *htxn;
4574
4575 MAY_LJMP(check_args(L, 2, "req_del_hdr"));
4576 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4577
Willy Tarreaueee5b512015-04-03 23:46:31 +02004578 return hlua_http_del_hdr(L, htxn, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004579}
4580
4581__LJMP static int hlua_http_res_del_hdr(lua_State *L)
4582{
4583 struct hlua_txn *htxn;
4584
4585 MAY_LJMP(check_args(L, 2, "req_del_hdr"));
4586 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4587
Willy Tarreaueee5b512015-04-03 23:46:31 +02004588 return hlua_http_del_hdr(L, htxn, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004589}
4590
4591/* This function adds an header. It is a wrapper used by
4592 * the 2 following functions.
4593 */
4594__LJMP static inline int hlua_http_add_hdr(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg)
4595{
4596 size_t name_len;
4597 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
4598 size_t value_len;
4599 const char *value = MAY_LJMP(luaL_checklstring(L, 3, &value_len));
4600 char *p;
4601
Thierry FOURNIER / OZON.IOb84ae922016-08-02 23:44:58 +02004602 /* Check if a valid message is parsed */
4603 if (unlikely(msg->msg_state < HTTP_MSG_BODY))
4604 return 0;
4605
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004606 /* Check length. */
4607 trash.len = value_len + name_len + 2;
4608 if (trash.len > trash.size)
4609 return 0;
4610
4611 /* Creates the header string. */
4612 p = trash.str;
4613 memcpy(p, name, name_len);
4614 p += name_len;
4615 *p = ':';
4616 p++;
4617 *p = ' ';
4618 p++;
4619 memcpy(p, value, value_len);
4620
Willy Tarreaueee5b512015-04-03 23:46:31 +02004621 lua_pushboolean(L, http_header_add_tail2(msg, &htxn->s->txn->hdr_idx,
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004622 trash.str, trash.len) != 0);
4623
4624 return 0;
4625}
4626
4627__LJMP static int hlua_http_req_add_hdr(lua_State *L)
4628{
4629 struct hlua_txn *htxn;
4630
4631 MAY_LJMP(check_args(L, 3, "req_add_hdr"));
4632 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4633
Willy Tarreaueee5b512015-04-03 23:46:31 +02004634 return hlua_http_add_hdr(L, htxn, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004635}
4636
4637__LJMP static int hlua_http_res_add_hdr(lua_State *L)
4638{
4639 struct hlua_txn *htxn;
4640
4641 MAY_LJMP(check_args(L, 3, "res_add_hdr"));
4642 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4643
Willy Tarreaueee5b512015-04-03 23:46:31 +02004644 return hlua_http_add_hdr(L, htxn, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004645}
4646
4647static int hlua_http_req_set_hdr(lua_State *L)
4648{
4649 struct hlua_txn *htxn;
4650
4651 MAY_LJMP(check_args(L, 3, "req_set_hdr"));
4652 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4653
Willy Tarreaueee5b512015-04-03 23:46:31 +02004654 hlua_http_del_hdr(L, htxn, &htxn->s->txn->req);
4655 return hlua_http_add_hdr(L, htxn, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004656}
4657
4658static int hlua_http_res_set_hdr(lua_State *L)
4659{
4660 struct hlua_txn *htxn;
4661
4662 MAY_LJMP(check_args(L, 3, "res_set_hdr"));
4663 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4664
Willy Tarreaueee5b512015-04-03 23:46:31 +02004665 hlua_http_del_hdr(L, htxn, &htxn->s->txn->rsp);
4666 return hlua_http_add_hdr(L, htxn, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004667}
4668
4669/* This function set the method. */
4670static int hlua_http_req_set_meth(lua_State *L)
4671{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02004672 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004673 size_t name_len;
4674 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004675
Thierry FOURNIER / OZON.IOb84ae922016-08-02 23:44:58 +02004676 /* Check if a valid request is parsed */
4677 if (unlikely(htxn->s->txn->req.msg_state < HTTP_MSG_BODY)) {
4678 lua_pushboolean(L, 0);
4679 return 1;
4680 }
4681
Willy Tarreau987e3fb2015-04-04 01:09:08 +02004682 lua_pushboolean(L, http_replace_req_line(0, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004683 return 1;
4684}
4685
4686/* This function set the method. */
4687static int hlua_http_req_set_path(lua_State *L)
4688{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02004689 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004690 size_t name_len;
4691 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER / OZON.IOb84ae922016-08-02 23:44:58 +02004692
4693 /* Check if a valid request is parsed */
4694 if (unlikely(htxn->s->txn->req.msg_state < HTTP_MSG_BODY)) {
4695 lua_pushboolean(L, 0);
4696 return 1;
4697 }
4698
Willy Tarreau987e3fb2015-04-04 01:09:08 +02004699 lua_pushboolean(L, http_replace_req_line(1, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004700 return 1;
4701}
4702
4703/* This function set the query-string. */
4704static int hlua_http_req_set_query(lua_State *L)
4705{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02004706 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004707 size_t name_len;
4708 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004709
Thierry FOURNIER / OZON.IOb84ae922016-08-02 23:44:58 +02004710 /* Check if a valid request is parsed */
4711 if (unlikely(htxn->s->txn->req.msg_state < HTTP_MSG_BODY)) {
4712 lua_pushboolean(L, 0);
4713 return 1;
4714 }
4715
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004716 /* Check length. */
4717 if (name_len > trash.size - 1) {
4718 lua_pushboolean(L, 0);
4719 return 1;
4720 }
4721
4722 /* Add the mark question as prefix. */
4723 chunk_reset(&trash);
4724 trash.str[trash.len++] = '?';
4725 memcpy(trash.str + trash.len, name, name_len);
4726 trash.len += name_len;
4727
Willy Tarreau987e3fb2015-04-04 01:09:08 +02004728 lua_pushboolean(L, http_replace_req_line(2, trash.str, trash.len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004729 return 1;
4730}
4731
4732/* This function set the uri. */
4733static int hlua_http_req_set_uri(lua_State *L)
4734{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02004735 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004736 size_t name_len;
4737 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004738
Thierry FOURNIER / OZON.IOb84ae922016-08-02 23:44:58 +02004739 /* Check if a valid request is parsed */
4740 if (unlikely(htxn->s->txn->req.msg_state < HTTP_MSG_BODY)) {
4741 lua_pushboolean(L, 0);
4742 return 1;
4743 }
4744
Willy Tarreau987e3fb2015-04-04 01:09:08 +02004745 lua_pushboolean(L, http_replace_req_line(3, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004746 return 1;
4747}
4748
Robin H. Johnson52f5db22017-01-01 13:10:52 -08004749/* This function set the response code & optionally reason. */
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02004750static int hlua_http_res_set_status(lua_State *L)
4751{
4752 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4753 unsigned int code = MAY_LJMP(luaL_checkinteger(L, 2));
Robin H. Johnson52f5db22017-01-01 13:10:52 -08004754 const char *reason = MAY_LJMP(luaL_optlstring(L, 3, NULL, NULL));
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02004755
Thierry FOURNIER / OZON.IOb84ae922016-08-02 23:44:58 +02004756 /* Check if a valid response is parsed */
4757 if (unlikely(htxn->s->txn->rsp.msg_state < HTTP_MSG_BODY))
4758 return 0;
4759
Robin H. Johnson52f5db22017-01-01 13:10:52 -08004760 http_set_status(code, reason, htxn->s);
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02004761 return 0;
4762}
4763
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004764/*
4765 *
4766 *
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004767 * Class TXN
4768 *
4769 *
4770 */
4771
4772/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02004773 * a class stream, otherwise it throws an error.
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004774 */
4775__LJMP static struct hlua_txn *hlua_checktxn(lua_State *L, int ud)
4776{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02004777 return MAY_LJMP(hlua_checkudata(L, ud, class_txn_ref));
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004778}
4779
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02004780__LJMP static int hlua_set_var(lua_State *L)
4781{
4782 struct hlua_txn *htxn;
4783 const char *name;
4784 size_t len;
4785 struct sample smp;
4786
4787 MAY_LJMP(check_args(L, 3, "set_var"));
4788
4789 /* It is useles to retrieve the stream, but this function
4790 * runs only in a stream context.
4791 */
4792 htxn = MAY_LJMP(hlua_checktxn(L, 1));
4793 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
4794
4795 /* Converts the third argument in a sample. */
4796 hlua_lua2smp(L, 3, &smp);
4797
4798 /* Store the sample in a variable. */
Willy Tarreau7560dd42016-03-10 16:28:58 +01004799 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
Willy Tarreau6204cd92016-03-10 16:33:04 +01004800 vars_set_by_name(name, len, &smp);
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02004801 return 0;
4802}
4803
Christopher Faulet85d79c92016-11-09 16:54:56 +01004804__LJMP static int hlua_unset_var(lua_State *L)
4805{
4806 struct hlua_txn *htxn;
4807 const char *name;
4808 size_t len;
4809 struct sample smp;
4810
4811 MAY_LJMP(check_args(L, 2, "unset_var"));
4812
4813 /* It is useles to retrieve the stream, but this function
4814 * runs only in a stream context.
4815 */
4816 htxn = MAY_LJMP(hlua_checktxn(L, 1));
4817 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
4818
4819 /* Unset the variable. */
4820 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
4821 vars_unset_by_name(name, len, &smp);
4822 return 0;
4823}
4824
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02004825__LJMP static int hlua_get_var(lua_State *L)
4826{
4827 struct hlua_txn *htxn;
4828 const char *name;
4829 size_t len;
4830 struct sample smp;
4831
4832 MAY_LJMP(check_args(L, 2, "get_var"));
4833
4834 /* It is useles to retrieve the stream, but this function
4835 * runs only in a stream context.
4836 */
4837 htxn = MAY_LJMP(hlua_checktxn(L, 1));
4838 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
4839
Willy Tarreau7560dd42016-03-10 16:28:58 +01004840 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
Willy Tarreau6204cd92016-03-10 16:33:04 +01004841 if (!vars_get_by_name(name, len, &smp)) {
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02004842 lua_pushnil(L);
4843 return 1;
4844 }
4845
4846 return hlua_smp2lua(L, &smp);
4847}
4848
Willy Tarreau59551662015-03-10 14:23:13 +01004849__LJMP static int hlua_set_priv(lua_State *L)
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01004850{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01004851 struct hlua *hlua;
4852
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01004853 MAY_LJMP(check_args(L, 2, "set_priv"));
4854
Willy Tarreau87b09662015-04-03 00:22:06 +02004855 /* It is useles to retrieve the stream, but this function
4856 * runs only in a stream context.
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01004857 */
4858 MAY_LJMP(hlua_checktxn(L, 1));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01004859 hlua = hlua_gethlua(L);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01004860
4861 /* Remove previous value. */
4862 if (hlua->Mref != -1)
4863 luaL_unref(L, hlua->Mref, LUA_REGISTRYINDEX);
4864
4865 /* Get and store new value. */
4866 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
4867 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
4868
4869 return 0;
4870}
4871
Willy Tarreau59551662015-03-10 14:23:13 +01004872__LJMP static int hlua_get_priv(lua_State *L)
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01004873{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01004874 struct hlua *hlua;
4875
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01004876 MAY_LJMP(check_args(L, 1, "get_priv"));
4877
Willy Tarreau87b09662015-04-03 00:22:06 +02004878 /* It is useles to retrieve the stream, but this function
4879 * runs only in a stream context.
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01004880 */
4881 MAY_LJMP(hlua_checktxn(L, 1));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01004882 hlua = hlua_gethlua(L);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01004883
4884 /* Push configuration index in the stack. */
4885 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
4886
4887 return 1;
4888}
4889
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004890/* Create stack entry containing a class TXN. This function
4891 * return 0 if the stack does not contains free slots,
4892 * otherwise it returns 1.
4893 */
Thierry FOURNIERab00df62016-07-14 11:42:37 +02004894static int hlua_txn_new(lua_State *L, struct stream *s, struct proxy *p, int dir, int flags)
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004895{
Willy Tarreaude491382015-04-06 11:04:28 +02004896 struct hlua_txn *htxn;
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004897
4898 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01004899 if (!lua_checkstack(L, 3))
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004900 return 0;
4901
4902 /* NOTE: The allocation never fails. The failure
4903 * throw an error, and the function never returns.
4904 * if the throw is not avalaible, the process is aborted.
4905 */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01004906 /* Create the object: obj[0] = userdata. */
4907 lua_newtable(L);
Willy Tarreaude491382015-04-06 11:04:28 +02004908 htxn = lua_newuserdata(L, sizeof(*htxn));
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01004909 lua_rawseti(L, -2, 0);
4910
Willy Tarreaude491382015-04-06 11:04:28 +02004911 htxn->s = s;
4912 htxn->p = p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01004913 htxn->dir = dir;
Thierry FOURNIERab00df62016-07-14 11:42:37 +02004914 htxn->flags = flags;
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004915
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01004916 /* Create the "f" field that contains a list of fetches. */
4917 lua_pushstring(L, "f");
Thierry FOURNIERca988662015-12-20 18:43:03 +01004918 if (!hlua_fetches_new(L, htxn, HLUA_F_MAY_USE_HTTP))
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01004919 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02004920 lua_rawset(L, -3);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01004921
4922 /* Create the "sf" field that contains a list of stringsafe fetches. */
4923 lua_pushstring(L, "sf");
Thierry FOURNIERca988662015-12-20 18:43:03 +01004924 if (!hlua_fetches_new(L, htxn, HLUA_F_MAY_USE_HTTP | HLUA_F_AS_STRING))
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01004925 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02004926 lua_rawset(L, -3);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01004927
Thierry FOURNIER594afe72015-03-10 23:58:30 +01004928 /* Create the "c" field that contains a list of converters. */
4929 lua_pushstring(L, "c");
Willy Tarreaude491382015-04-06 11:04:28 +02004930 if (!hlua_converters_new(L, htxn, 0))
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01004931 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02004932 lua_rawset(L, -3);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01004933
4934 /* Create the "sc" field that contains a list of stringsafe converters. */
4935 lua_pushstring(L, "sc");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01004936 if (!hlua_converters_new(L, htxn, HLUA_F_AS_STRING))
Thierry FOURNIER594afe72015-03-10 23:58:30 +01004937 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02004938 lua_rawset(L, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01004939
Thierry FOURNIER397826a2015-03-11 19:39:09 +01004940 /* Create the "req" field that contains the request channel object. */
4941 lua_pushstring(L, "req");
Willy Tarreau2a71af42015-03-10 13:51:50 +01004942 if (!hlua_channel_new(L, &s->req))
Thierry FOURNIER397826a2015-03-11 19:39:09 +01004943 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02004944 lua_rawset(L, -3);
Thierry FOURNIER397826a2015-03-11 19:39:09 +01004945
4946 /* Create the "res" field that contains the response channel object. */
4947 lua_pushstring(L, "res");
Willy Tarreau2a71af42015-03-10 13:51:50 +01004948 if (!hlua_channel_new(L, &s->res))
Thierry FOURNIER397826a2015-03-11 19:39:09 +01004949 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02004950 lua_rawset(L, -3);
Thierry FOURNIER397826a2015-03-11 19:39:09 +01004951
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004952 /* Creates the HTTP object is the current proxy allows http. */
4953 lua_pushstring(L, "http");
4954 if (p->mode == PR_MODE_HTTP) {
Willy Tarreaude491382015-04-06 11:04:28 +02004955 if (!hlua_http_new(L, htxn))
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004956 return 0;
4957 }
4958 else
4959 lua_pushnil(L);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02004960 lua_rawset(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004961
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01004962 /* Pop a class sesison metatable and affect it to the userdata. */
4963 lua_rawgeti(L, LUA_REGISTRYINDEX, class_txn_ref);
4964 lua_setmetatable(L, -2);
4965
4966 return 1;
4967}
4968
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01004969__LJMP static int hlua_txn_deflog(lua_State *L)
4970{
4971 const char *msg;
4972 struct hlua_txn *htxn;
4973
4974 MAY_LJMP(check_args(L, 2, "deflog"));
4975 htxn = MAY_LJMP(hlua_checktxn(L, 1));
4976 msg = MAY_LJMP(luaL_checkstring(L, 2));
4977
4978 hlua_sendlog(htxn->s->be, htxn->s->logs.level, msg);
4979 return 0;
4980}
4981
4982__LJMP static int hlua_txn_log(lua_State *L)
4983{
4984 int level;
4985 const char *msg;
4986 struct hlua_txn *htxn;
4987
4988 MAY_LJMP(check_args(L, 3, "log"));
4989 htxn = MAY_LJMP(hlua_checktxn(L, 1));
4990 level = MAY_LJMP(luaL_checkinteger(L, 2));
4991 msg = MAY_LJMP(luaL_checkstring(L, 3));
4992
4993 if (level < 0 || level >= NB_LOG_LEVELS)
4994 WILL_LJMP(luaL_argerror(L, 1, "Invalid loglevel."));
4995
4996 hlua_sendlog(htxn->s->be, level, msg);
4997 return 0;
4998}
4999
5000__LJMP static int hlua_txn_log_debug(lua_State *L)
5001{
5002 const char *msg;
5003 struct hlua_txn *htxn;
5004
5005 MAY_LJMP(check_args(L, 2, "Debug"));
5006 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5007 msg = MAY_LJMP(luaL_checkstring(L, 2));
5008 hlua_sendlog(htxn->s->be, LOG_DEBUG, msg);
5009 return 0;
5010}
5011
5012__LJMP static int hlua_txn_log_info(lua_State *L)
5013{
5014 const char *msg;
5015 struct hlua_txn *htxn;
5016
5017 MAY_LJMP(check_args(L, 2, "Info"));
5018 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5019 msg = MAY_LJMP(luaL_checkstring(L, 2));
5020 hlua_sendlog(htxn->s->be, LOG_INFO, msg);
5021 return 0;
5022}
5023
5024__LJMP static int hlua_txn_log_warning(lua_State *L)
5025{
5026 const char *msg;
5027 struct hlua_txn *htxn;
5028
5029 MAY_LJMP(check_args(L, 2, "Warning"));
5030 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5031 msg = MAY_LJMP(luaL_checkstring(L, 2));
5032 hlua_sendlog(htxn->s->be, LOG_WARNING, msg);
5033 return 0;
5034}
5035
5036__LJMP static int hlua_txn_log_alert(lua_State *L)
5037{
5038 const char *msg;
5039 struct hlua_txn *htxn;
5040
5041 MAY_LJMP(check_args(L, 2, "Alert"));
5042 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5043 msg = MAY_LJMP(luaL_checkstring(L, 2));
5044 hlua_sendlog(htxn->s->be, LOG_ALERT, msg);
5045 return 0;
5046}
5047
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005048__LJMP static int hlua_txn_set_loglevel(lua_State *L)
5049{
5050 struct hlua_txn *htxn;
5051 int ll;
5052
5053 MAY_LJMP(check_args(L, 2, "set_loglevel"));
5054 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5055 ll = MAY_LJMP(luaL_checkinteger(L, 2));
5056
5057 if (ll < 0 || ll > 7)
5058 WILL_LJMP(luaL_argerror(L, 2, "Bad log level. It must be between 0 and 7"));
5059
5060 htxn->s->logs.level = ll;
5061 return 0;
5062}
5063
5064__LJMP static int hlua_txn_set_tos(lua_State *L)
5065{
5066 struct hlua_txn *htxn;
5067 struct connection *cli_conn;
5068 int tos;
5069
5070 MAY_LJMP(check_args(L, 2, "set_tos"));
5071 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5072 tos = MAY_LJMP(luaL_checkinteger(L, 2));
5073
Willy Tarreau9ad7bd42015-04-03 19:19:59 +02005074 if ((cli_conn = objt_conn(htxn->s->sess->origin)) && conn_ctrl_ready(cli_conn))
Vincent Bernat6e615892016-05-18 16:17:44 +02005075 inet_set_tos(cli_conn->t.sock.fd, &cli_conn->addr.from, tos);
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005076
5077 return 0;
5078}
5079
5080__LJMP static int hlua_txn_set_mark(lua_State *L)
5081{
5082#ifdef SO_MARK
5083 struct hlua_txn *htxn;
5084 struct connection *cli_conn;
5085 int mark;
5086
5087 MAY_LJMP(check_args(L, 2, "set_mark"));
5088 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5089 mark = MAY_LJMP(luaL_checkinteger(L, 2));
5090
Willy Tarreau9ad7bd42015-04-03 19:19:59 +02005091 if ((cli_conn = objt_conn(htxn->s->sess->origin)) && conn_ctrl_ready(cli_conn))
Willy Tarreau07081fe2015-04-06 10:59:20 +02005092 setsockopt(cli_conn->t.sock.fd, SOL_SOCKET, SO_MARK, &mark, sizeof(mark));
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005093#endif
5094 return 0;
5095}
5096
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005097/* This function is an Lua binding that send pending data
5098 * to the client, and close the stream interface.
5099 */
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02005100__LJMP static int hlua_txn_done(lua_State *L)
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005101{
Willy Tarreaub2ccb562015-04-06 11:11:15 +02005102 struct hlua_txn *htxn;
Thierry FOURNIER9bd52d42016-07-14 11:45:33 +02005103 struct hlua *hlua;
Willy Tarreau81389672015-03-10 12:03:52 +01005104 struct channel *ic, *oc;
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005105
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005106 MAY_LJMP(check_args(L, 1, "close"));
Willy Tarreaub2ccb562015-04-06 11:11:15 +02005107 htxn = MAY_LJMP(hlua_checktxn(L, 1));
Thierry FOURNIER9bd52d42016-07-14 11:45:33 +02005108 hlua = hlua_gethlua(L);
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005109
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005110 /* If the flags NOTERM is set, we cannot terminate the http
5111 * session, so we just end the execution of the current
5112 * lua code.
5113 */
5114 if (htxn->flags & HLUA_TXN_NOTERM) {
5115 WILL_LJMP(hlua_done(L));
5116 return 0;
5117 }
5118
Willy Tarreaub2ccb562015-04-06 11:11:15 +02005119 ic = &htxn->s->req;
5120 oc = &htxn->s->res;
Willy Tarreau81389672015-03-10 12:03:52 +01005121
Willy Tarreau630ef452015-08-28 10:06:15 +02005122 if (htxn->s->txn) {
5123 /* HTTP mode, let's stay in sync with the stream */
5124 bi_fast_delete(ic->buf, htxn->s->txn->req.sov);
5125 htxn->s->txn->req.next -= htxn->s->txn->req.sov;
5126 htxn->s->txn->req.sov = 0;
5127 ic->analysers &= AN_REQ_HTTP_XFER_BODY;
5128 oc->analysers = AN_RES_HTTP_XFER_BODY;
5129 htxn->s->txn->req.msg_state = HTTP_MSG_CLOSED;
5130 htxn->s->txn->rsp.msg_state = HTTP_MSG_DONE;
5131
Willy Tarreau630ef452015-08-28 10:06:15 +02005132 /* Note that if we want to support keep-alive, we need
5133 * to bypass the close/shutr_now calls below, but that
5134 * may only be done if the HTTP request was already
5135 * processed and the connection header is known (ie
5136 * not during TCP rules).
5137 */
5138 }
5139
Thierry FOURNIER10ec2142015-08-24 17:23:45 +02005140 channel_auto_read(ic);
Willy Tarreau81389672015-03-10 12:03:52 +01005141 channel_abort(ic);
5142 channel_auto_close(ic);
5143 channel_erase(ic);
Thierry FOURNIER10ec2142015-08-24 17:23:45 +02005144
5145 oc->wex = tick_add_ifset(now_ms, oc->wto);
Willy Tarreau81389672015-03-10 12:03:52 +01005146 channel_auto_read(oc);
5147 channel_auto_close(oc);
5148 channel_shutr_now(oc);
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005149
Willy Tarreau0458b082015-08-28 09:40:04 +02005150 ic->analysers = 0;
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02005151
Thierry FOURNIER9bd52d42016-07-14 11:45:33 +02005152 hlua->flags |= HLUA_STOP;
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02005153 WILL_LJMP(hlua_done(L));
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01005154 return 0;
5155}
5156
5157__LJMP static int hlua_log(lua_State *L)
5158{
5159 int level;
5160 const char *msg;
5161
5162 MAY_LJMP(check_args(L, 2, "log"));
5163 level = MAY_LJMP(luaL_checkinteger(L, 1));
5164 msg = MAY_LJMP(luaL_checkstring(L, 2));
5165
5166 if (level < 0 || level >= NB_LOG_LEVELS)
5167 WILL_LJMP(luaL_argerror(L, 1, "Invalid loglevel."));
5168
5169 hlua_sendlog(NULL, level, msg);
5170 return 0;
5171}
5172
5173__LJMP static int hlua_log_debug(lua_State *L)
5174{
5175 const char *msg;
5176
5177 MAY_LJMP(check_args(L, 1, "debug"));
5178 msg = MAY_LJMP(luaL_checkstring(L, 1));
5179 hlua_sendlog(NULL, LOG_DEBUG, msg);
5180 return 0;
5181}
5182
5183__LJMP static int hlua_log_info(lua_State *L)
5184{
5185 const char *msg;
5186
5187 MAY_LJMP(check_args(L, 1, "info"));
5188 msg = MAY_LJMP(luaL_checkstring(L, 1));
5189 hlua_sendlog(NULL, LOG_INFO, msg);
5190 return 0;
5191}
5192
5193__LJMP static int hlua_log_warning(lua_State *L)
5194{
5195 const char *msg;
5196
5197 MAY_LJMP(check_args(L, 1, "warning"));
5198 msg = MAY_LJMP(luaL_checkstring(L, 1));
5199 hlua_sendlog(NULL, LOG_WARNING, msg);
5200 return 0;
5201}
5202
5203__LJMP static int hlua_log_alert(lua_State *L)
5204{
5205 const char *msg;
5206
5207 MAY_LJMP(check_args(L, 1, "alert"));
5208 msg = MAY_LJMP(luaL_checkstring(L, 1));
5209 hlua_sendlog(NULL, LOG_ALERT, msg);
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005210 return 0;
5211}
5212
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01005213__LJMP static int hlua_sleep_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01005214{
5215 int wakeup_ms = lua_tointeger(L, -1);
5216 if (now_ms < wakeup_ms)
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01005217 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01005218 return 0;
5219}
5220
5221__LJMP static int hlua_sleep(lua_State *L)
5222{
5223 unsigned int delay;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01005224 unsigned int wakeup_ms;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01005225
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01005226 MAY_LJMP(check_args(L, 1, "sleep"));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01005227
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01005228 delay = MAY_LJMP(luaL_checkinteger(L, 1)) * 1000;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01005229 wakeup_ms = tick_add(now_ms, delay);
5230 lua_pushinteger(L, wakeup_ms);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01005231
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01005232 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
5233 return 0;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01005234}
5235
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01005236__LJMP static int hlua_msleep(lua_State *L)
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01005237{
5238 unsigned int delay;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01005239 unsigned int wakeup_ms;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01005240
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01005241 MAY_LJMP(check_args(L, 1, "msleep"));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01005242
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01005243 delay = MAY_LJMP(luaL_checkinteger(L, 1));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01005244 wakeup_ms = tick_add(now_ms, delay);
5245 lua_pushinteger(L, wakeup_ms);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01005246
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01005247 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
5248 return 0;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01005249}
5250
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01005251/* This functionis an LUA binding. it permits to give back
5252 * the hand at the HAProxy scheduler. It is used when the
5253 * LUA processing consumes a lot of time.
5254 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01005255__LJMP static int hlua_yield_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01005256{
5257 return 0;
5258}
5259
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01005260__LJMP static int hlua_yield(lua_State *L)
5261{
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01005262 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_yield_yield, TICK_ETERNITY, HLUA_CTRLYIELD));
5263 return 0;
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01005264}
5265
Thierry FOURNIER37196f42015-02-16 19:34:56 +01005266/* This function change the nice of the currently executed
5267 * task. It is used set low or high priority at the current
5268 * task.
5269 */
Willy Tarreau59551662015-03-10 14:23:13 +01005270__LJMP static int hlua_set_nice(lua_State *L)
Thierry FOURNIER37196f42015-02-16 19:34:56 +01005271{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005272 struct hlua *hlua;
5273 int nice;
Thierry FOURNIER37196f42015-02-16 19:34:56 +01005274
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005275 MAY_LJMP(check_args(L, 1, "set_nice"));
5276 hlua = hlua_gethlua(L);
5277 nice = MAY_LJMP(luaL_checkinteger(L, 1));
Thierry FOURNIER37196f42015-02-16 19:34:56 +01005278
5279 /* If he task is not set, I'm in a start mode. */
5280 if (!hlua || !hlua->task)
5281 return 0;
5282
5283 if (nice < -1024)
5284 nice = -1024;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005285 else if (nice > 1024)
Thierry FOURNIER37196f42015-02-16 19:34:56 +01005286 nice = 1024;
5287
5288 hlua->task->nice = nice;
5289 return 0;
5290}
5291
Thierry FOURNIER24f33532015-01-23 12:13:00 +01005292/* This function is used as a calback of a task. It is called by the
5293 * HAProxy task subsystem when the task is awaked. The LUA runtime can
5294 * return an E_AGAIN signal, the emmiter of this signal must set a
5295 * signal to wake the task.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005296 *
5297 * Task wrapper are longjmp safe because the only one Lua code
5298 * executed is the safe hlua_ctx_resume();
Thierry FOURNIER24f33532015-01-23 12:13:00 +01005299 */
5300static struct task *hlua_process_task(struct task *task)
5301{
5302 struct hlua *hlua = task->context;
5303 enum hlua_exec status;
5304
5305 /* We need to remove the task from the wait queue before executing
5306 * the Lua code because we don't know if it needs to wait for
5307 * another timer or not in the case of E_AGAIN.
5308 */
5309 task_delete(task);
5310
Thierry FOURNIERbd413492015-03-03 16:52:26 +01005311 /* If it is the first call to the task, we must initialize the
5312 * execution timeouts.
5313 */
5314 if (!HLUA_IS_RUNNING(hlua))
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02005315 hlua->max_time = hlua_timeout_task;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01005316
Thierry FOURNIER24f33532015-01-23 12:13:00 +01005317 /* Execute the Lua code. */
5318 status = hlua_ctx_resume(hlua, 1);
5319
5320 switch (status) {
5321 /* finished or yield */
5322 case HLUA_E_OK:
5323 hlua_ctx_destroy(hlua);
5324 task_delete(task);
5325 task_free(task);
5326 break;
5327
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01005328 case HLUA_E_AGAIN: /* co process or timeout wake me later. */
5329 if (hlua->wake_time != TICK_ETERNITY)
5330 task_schedule(task, hlua->wake_time);
Thierry FOURNIER24f33532015-01-23 12:13:00 +01005331 break;
5332
5333 /* finished with error. */
5334 case HLUA_E_ERRMSG:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005335 SEND_ERR(NULL, "Lua task: %s.\n", lua_tostring(hlua->T, -1));
Thierry FOURNIER24f33532015-01-23 12:13:00 +01005336 hlua_ctx_destroy(hlua);
5337 task_delete(task);
5338 task_free(task);
5339 break;
5340
5341 case HLUA_E_ERR:
5342 default:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005343 SEND_ERR(NULL, "Lua task: unknown error.\n");
Thierry FOURNIER24f33532015-01-23 12:13:00 +01005344 hlua_ctx_destroy(hlua);
5345 task_delete(task);
5346 task_free(task);
5347 break;
5348 }
5349 return NULL;
5350}
5351
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01005352/* This function is an LUA binding that register LUA function to be
5353 * executed after the HAProxy configuration parsing and before the
5354 * HAProxy scheduler starts. This function expect only one LUA
5355 * argument that is a function. This function returns nothing, but
5356 * throws if an error is encountered.
5357 */
5358__LJMP static int hlua_register_init(lua_State *L)
5359{
5360 struct hlua_init_function *init;
5361 int ref;
5362
5363 MAY_LJMP(check_args(L, 1, "register_init"));
5364
5365 ref = MAY_LJMP(hlua_checkfunction(L, 1));
5366
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02005367 init = calloc(1, sizeof(*init));
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01005368 if (!init)
5369 WILL_LJMP(luaL_error(L, "lua out of memory error."));
5370
5371 init->function_ref = ref;
5372 LIST_ADDQ(&hlua_init_functions, &init->l);
5373 return 0;
5374}
5375
Thierry FOURNIER24f33532015-01-23 12:13:00 +01005376/* This functio is an LUA binding. It permits to register a task
5377 * executed in parallel of the main HAroxy activity. The task is
5378 * created and it is set in the HAProxy scheduler. It can be called
5379 * from the "init" section, "post init" or during the runtime.
5380 *
5381 * Lua prototype:
5382 *
5383 * <none> core.register_task(<function>)
5384 */
5385static int hlua_register_task(lua_State *L)
5386{
5387 struct hlua *hlua;
5388 struct task *task;
5389 int ref;
5390
5391 MAY_LJMP(check_args(L, 1, "register_task"));
5392
5393 ref = MAY_LJMP(hlua_checkfunction(L, 1));
5394
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005395 hlua = pool_alloc2(pool2_hlua);
Thierry FOURNIER24f33532015-01-23 12:13:00 +01005396 if (!hlua)
5397 WILL_LJMP(luaL_error(L, "lua out of memory error."));
5398
5399 task = task_new();
5400 task->context = hlua;
5401 task->process = hlua_process_task;
5402
5403 if (!hlua_ctx_init(hlua, task))
5404 WILL_LJMP(luaL_error(L, "lua out of memory error."));
5405
5406 /* Restore the function in the stack. */
5407 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ref);
5408 hlua->nargs = 0;
5409
5410 /* Schedule task. */
5411 task_schedule(task, now_ms);
5412
5413 return 0;
5414}
5415
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005416/* Wrapper called by HAProxy to execute an LUA converter. This wrapper
5417 * doesn't allow "yield" functions because the HAProxy engine cannot
5418 * resume converters.
5419 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005420static int hlua_sample_conv_wrapper(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005421{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02005422 struct hlua_function *fcn = private;
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005423 struct stream *stream = smp->strm;
Thierry Fournierfd107a22016-02-19 19:57:23 +01005424 const char *error;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005425
Willy Tarreaube508f12016-03-10 11:47:01 +01005426 if (!stream)
5427 return 0;
5428
Willy Tarreau87b09662015-04-03 00:22:06 +02005429 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01005430 * Lua context can be not initialized. This behavior
5431 * permits to save performances because a systematic
5432 * Lua initialization cause 5% performances loss.
5433 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005434 if (!stream->hlua) {
5435 stream->hlua = pool_alloc2(pool2_hlua);
5436 if (!stream->hlua) {
5437 SEND_ERR(stream->be, "Lua converter '%s': can't initialize Lua context.\n", fcn->name);
5438 return 0;
5439 }
5440 if (!hlua_ctx_init(stream->hlua, stream->task)) {
5441 SEND_ERR(stream->be, "Lua converter '%s': can't initialize Lua context.\n", fcn->name);
5442 return 0;
5443 }
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01005444 }
5445
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005446 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005447 if (!HLUA_IS_RUNNING(stream->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005448
5449 /* The following Lua calls can fail. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005450 if (!SET_SAFE_LJMP(stream->hlua->T)) {
5451 if (lua_type(stream->hlua->T, -1) == LUA_TSTRING)
5452 error = lua_tostring(stream->hlua->T, -1);
Thierry Fournierfd107a22016-02-19 19:57:23 +01005453 else
5454 error = "critical error";
5455 SEND_ERR(stream->be, "Lua converter '%s': %s.\n", fcn->name, error);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005456 return 0;
5457 }
5458
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005459 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005460 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005461 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005462 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005463 return 0;
5464 }
5465
5466 /* Restore the function in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005467 lua_rawgeti(stream->hlua->T, LUA_REGISTRYINDEX, fcn->function_ref);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005468
5469 /* convert input sample and pust-it in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005470 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005471 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005472 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005473 return 0;
5474 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005475 hlua_smp2lua(stream->hlua->T, smp);
5476 stream->hlua->nargs = 1;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005477
5478 /* push keywords in the stack. */
5479 if (arg_p) {
5480 for (; arg_p->type != ARGT_STOP; arg_p++) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005481 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005482 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005483 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005484 return 0;
5485 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005486 hlua_arg2lua(stream->hlua->T, arg_p);
5487 stream->hlua->nargs++;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005488 }
5489 }
5490
Thierry FOURNIERbd413492015-03-03 16:52:26 +01005491 /* We must initialize the execution timeouts. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005492 stream->hlua->max_time = hlua_timeout_session;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01005493
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005494 /* At this point the execution is safe. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005495 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005496 }
5497
5498 /* Execute the function. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005499 switch (hlua_ctx_resume(stream->hlua, 0)) {
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005500 /* finished. */
5501 case HLUA_E_OK:
5502 /* Convert the returned value in sample. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005503 hlua_lua2smp(stream->hlua->T, -1, smp);
5504 lua_pop(stream->hlua->T, 1);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005505 return 1;
5506
5507 /* yield. */
5508 case HLUA_E_AGAIN:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005509 SEND_ERR(stream->be, "Lua converter '%s': cannot use yielded functions.\n", fcn->name);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005510 return 0;
5511
5512 /* finished with error. */
5513 case HLUA_E_ERRMSG:
5514 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005515 SEND_ERR(stream->be, "Lua converter '%s': %s.\n",
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005516 fcn->name, lua_tostring(stream->hlua->T, -1));
5517 lua_pop(stream->hlua->T, 1);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005518 return 0;
5519
5520 case HLUA_E_ERR:
5521 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005522 SEND_ERR(stream->be, "Lua converter '%s' returns an unknown error.\n", fcn->name);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005523
5524 default:
5525 return 0;
5526 }
5527}
5528
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005529/* Wrapper called by HAProxy to execute a sample-fetch. this wrapper
5530 * doesn't allow "yield" functions because the HAProxy engine cannot
Willy Tarreaube508f12016-03-10 11:47:01 +01005531 * resume sample-fetches. This function will be called by the sample
5532 * fetch engine to call lua-based fetch operations.
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005533 */
Thierry FOURNIER0786d052015-05-11 15:42:45 +02005534static int hlua_sample_fetch_wrapper(const struct arg *arg_p, struct sample *smp,
5535 const char *kw, void *private)
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005536{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02005537 struct hlua_function *fcn = private;
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02005538 struct stream *stream = smp->strm;
Thierry Fournierfd107a22016-02-19 19:57:23 +01005539 const char *error;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01005540 const struct chunk msg = { .len = 0 };
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005541
Willy Tarreaube508f12016-03-10 11:47:01 +01005542 if (!stream)
5543 return 0;
5544
Willy Tarreau87b09662015-04-03 00:22:06 +02005545 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01005546 * Lua context can be not initialized. This behavior
5547 * permits to save performances because a systematic
5548 * Lua initialization cause 5% performances loss.
5549 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005550 if (!stream->hlua) {
5551 stream->hlua = pool_alloc2(pool2_hlua);
5552 if (!stream->hlua) {
5553 SEND_ERR(stream->be, "Lua sample-fetch '%s': can't initialize Lua context.\n", fcn->name);
5554 return 0;
5555 }
5556 if (!hlua_ctx_init(stream->hlua, stream->task)) {
5557 SEND_ERR(stream->be, "Lua sample-fetch '%s': can't initialize Lua context.\n", fcn->name);
5558 return 0;
5559 }
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01005560 }
5561
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005562 consistency_set(stream, smp->opt, &stream->hlua->cons);
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01005563
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005564 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005565 if (!HLUA_IS_RUNNING(stream->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005566
5567 /* The following Lua calls can fail. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005568 if (!SET_SAFE_LJMP(stream->hlua->T)) {
5569 if (lua_type(stream->hlua->T, -1) == LUA_TSTRING)
5570 error = lua_tostring(stream->hlua->T, -1);
Thierry Fournierfd107a22016-02-19 19:57:23 +01005571 else
5572 error = "critical error";
5573 SEND_ERR(smp->px, "Lua sample-fetch '%s': %s.\n", fcn->name, error);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005574 return 0;
5575 }
5576
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005577 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005578 if (!lua_checkstack(stream->hlua->T, 2)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005579 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005580 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005581 return 0;
5582 }
5583
5584 /* Restore the function in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005585 lua_rawgeti(stream->hlua->T, LUA_REGISTRYINDEX, fcn->function_ref);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005586
5587 /* push arguments in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005588 if (!hlua_txn_new(stream->hlua->T, stream, smp->px, smp->opt & SMP_OPT_DIR,
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005589 HLUA_TXN_NOTERM)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005590 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005591 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005592 return 0;
5593 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005594 stream->hlua->nargs = 1;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005595
5596 /* push keywords in the stack. */
5597 for (; arg_p && arg_p->type != ARGT_STOP; arg_p++) {
5598 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005599 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005600 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005601 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005602 return 0;
5603 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005604 hlua_arg2lua(stream->hlua->T, arg_p);
5605 stream->hlua->nargs++;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005606 }
5607
Thierry FOURNIERbd413492015-03-03 16:52:26 +01005608 /* We must initialize the execution timeouts. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005609 stream->hlua->max_time = hlua_timeout_session;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01005610
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005611 /* At this point the execution is safe. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005612 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005613 }
5614
5615 /* Execute the function. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005616 switch (hlua_ctx_resume(stream->hlua, 0)) {
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005617 /* finished. */
5618 case HLUA_E_OK:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005619 if (!consistency_check(stream, smp->opt, &stream->hlua->cons)) {
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01005620 stream_int_retnclose(&stream->si[0], &msg);
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02005621 return 0;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01005622 }
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005623 /* Convert the returned value in sample. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005624 hlua_lua2smp(stream->hlua->T, -1, smp);
5625 lua_pop(stream->hlua->T, 1);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005626
5627 /* Set the end of execution flag. */
5628 smp->flags &= ~SMP_F_MAY_CHANGE;
5629 return 1;
5630
5631 /* yield. */
5632 case HLUA_E_AGAIN:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005633 if (!consistency_check(stream, smp->opt, &stream->hlua->cons))
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01005634 stream_int_retnclose(&stream->si[0], &msg);
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005635 SEND_ERR(smp->px, "Lua sample-fetch '%s': cannot use yielded functions.\n", fcn->name);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005636 return 0;
5637
5638 /* finished with error. */
5639 case HLUA_E_ERRMSG:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005640 if (!consistency_check(stream, smp->opt, &stream->hlua->cons))
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01005641 stream_int_retnclose(&stream->si[0], &msg);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005642 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005643 SEND_ERR(smp->px, "Lua sample-fetch '%s': %s.\n",
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005644 fcn->name, lua_tostring(stream->hlua->T, -1));
5645 lua_pop(stream->hlua->T, 1);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005646 return 0;
5647
5648 case HLUA_E_ERR:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005649 if (!consistency_check(stream, smp->opt, &stream->hlua->cons))
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01005650 stream_int_retnclose(&stream->si[0], &msg);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005651 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005652 SEND_ERR(smp->px, "Lua sample-fetch '%s' returns an unknown error.\n", fcn->name);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005653
5654 default:
5655 return 0;
5656 }
5657}
5658
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005659/* This function is an LUA binding used for registering
5660 * "sample-conv" functions. It expects a converter name used
5661 * in the haproxy configuration file, and an LUA function.
5662 */
5663__LJMP static int hlua_register_converters(lua_State *L)
5664{
5665 struct sample_conv_kw_list *sck;
5666 const char *name;
5667 int ref;
5668 int len;
5669 struct hlua_function *fcn;
5670
5671 MAY_LJMP(check_args(L, 2, "register_converters"));
5672
5673 /* First argument : converter name. */
5674 name = MAY_LJMP(luaL_checkstring(L, 1));
5675
5676 /* Second argument : lua function. */
5677 ref = MAY_LJMP(hlua_checkfunction(L, 2));
5678
5679 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02005680 sck = calloc(1, sizeof(*sck) + sizeof(struct sample_conv) * 2);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005681 if (!sck)
5682 WILL_LJMP(luaL_error(L, "lua out of memory error."));
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02005683 fcn = calloc(1, sizeof(*fcn));
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005684 if (!fcn)
5685 WILL_LJMP(luaL_error(L, "lua out of memory error."));
5686
5687 /* Fill fcn. */
5688 fcn->name = strdup(name);
5689 if (!fcn->name)
5690 WILL_LJMP(luaL_error(L, "lua out of memory error."));
5691 fcn->function_ref = ref;
5692
5693 /* List head */
5694 sck->list.n = sck->list.p = NULL;
5695
5696 /* converter keyword. */
5697 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02005698 sck->kw[0].kw = calloc(1, len);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005699 if (!sck->kw[0].kw)
5700 WILL_LJMP(luaL_error(L, "lua out of memory error."));
5701
5702 snprintf((char *)sck->kw[0].kw, len, "lua.%s", name);
5703 sck->kw[0].process = hlua_sample_conv_wrapper;
David Carlier0c437f42016-04-27 16:21:56 +01005704 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 +01005705 sck->kw[0].val_args = NULL;
5706 sck->kw[0].in_type = SMP_T_STR;
5707 sck->kw[0].out_type = SMP_T_STR;
5708 sck->kw[0].private = fcn;
5709
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01005710 /* Register this new converter */
5711 sample_register_convs(sck);
5712
5713 return 0;
5714}
5715
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005716/* This fucntion is an LUA binding used for registering
5717 * "sample-fetch" functions. It expects a converter name used
5718 * in the haproxy configuration file, and an LUA function.
5719 */
5720__LJMP static int hlua_register_fetches(lua_State *L)
5721{
5722 const char *name;
5723 int ref;
5724 int len;
5725 struct sample_fetch_kw_list *sfk;
5726 struct hlua_function *fcn;
5727
5728 MAY_LJMP(check_args(L, 2, "register_fetches"));
5729
5730 /* First argument : sample-fetch name. */
5731 name = MAY_LJMP(luaL_checkstring(L, 1));
5732
5733 /* Second argument : lua function. */
5734 ref = MAY_LJMP(hlua_checkfunction(L, 2));
5735
5736 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02005737 sfk = calloc(1, sizeof(*sfk) + sizeof(struct sample_fetch) * 2);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005738 if (!sfk)
5739 WILL_LJMP(luaL_error(L, "lua out of memory error."));
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02005740 fcn = calloc(1, sizeof(*fcn));
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005741 if (!fcn)
5742 WILL_LJMP(luaL_error(L, "lua out of memory error."));
5743
5744 /* Fill fcn. */
5745 fcn->name = strdup(name);
5746 if (!fcn->name)
5747 WILL_LJMP(luaL_error(L, "lua out of memory error."));
5748 fcn->function_ref = ref;
5749
5750 /* List head */
5751 sfk->list.n = sfk->list.p = NULL;
5752
5753 /* sample-fetch keyword. */
5754 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02005755 sfk->kw[0].kw = calloc(1, len);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005756 if (!sfk->kw[0].kw)
5757 return luaL_error(L, "lua out of memory error.");
5758
5759 snprintf((char *)sfk->kw[0].kw, len, "lua.%s", name);
5760 sfk->kw[0].process = hlua_sample_fetch_wrapper;
David Carlier0c437f42016-04-27 16:21:56 +01005761 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 +01005762 sfk->kw[0].val_args = NULL;
5763 sfk->kw[0].out_type = SMP_T_STR;
5764 sfk->kw[0].use = SMP_USE_HTTP_ANY;
5765 sfk->kw[0].val = 0;
5766 sfk->kw[0].private = fcn;
5767
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01005768 /* Register this new fetch. */
5769 sample_register_fetches(sfk);
5770
5771 return 0;
5772}
5773
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005774/* This function is a wrapper to execute each LUA function declared
5775 * as an action wrapper during the initialisation period. This function
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005776 * return ACT_RET_CONT if the processing is finished (with or without
5777 * error) and return ACT_RET_YIELD if the function must be called again
5778 * because the LUA returns a yield.
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005779 */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005780static enum act_return hlua_action(struct act_rule *rule, struct proxy *px,
Willy Tarreau658b85b2015-09-27 10:00:49 +02005781 struct session *sess, struct stream *s, int flags)
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005782{
5783 char **arg;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005784 unsigned int analyzer;
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02005785 int dir;
Thierry Fournierfd107a22016-02-19 19:57:23 +01005786 const char *error;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01005787 const struct chunk msg = { .len = 0 };
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005788
5789 switch (rule->from) {
Thierry FOURNIER6e01f382015-11-02 09:52:54 +01005790 case ACT_F_TCP_REQ_CNT: analyzer = AN_REQ_INSPECT_FE ; dir = SMP_OPT_DIR_REQ; break;
5791 case ACT_F_TCP_RES_CNT: analyzer = AN_RES_INSPECT ; dir = SMP_OPT_DIR_RES; break;
5792 case ACT_F_HTTP_REQ: analyzer = AN_REQ_HTTP_PROCESS_FE; dir = SMP_OPT_DIR_REQ; break;
5793 case ACT_F_HTTP_RES: analyzer = AN_RES_HTTP_PROCESS_BE; dir = SMP_OPT_DIR_RES; break;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005794 default:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005795 SEND_ERR(px, "Lua: internal error while execute action.\n");
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005796 return ACT_RET_CONT;
5797 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005798
Willy Tarreau87b09662015-04-03 00:22:06 +02005799 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01005800 * Lua context can be not initialized. This behavior
5801 * permits to save performances because a systematic
5802 * Lua initialization cause 5% performances loss.
5803 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005804 if (!s->hlua) {
5805 s->hlua = pool_alloc2(pool2_hlua);
5806 if (!s->hlua) {
5807 SEND_ERR(px, "Lua action '%s': can't initialize Lua context.\n",
5808 rule->arg.hlua_rule->fcn.name);
5809 return ACT_RET_CONT;
5810 }
5811 if (!hlua_ctx_init(s->hlua, s->task)) {
5812 SEND_ERR(px, "Lua action '%s': can't initialize Lua context.\n",
5813 rule->arg.hlua_rule->fcn.name);
5814 return ACT_RET_CONT;
5815 }
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01005816 }
5817
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005818 consistency_set(s, dir, &s->hlua->cons);
5819
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005820 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005821 if (!HLUA_IS_RUNNING(s->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005822
5823 /* The following Lua calls can fail. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005824 if (!SET_SAFE_LJMP(s->hlua->T)) {
5825 if (lua_type(s->hlua->T, -1) == LUA_TSTRING)
5826 error = lua_tostring(s->hlua->T, -1);
Thierry Fournierfd107a22016-02-19 19:57:23 +01005827 else
5828 error = "critical error";
5829 SEND_ERR(px, "Lua function '%s': %s.\n",
5830 rule->arg.hlua_rule->fcn.name, error);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005831 return ACT_RET_CONT;
5832 }
5833
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005834 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005835 if (!lua_checkstack(s->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005836 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005837 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005838 RESET_SAFE_LJMP(s->hlua->T);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02005839 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005840 }
5841
5842 /* Restore the function in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005843 lua_rawgeti(s->hlua->T, LUA_REGISTRYINDEX, rule->arg.hlua_rule->fcn.function_ref);
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005844
Willy Tarreau87b09662015-04-03 00:22:06 +02005845 /* Create and and push object stream in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005846 if (!hlua_txn_new(s->hlua->T, s, px, dir, 0)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005847 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005848 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005849 RESET_SAFE_LJMP(s->hlua->T);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02005850 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005851 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005852 s->hlua->nargs = 1;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005853
5854 /* push keywords in the stack. */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005855 for (arg = rule->arg.hlua_rule->args; arg && *arg; arg++) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005856 if (!lua_checkstack(s->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005857 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005858 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005859 RESET_SAFE_LJMP(s->hlua->T);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02005860 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005861 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005862 lua_pushstring(s->hlua->T, *arg);
5863 s->hlua->nargs++;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005864 }
5865
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005866 /* Now the execution is safe. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005867 RESET_SAFE_LJMP(s->hlua->T);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02005868
Thierry FOURNIERbd413492015-03-03 16:52:26 +01005869 /* We must initialize the execution timeouts. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005870 s->hlua->max_time = hlua_timeout_session;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005871 }
5872
5873 /* Execute the function. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005874 switch (hlua_ctx_resume(s->hlua, !(flags & ACT_FLAG_FINAL))) {
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005875 /* finished. */
5876 case HLUA_E_OK:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005877 if (!consistency_check(s, dir, &s->hlua->cons)) {
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01005878 stream_int_retnclose(&s->si[0], &msg);
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02005879 return ACT_RET_ERR;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01005880 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005881 if (s->hlua->flags & HLUA_STOP)
Thierry FOURNIER9bd52d42016-07-14 11:45:33 +02005882 return ACT_RET_STOP;
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02005883 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005884
5885 /* yield. */
5886 case HLUA_E_AGAIN:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01005887 /* Set timeout in the required channel. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005888 if (s->hlua->wake_time != TICK_ETERNITY) {
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01005889 if (analyzer & (AN_REQ_INSPECT_FE|AN_REQ_HTTP_PROCESS_FE))
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005890 s->req.analyse_exp = s->hlua->wake_time;
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01005891 else if (analyzer & (AN_RES_INSPECT|AN_RES_HTTP_PROCESS_BE))
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005892 s->res.analyse_exp = s->hlua->wake_time;
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01005893 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005894 /* Some actions can be wake up when a "write" event
5895 * is detected on a response channel. This is useful
5896 * only for actions targetted on the requests.
5897 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005898 if (HLUA_IS_WAKERESWR(s->hlua)) {
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01005899 s->res.flags |= CF_WAKE_WRITE;
Willy Tarreau76bd97f2015-03-10 17:16:10 +01005900 if ((analyzer & (AN_REQ_INSPECT_FE|AN_REQ_HTTP_PROCESS_FE)))
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01005901 s->res.analysers |= analyzer;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005902 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005903 if (HLUA_IS_WAKEREQWR(s->hlua))
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01005904 s->req.flags |= CF_WAKE_WRITE;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01005905 /* We can quit the fcuntion without consistency check
5906 * because HAProxy is not able to manipulate data, it
5907 * is only allowed to call me again. */
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02005908 return ACT_RET_YIELD;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005909
5910 /* finished with error. */
5911 case HLUA_E_ERRMSG:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005912 if (!consistency_check(s, dir, &s->hlua->cons)) {
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01005913 stream_int_retnclose(&s->si[0], &msg);
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02005914 return ACT_RET_ERR;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01005915 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005916 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005917 SEND_ERR(px, "Lua function '%s': %s.\n",
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005918 rule->arg.hlua_rule->fcn.name, lua_tostring(s->hlua->T, -1));
5919 lua_pop(s->hlua->T, 1);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02005920 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005921
5922 case HLUA_E_ERR:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01005923 if (!consistency_check(s, dir, &s->hlua->cons)) {
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01005924 stream_int_retnclose(&s->si[0], &msg);
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02005925 return ACT_RET_ERR;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01005926 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005927 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02005928 SEND_ERR(px, "Lua function '%s' return an unknown error.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02005929 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005930
5931 default:
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02005932 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01005933 }
5934}
5935
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02005936struct task *hlua_applet_wakeup(struct task *t)
5937{
5938 struct appctx *ctx = t->context;
5939 struct stream_interface *si = ctx->owner;
5940
5941 /* If the applet is wake up without any expected work, the sheduler
5942 * remove it from the run queue. This flag indicate that the applet
5943 * is waiting for write. If the buffer is full, the main processing
5944 * will send some data and after call the applet, otherwise it call
5945 * the applet ASAP.
5946 */
5947 si_applet_cant_put(si);
5948 appctx_wakeup(ctx);
5949 return NULL;
5950}
5951
5952static int hlua_applet_tcp_init(struct appctx *ctx, struct proxy *px, struct stream *strm)
5953{
5954 struct stream_interface *si = ctx->owner;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01005955 struct hlua *hlua;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02005956 struct task *task;
5957 char **arg;
Thierry Fournierfd107a22016-02-19 19:57:23 +01005958 const char *error;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02005959
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01005960 hlua = pool_alloc2(pool2_hlua);
5961 if (!hlua) {
5962 SEND_ERR(px, "Lua applet tcp '%s': out of memory.\n",
5963 ctx->rule->arg.hlua_rule->fcn.name);
5964 return 0;
5965 }
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02005966 HLUA_INIT(hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01005967 ctx->ctx.hlua_apptcp.hlua = hlua;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02005968 ctx->ctx.hlua_apptcp.flags = 0;
5969
5970 /* Create task used by signal to wakeup applets. */
5971 task = task_new();
5972 if (!task) {
5973 SEND_ERR(px, "Lua applet tcp '%s': out of memory.\n",
5974 ctx->rule->arg.hlua_rule->fcn.name);
5975 return 0;
5976 }
5977 task->nice = 0;
5978 task->context = ctx;
5979 task->process = hlua_applet_wakeup;
5980 ctx->ctx.hlua_apptcp.task = task;
5981
5982 /* In the execution wrappers linked with a stream, the
5983 * Lua context can be not initialized. This behavior
5984 * permits to save performances because a systematic
5985 * Lua initialization cause 5% performances loss.
5986 */
5987 if (!hlua_ctx_init(hlua, task)) {
5988 SEND_ERR(px, "Lua applet tcp '%s': can't initialize Lua context.\n",
5989 ctx->rule->arg.hlua_rule->fcn.name);
5990 return 0;
5991 }
5992
5993 /* Set timeout according with the applet configuration. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02005994 hlua->max_time = ctx->applet->timeout;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02005995
5996 /* The following Lua calls can fail. */
5997 if (!SET_SAFE_LJMP(hlua->T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01005998 if (lua_type(hlua->T, -1) == LUA_TSTRING)
5999 error = lua_tostring(hlua->T, -1);
6000 else
6001 error = "critical error";
6002 SEND_ERR(px, "Lua applet tcp '%s': %s.\n",
6003 ctx->rule->arg.hlua_rule->fcn.name, error);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006004 RESET_SAFE_LJMP(hlua->T);
6005 return 0;
6006 }
6007
6008 /* Check stack available size. */
6009 if (!lua_checkstack(hlua->T, 1)) {
6010 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
6011 ctx->rule->arg.hlua_rule->fcn.name);
6012 RESET_SAFE_LJMP(hlua->T);
6013 return 0;
6014 }
6015
6016 /* Restore the function in the stack. */
6017 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ctx->rule->arg.hlua_rule->fcn.function_ref);
6018
6019 /* Create and and push object stream in the stack. */
6020 if (!hlua_applet_tcp_new(hlua->T, ctx)) {
6021 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
6022 ctx->rule->arg.hlua_rule->fcn.name);
6023 RESET_SAFE_LJMP(hlua->T);
6024 return 0;
6025 }
6026 hlua->nargs = 1;
6027
6028 /* push keywords in the stack. */
6029 for (arg = ctx->rule->arg.hlua_rule->args; arg && *arg; arg++) {
6030 if (!lua_checkstack(hlua->T, 1)) {
6031 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
6032 ctx->rule->arg.hlua_rule->fcn.name);
6033 RESET_SAFE_LJMP(hlua->T);
6034 return 0;
6035 }
6036 lua_pushstring(hlua->T, *arg);
6037 hlua->nargs++;
6038 }
6039
6040 RESET_SAFE_LJMP(hlua->T);
6041
6042 /* Wakeup the applet ASAP. */
6043 si_applet_cant_get(si);
6044 si_applet_cant_put(si);
6045
6046 return 1;
6047}
6048
6049static void hlua_applet_tcp_fct(struct appctx *ctx)
6050{
6051 struct stream_interface *si = ctx->owner;
6052 struct stream *strm = si_strm(si);
6053 struct channel *res = si_ic(si);
6054 struct act_rule *rule = ctx->rule;
6055 struct proxy *px = strm->be;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006056 struct hlua *hlua = ctx->ctx.hlua_apptcp.hlua;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006057
6058 /* The applet execution is already done. */
6059 if (ctx->ctx.hlua_apptcp.flags & APPLET_DONE)
6060 return;
6061
6062 /* If the stream is disconnect or closed, ldo nothing. */
6063 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
6064 return;
6065
6066 /* Execute the function. */
6067 switch (hlua_ctx_resume(hlua, 1)) {
6068 /* finished. */
6069 case HLUA_E_OK:
6070 ctx->ctx.hlua_apptcp.flags |= APPLET_DONE;
6071
6072 /* log time */
6073 strm->logs.tv_request = now;
6074
6075 /* eat the whole request */
6076 bo_skip(si_oc(si), si_ob(si)->o);
6077 res->flags |= CF_READ_NULL;
6078 si_shutr(si);
6079 return;
6080
6081 /* yield. */
6082 case HLUA_E_AGAIN:
Thierry Fournier0164f202016-02-20 17:47:43 +01006083 if (hlua->wake_time != TICK_ETERNITY)
6084 task_schedule(ctx->ctx.hlua_apptcp.task, hlua->wake_time);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006085 return;
6086
6087 /* finished with error. */
6088 case HLUA_E_ERRMSG:
6089 /* Display log. */
6090 SEND_ERR(px, "Lua applet tcp '%s': %s.\n",
6091 rule->arg.hlua_rule->fcn.name, lua_tostring(hlua->T, -1));
6092 lua_pop(hlua->T, 1);
6093 goto error;
6094
6095 case HLUA_E_ERR:
6096 /* Display log. */
6097 SEND_ERR(px, "Lua applet tcp '%s' return an unknown error.\n",
6098 rule->arg.hlua_rule->fcn.name);
6099 goto error;
6100
6101 default:
6102 goto error;
6103 }
6104
6105error:
6106
6107 /* For all other cases, just close the stream. */
6108 si_shutw(si);
6109 si_shutr(si);
6110 ctx->ctx.hlua_apptcp.flags |= APPLET_DONE;
6111}
6112
6113static void hlua_applet_tcp_release(struct appctx *ctx)
6114{
6115 task_free(ctx->ctx.hlua_apptcp.task);
6116 ctx->ctx.hlua_apptcp.task = NULL;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006117 hlua_ctx_destroy(ctx->ctx.hlua_apptcp.hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006118 ctx->ctx.hlua_apptcp.hlua = NULL;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006119}
6120
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006121/* The function returns 1 if the initialisation is complete, 0 if
6122 * an errors occurs and -1 if more data are required for initializing
6123 * the applet.
6124 */
6125static int hlua_applet_http_init(struct appctx *ctx, struct proxy *px, struct stream *strm)
6126{
6127 struct stream_interface *si = ctx->owner;
6128 struct channel *req = si_oc(si);
6129 struct http_msg *msg;
6130 struct http_txn *txn;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006131 struct hlua *hlua;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006132 char **arg;
6133 struct hdr_ctx hdr;
6134 struct task *task;
6135 struct sample smp; /* just used for a valid call to smp_prefetch_http. */
Thierry Fournierfd107a22016-02-19 19:57:23 +01006136 const char *error;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006137
6138 /* Wait for a full HTTP request. */
6139 if (!smp_prefetch_http(px, strm, 0, NULL, &smp, 0)) {
6140 if (smp.flags & SMP_F_MAY_CHANGE)
6141 return -1;
6142 return 0;
6143 }
6144 txn = strm->txn;
6145 msg = &txn->req;
6146
Willy Tarreau0078bfc2015-10-07 20:20:28 +02006147 /* We want two things in HTTP mode :
6148 * - enforce server-close mode if we were in keep-alive, so that the
6149 * applet is released after each response ;
6150 * - enable request body transfer to the applet in order to resync
6151 * with the response body.
6152 */
6153 if ((txn->flags & TX_CON_WANT_MSK) == TX_CON_WANT_KAL)
6154 txn->flags = (txn->flags & ~TX_CON_WANT_MSK) | TX_CON_WANT_SCL;
Willy Tarreau0078bfc2015-10-07 20:20:28 +02006155
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006156 hlua = pool_alloc2(pool2_hlua);
6157 if (!hlua) {
6158 SEND_ERR(px, "Lua applet http '%s': out of memory.\n",
6159 ctx->rule->arg.hlua_rule->fcn.name);
6160 return 0;
6161 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006162 HLUA_INIT(hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006163 ctx->ctx.hlua_apphttp.hlua = hlua;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006164 ctx->ctx.hlua_apphttp.left_bytes = -1;
6165 ctx->ctx.hlua_apphttp.flags = 0;
6166
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +01006167 if (txn->req.flags & HTTP_MSGF_VER_11)
6168 ctx->ctx.hlua_apphttp.flags |= APPLET_HTTP11;
6169
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006170 /* Create task used by signal to wakeup applets. */
6171 task = task_new();
6172 if (!task) {
6173 SEND_ERR(px, "Lua applet http '%s': out of memory.\n",
6174 ctx->rule->arg.hlua_rule->fcn.name);
6175 return 0;
6176 }
6177 task->nice = 0;
6178 task->context = ctx;
6179 task->process = hlua_applet_wakeup;
6180 ctx->ctx.hlua_apphttp.task = task;
6181
6182 /* In the execution wrappers linked with a stream, the
6183 * Lua context can be not initialized. This behavior
6184 * permits to save performances because a systematic
6185 * Lua initialization cause 5% performances loss.
6186 */
6187 if (!hlua_ctx_init(hlua, task)) {
6188 SEND_ERR(px, "Lua applet http '%s': can't initialize Lua context.\n",
6189 ctx->rule->arg.hlua_rule->fcn.name);
6190 return 0;
6191 }
6192
6193 /* Set timeout according with the applet configuration. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02006194 hlua->max_time = ctx->applet->timeout;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006195
6196 /* The following Lua calls can fail. */
6197 if (!SET_SAFE_LJMP(hlua->T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01006198 if (lua_type(hlua->T, -1) == LUA_TSTRING)
6199 error = lua_tostring(hlua->T, -1);
6200 else
6201 error = "critical error";
6202 SEND_ERR(px, "Lua applet http '%s': %s.\n",
6203 ctx->rule->arg.hlua_rule->fcn.name, error);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006204 return 0;
6205 }
6206
6207 /* Check stack available size. */
6208 if (!lua_checkstack(hlua->T, 1)) {
6209 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
6210 ctx->rule->arg.hlua_rule->fcn.name);
6211 RESET_SAFE_LJMP(hlua->T);
6212 return 0;
6213 }
6214
6215 /* Restore the function in the stack. */
6216 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ctx->rule->arg.hlua_rule->fcn.function_ref);
6217
6218 /* Create and and push object stream in the stack. */
6219 if (!hlua_applet_http_new(hlua->T, ctx)) {
6220 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
6221 ctx->rule->arg.hlua_rule->fcn.name);
6222 RESET_SAFE_LJMP(hlua->T);
6223 return 0;
6224 }
6225 hlua->nargs = 1;
6226
6227 /* Look for a 100-continue expected. */
6228 if (msg->flags & HTTP_MSGF_VER_11) {
6229 hdr.idx = 0;
6230 if (http_find_header2("Expect", 6, req->buf->p, &txn->hdr_idx, &hdr) &&
6231 unlikely(hdr.vlen == 12 && strncasecmp(hdr.line+hdr.val, "100-continue", 12) == 0))
6232 ctx->ctx.hlua_apphttp.flags |= APPLET_100C;
6233 }
6234
6235 /* push keywords in the stack. */
6236 for (arg = ctx->rule->arg.hlua_rule->args; arg && *arg; arg++) {
6237 if (!lua_checkstack(hlua->T, 1)) {
6238 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
6239 ctx->rule->arg.hlua_rule->fcn.name);
6240 RESET_SAFE_LJMP(hlua->T);
6241 return 0;
6242 }
6243 lua_pushstring(hlua->T, *arg);
6244 hlua->nargs++;
6245 }
6246
6247 RESET_SAFE_LJMP(hlua->T);
6248
6249 /* Wakeup the applet when data is ready for read. */
6250 si_applet_cant_get(si);
6251
6252 return 1;
6253}
6254
6255static void hlua_applet_http_fct(struct appctx *ctx)
6256{
6257 struct stream_interface *si = ctx->owner;
6258 struct stream *strm = si_strm(si);
6259 struct channel *res = si_ic(si);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006260 struct act_rule *rule = ctx->rule;
6261 struct proxy *px = strm->be;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006262 struct hlua *hlua = ctx->ctx.hlua_apphttp.hlua;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006263 char *blk1;
6264 int len1;
6265 char *blk2;
6266 int len2;
6267 int ret;
6268
6269 /* If the stream is disconnect or closed, ldo nothing. */
6270 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
6271 return;
6272
6273 /* Set the currently running flag. */
6274 if (!HLUA_IS_RUNNING(hlua) &&
6275 !(ctx->ctx.hlua_apphttp.flags & APPLET_DONE)) {
6276
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006277 /* Wait for full HTTP analysys. */
6278 if (unlikely(strm->txn->req.msg_state < HTTP_MSG_BODY)) {
6279 si_applet_cant_get(si);
6280 return;
6281 }
6282
6283 /* Store the max amount of bytes that we can read. */
6284 ctx->ctx.hlua_apphttp.left_bytes = strm->txn->req.body_len;
6285
6286 /* We need to flush the request header. This left the body
6287 * for the Lua.
6288 */
6289
6290 /* Read the maximum amount of data avalaible. */
6291 ret = bo_getblk_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
6292 if (ret == -1)
6293 return;
6294
6295 /* No data available, ask for more data. */
6296 if (ret == 1)
6297 len2 = 0;
6298 if (ret == 0)
6299 len1 = 0;
6300 if (len1 + len2 < strm->txn->req.eoh + 2) {
6301 si_applet_cant_get(si);
6302 return;
6303 }
6304
6305 /* skip the requests bytes. */
6306 bo_skip(si_oc(si), strm->txn->req.eoh + 2);
6307 }
6308
6309 /* Executes The applet if it is not done. */
6310 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_DONE)) {
6311
6312 /* Execute the function. */
6313 switch (hlua_ctx_resume(hlua, 1)) {
6314 /* finished. */
6315 case HLUA_E_OK:
6316 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
6317 break;
6318
6319 /* yield. */
6320 case HLUA_E_AGAIN:
Thierry Fournier0164f202016-02-20 17:47:43 +01006321 if (hlua->wake_time != TICK_ETERNITY)
6322 task_schedule(ctx->ctx.hlua_apphttp.task, hlua->wake_time);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006323 return;
6324
6325 /* finished with error. */
6326 case HLUA_E_ERRMSG:
6327 /* Display log. */
6328 SEND_ERR(px, "Lua applet http '%s': %s.\n",
6329 rule->arg.hlua_rule->fcn.name, lua_tostring(hlua->T, -1));
6330 lua_pop(hlua->T, 1);
6331 goto error;
6332
6333 case HLUA_E_ERR:
6334 /* Display log. */
6335 SEND_ERR(px, "Lua applet http '%s' return an unknown error.\n",
6336 rule->arg.hlua_rule->fcn.name);
6337 goto error;
6338
6339 default:
6340 goto error;
6341 }
6342 }
6343
6344 if (ctx->ctx.hlua_apphttp.flags & APPLET_DONE) {
6345
6346 /* We must send the final chunk. */
6347 if (ctx->ctx.hlua_apphttp.flags & APPLET_CHUNKED &&
6348 !(ctx->ctx.hlua_apphttp.flags & APPLET_LAST_CHK)) {
6349
6350 /* sent last chunk at once. */
6351 ret = bi_putblk(res, "0\r\n\r\n", 5);
6352
6353 /* critical error. */
6354 if (ret == -2 || ret == -3) {
6355 SEND_ERR(px, "Lua applet http '%s'cannont send last chunk.\n",
6356 rule->arg.hlua_rule->fcn.name);
6357 goto error;
6358 }
6359
6360 /* no enough space error. */
6361 if (ret == -1) {
6362 si_applet_cant_put(si);
6363 return;
6364 }
6365
6366 /* set the last chunk sent. */
6367 ctx->ctx.hlua_apphttp.flags |= APPLET_LAST_CHK;
6368 }
6369
6370 /* close the connection. */
6371
6372 /* status / log */
6373 strm->txn->status = ctx->ctx.hlua_apphttp.status;
6374 strm->logs.tv_request = now;
6375
6376 /* eat the whole request */
6377 bo_skip(si_oc(si), si_ob(si)->o);
6378 res->flags |= CF_READ_NULL;
6379 si_shutr(si);
6380
6381 return;
6382 }
6383
6384error:
6385
6386 /* If we are in HTTP mode, and we are not send any
6387 * data, return a 500 server error in best effort:
6388 * if there are no room avalaible in the buffer,
6389 * just close the connection.
6390 */
6391 bi_putblk(res, error_500, strlen(error_500));
6392 if (!(strm->flags & SF_ERR_MASK))
6393 strm->flags |= SF_ERR_RESOURCE;
6394 si_shutw(si);
6395 si_shutr(si);
6396 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
6397}
6398
6399static void hlua_applet_http_release(struct appctx *ctx)
6400{
6401 task_free(ctx->ctx.hlua_apphttp.task);
6402 ctx->ctx.hlua_apphttp.task = NULL;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006403 hlua_ctx_destroy(ctx->ctx.hlua_apphttp.hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006404 ctx->ctx.hlua_apphttp.hlua = NULL;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006405}
6406
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006407/* global {tcp|http}-request parser. Return ACT_RET_PRS_OK in
6408 * succes case, else return ACT_RET_PRS_ERR.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006409 *
6410 * This function can fail with an abort() due to an Lua critical error.
6411 * We are in the configuration parsing process of HAProxy, this abort() is
6412 * tolerated.
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006413 */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006414static enum act_parse_ret action_register_lua(const char **args, int *cur_arg, struct proxy *px,
6415 struct act_rule *rule, char **err)
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006416{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02006417 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01006418 int i;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006419
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006420 /* Memory for the rule. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006421 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006422 if (!rule->arg.hlua_rule) {
6423 memprintf(err, "out of memory error");
Thierry FOURNIERafa80492015-08-19 09:04:15 +02006424 return ACT_RET_PRS_ERR;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006425 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006426
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01006427 /* Memory for arguments. */
6428 rule->arg.hlua_rule->args = calloc(fcn->nargs + 1, sizeof(char *));
6429 if (!rule->arg.hlua_rule->args) {
6430 memprintf(err, "out of memory error");
6431 return ACT_RET_PRS_ERR;
6432 }
6433
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006434 /* Reference the Lua function and store the reference. */
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006435 rule->arg.hlua_rule->fcn = *fcn;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006436
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01006437 /* Expect some arguments */
6438 for (i = 0; i < fcn->nargs; i++) {
6439 if (*args[i+1] == '\0') {
6440 memprintf(err, "expect %d arguments", fcn->nargs);
6441 return ACT_RET_PRS_ERR;
6442 }
6443 rule->arg.hlua_rule->args[i] = strdup(args[i + 1]);
6444 if (!rule->arg.hlua_rule->args[i]) {
6445 memprintf(err, "out of memory error");
6446 return ACT_RET_PRS_ERR;
6447 }
6448 (*cur_arg)++;
6449 }
6450 rule->arg.hlua_rule->args[i] = NULL;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006451
Thierry FOURNIER42148732015-09-02 17:17:33 +02006452 rule->action = ACT_CUSTOM;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006453 rule->action_ptr = hlua_action;
Thierry FOURNIERafa80492015-08-19 09:04:15 +02006454 return ACT_RET_PRS_OK;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006455}
6456
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006457static enum act_parse_ret action_register_service_http(const char **args, int *cur_arg, struct proxy *px,
6458 struct act_rule *rule, char **err)
6459{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02006460 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006461
Thierry FOURNIER718e2a72015-12-20 20:13:14 +01006462 /* HTTP applets are forbidden in tcp-request rules.
6463 * HTTP applet request requires everything initilized by
6464 * "http_process_request" (analyzer flag AN_REQ_HTTP_INNER).
6465 * The applet will be immediately initilized, but its before
6466 * the call of this analyzer.
6467 */
6468 if (rule->from != ACT_F_HTTP_REQ) {
6469 memprintf(err, "HTTP applets are forbidden from 'tcp-request' rulesets");
6470 return ACT_RET_PRS_ERR;
6471 }
6472
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006473 /* Memory for the rule. */
6474 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
6475 if (!rule->arg.hlua_rule) {
6476 memprintf(err, "out of memory error");
6477 return ACT_RET_PRS_ERR;
6478 }
6479
6480 /* Reference the Lua function and store the reference. */
6481 rule->arg.hlua_rule->fcn = *fcn;
6482
6483 /* TODO: later accept arguments. */
6484 rule->arg.hlua_rule->args = NULL;
6485
6486 /* Add applet pointer in the rule. */
6487 rule->applet.obj_type = OBJ_TYPE_APPLET;
6488 rule->applet.name = fcn->name;
6489 rule->applet.init = hlua_applet_http_init;
6490 rule->applet.fct = hlua_applet_http_fct;
6491 rule->applet.release = hlua_applet_http_release;
6492 rule->applet.timeout = hlua_timeout_applet;
6493
6494 return ACT_RET_PRS_OK;
6495}
6496
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006497/* This function is an LUA binding used for registering
6498 * "sample-conv" functions. It expects a converter name used
6499 * in the haproxy configuration file, and an LUA function.
6500 */
6501__LJMP static int hlua_register_action(lua_State *L)
6502{
6503 struct action_kw_list *akl;
6504 const char *name;
6505 int ref;
6506 int len;
6507 struct hlua_function *fcn;
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01006508 int nargs;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006509
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01006510 /* Initialise the number of expected arguments at 0. */
6511 nargs = 0;
6512
6513 if (lua_gettop(L) < 3 || lua_gettop(L) > 4)
6514 WILL_LJMP(luaL_error(L, "'register_action' needs between 3 and 4 arguments"));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006515
6516 /* First argument : converter name. */
6517 name = MAY_LJMP(luaL_checkstring(L, 1));
6518
6519 /* Second argument : environment. */
6520 if (lua_type(L, 2) != LUA_TTABLE)
6521 WILL_LJMP(luaL_error(L, "register_action: second argument must be a table of strings"));
6522
6523 /* Third argument : lua function. */
6524 ref = MAY_LJMP(hlua_checkfunction(L, 3));
6525
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01006526 /* Fouth argument : number of mandatories arguments expected on the configuration line. */
6527 if (lua_gettop(L) >= 4)
6528 nargs = MAY_LJMP(luaL_checkinteger(L, 4));
6529
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006530 /* browse the second argulent as an array. */
6531 lua_pushnil(L);
6532 while (lua_next(L, 2) != 0) {
6533 if (lua_type(L, -1) != LUA_TSTRING)
6534 WILL_LJMP(luaL_error(L, "register_action: second argument must be a table of strings"));
6535
6536 /* Check required environment. Only accepted "http" or "tcp". */
6537 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006538 akl = calloc(1, sizeof(*akl) + sizeof(struct action_kw) * 2);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006539 if (!akl)
6540 WILL_LJMP(luaL_error(L, "lua out of memory error."));
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006541 fcn = calloc(1, sizeof(*fcn));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006542 if (!fcn)
6543 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6544
6545 /* Fill fcn. */
6546 fcn->name = strdup(name);
6547 if (!fcn->name)
6548 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6549 fcn->function_ref = ref;
6550
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01006551 /* Set the expected number od arguments. */
6552 fcn->nargs = nargs;
6553
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006554 /* List head */
6555 akl->list.n = akl->list.p = NULL;
6556
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006557 /* action keyword. */
6558 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006559 akl->kw[0].kw = calloc(1, len);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006560 if (!akl->kw[0].kw)
6561 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6562
6563 snprintf((char *)akl->kw[0].kw, len, "lua.%s", name);
6564
6565 akl->kw[0].match_pfx = 0;
6566 akl->kw[0].private = fcn;
6567 akl->kw[0].parse = action_register_lua;
6568
6569 /* select the action registering point. */
6570 if (strcmp(lua_tostring(L, -1), "tcp-req") == 0)
6571 tcp_req_cont_keywords_register(akl);
6572 else if (strcmp(lua_tostring(L, -1), "tcp-res") == 0)
6573 tcp_res_cont_keywords_register(akl);
6574 else if (strcmp(lua_tostring(L, -1), "http-req") == 0)
6575 http_req_keywords_register(akl);
6576 else if (strcmp(lua_tostring(L, -1), "http-res") == 0)
6577 http_res_keywords_register(akl);
6578 else
6579 WILL_LJMP(luaL_error(L, "lua action environment '%s' is unknown. "
6580 "'tcp-req', 'tcp-res', 'http-req' or 'http-res' "
6581 "are expected.", lua_tostring(L, -1)));
6582
6583 /* pop the environment string. */
6584 lua_pop(L, 1);
6585 }
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006586 return ACT_RET_PRS_OK;
6587}
6588
6589static enum act_parse_ret action_register_service_tcp(const char **args, int *cur_arg, struct proxy *px,
6590 struct act_rule *rule, char **err)
6591{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02006592 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006593
6594 /* Memory for the rule. */
6595 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
6596 if (!rule->arg.hlua_rule) {
6597 memprintf(err, "out of memory error");
6598 return ACT_RET_PRS_ERR;
6599 }
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006600
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006601 /* Reference the Lua function and store the reference. */
6602 rule->arg.hlua_rule->fcn = *fcn;
6603
6604 /* TODO: later accept arguments. */
6605 rule->arg.hlua_rule->args = NULL;
6606
6607 /* Add applet pointer in the rule. */
6608 rule->applet.obj_type = OBJ_TYPE_APPLET;
6609 rule->applet.name = fcn->name;
6610 rule->applet.init = hlua_applet_tcp_init;
6611 rule->applet.fct = hlua_applet_tcp_fct;
6612 rule->applet.release = hlua_applet_tcp_release;
6613 rule->applet.timeout = hlua_timeout_applet;
6614
6615 return 0;
6616}
6617
6618/* This function is an LUA binding used for registering
6619 * "sample-conv" functions. It expects a converter name used
6620 * in the haproxy configuration file, and an LUA function.
6621 */
6622__LJMP static int hlua_register_service(lua_State *L)
6623{
6624 struct action_kw_list *akl;
6625 const char *name;
6626 const char *env;
6627 int ref;
6628 int len;
6629 struct hlua_function *fcn;
6630
6631 MAY_LJMP(check_args(L, 3, "register_service"));
6632
6633 /* First argument : converter name. */
6634 name = MAY_LJMP(luaL_checkstring(L, 1));
6635
6636 /* Second argument : environment. */
6637 env = MAY_LJMP(luaL_checkstring(L, 2));
6638
6639 /* Third argument : lua function. */
6640 ref = MAY_LJMP(hlua_checkfunction(L, 3));
6641
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006642 /* Allocate and fill the sample fetch keyword struct. */
6643 akl = calloc(1, sizeof(*akl) + sizeof(struct action_kw) * 2);
6644 if (!akl)
6645 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6646 fcn = calloc(1, sizeof(*fcn));
6647 if (!fcn)
6648 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6649
6650 /* Fill fcn. */
6651 len = strlen("<lua.>") + strlen(name) + 1;
6652 fcn->name = calloc(1, len);
6653 if (!fcn->name)
6654 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6655 snprintf((char *)fcn->name, len, "<lua.%s>", name);
6656 fcn->function_ref = ref;
6657
6658 /* List head */
6659 akl->list.n = akl->list.p = NULL;
6660
6661 /* converter keyword. */
6662 len = strlen("lua.") + strlen(name) + 1;
6663 akl->kw[0].kw = calloc(1, len);
6664 if (!akl->kw[0].kw)
6665 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6666
6667 snprintf((char *)akl->kw[0].kw, len, "lua.%s", name);
6668
Thierry FOURNIER / OZON.IO02564fd2016-11-12 11:07:05 +01006669 /* Check required environment. Only accepted "http" or "tcp". */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006670 if (strcmp(env, "tcp") == 0)
6671 akl->kw[0].parse = action_register_service_tcp;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006672 else if (strcmp(env, "http") == 0)
6673 akl->kw[0].parse = action_register_service_http;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006674 else
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02006675 WILL_LJMP(luaL_error(L, "lua service environment '%s' is unknown. "
6676 "'tcp' or 'http' are expected."));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006677
6678 akl->kw[0].match_pfx = 0;
6679 akl->kw[0].private = fcn;
6680
6681 /* End of array. */
6682 memset(&akl->kw[1], 0, sizeof(*akl->kw));
6683
6684 /* Register this new converter */
6685 service_keywords_register(akl);
6686
Thierry FOURNIER8255a752015-09-23 21:03:35 +02006687 return 0;
6688}
6689
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01006690/* This function initialises Lua cli handler. It copies the
6691 * arguments in the Lua stack and create channel IO objects.
6692 */
6693static int hlua_cli_parse_fct(char **args, struct appctx *appctx, void *private)
6694{
6695 struct hlua *hlua;
6696 struct hlua_function *fcn;
6697 int i;
6698 const char *error;
6699
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01006700 fcn = private;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006701 appctx->ctx.hlua_cli.fcn = private;
6702
6703 hlua = pool_alloc2(pool2_hlua);
6704 if (!hlua) {
6705 SEND_ERR(NULL, "Lua cli '%s': out of memory.\n", fcn->name);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01006706 return 1;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006707 }
6708 HLUA_INIT(hlua);
6709 appctx->ctx.hlua_cli.hlua = hlua;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01006710
6711 /* Create task used by signal to wakeup applets.
6712 * We use the same wakeup fonction than the Lua applet_tcp and
6713 * applet_http. It is absolutely compatible.
6714 */
6715 appctx->ctx.hlua_cli.task = task_new();
6716 if (!appctx->ctx.hlua_cli.task) {
Thierry FOURNIERffbf5692016-12-16 11:14:06 +01006717 SEND_ERR(NULL, "Lua cli '%s': out of memory.\n", fcn->name);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01006718 goto error;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01006719 }
6720 appctx->ctx.hlua_cli.task->nice = 0;
6721 appctx->ctx.hlua_cli.task->context = appctx;
6722 appctx->ctx.hlua_cli.task->process = hlua_applet_wakeup;
6723
6724 /* Initialises the Lua context */
6725 if (!hlua_ctx_init(hlua, appctx->ctx.hlua_cli.task)) {
6726 SEND_ERR(NULL, "Lua cli '%s': can't initialize Lua context.\n", fcn->name);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01006727 goto error;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01006728 }
6729
6730 /* The following Lua calls can fail. */
6731 if (!SET_SAFE_LJMP(hlua->T)) {
6732 if (lua_type(hlua->T, -1) == LUA_TSTRING)
6733 error = lua_tostring(hlua->T, -1);
6734 else
6735 error = "critical error";
6736 SEND_ERR(NULL, "Lua cli '%s': %s.\n", fcn->name, error);
6737 goto error;
6738 }
6739
6740 /* Check stack available size. */
6741 if (!lua_checkstack(hlua->T, 2)) {
6742 SEND_ERR(NULL, "Lua cli '%s': full stack.\n", fcn->name);
6743 goto error;
6744 }
6745
6746 /* Restore the function in the stack. */
6747 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, fcn->function_ref);
6748
6749 /* Once the arguments parsed, the CLI is like an AppletTCP,
6750 * so push AppletTCP in the stack.
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01006751 */
6752 if (!hlua_applet_tcp_new(hlua->T, appctx)) {
6753 SEND_ERR(NULL, "Lua cli '%s': full stack.\n", fcn->name);
6754 goto error;
6755 }
6756 hlua->nargs = 1;
6757
6758 /* push keywords in the stack. */
6759 for (i = 0; *args[i]; i++) {
6760 /* Check stack available size. */
6761 if (!lua_checkstack(hlua->T, 1)) {
6762 SEND_ERR(NULL, "Lua cli '%s': full stack.\n", fcn->name);
6763 goto error;
6764 }
6765 lua_pushstring(hlua->T, args[i]);
6766 hlua->nargs++;
6767 }
6768
6769 /* We must initialize the execution timeouts. */
6770 hlua->max_time = hlua_timeout_session;
6771
6772 /* At this point the execution is safe. */
6773 RESET_SAFE_LJMP(hlua->T);
6774
6775 /* It's ok */
6776 return 0;
6777
6778 /* It's not ok. */
6779error:
6780 RESET_SAFE_LJMP(hlua->T);
6781 hlua_ctx_destroy(hlua);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01006782 appctx->ctx.hlua_cli.hlua = NULL;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01006783 return 1;
6784}
6785
6786static int hlua_cli_io_handler_fct(struct appctx *appctx)
6787{
6788 struct hlua *hlua;
6789 struct stream_interface *si;
6790 struct hlua_function *fcn;
6791
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006792 hlua = appctx->ctx.hlua_cli.hlua;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01006793 si = appctx->owner;
Willy Tarreau8ae4f752016-12-14 15:41:45 +01006794 fcn = appctx->ctx.hlua_cli.fcn;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01006795
6796 /* If the stream is disconnect or closed, ldo nothing. */
6797 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
6798 return 1;
6799
6800 /* Execute the function. */
6801 switch (hlua_ctx_resume(hlua, 1)) {
6802
6803 /* finished. */
6804 case HLUA_E_OK:
6805 return 1;
6806
6807 /* yield. */
6808 case HLUA_E_AGAIN:
6809 /* We want write. */
6810 if (HLUA_IS_WAKERESWR(hlua))
6811 si_applet_cant_put(si);
6812 /* Set the timeout. */
6813 if (hlua->wake_time != TICK_ETERNITY)
6814 task_schedule(hlua->task, hlua->wake_time);
6815 return 0;
6816
6817 /* finished with error. */
6818 case HLUA_E_ERRMSG:
6819 /* Display log. */
6820 SEND_ERR(NULL, "Lua cli '%s': %s.\n",
6821 fcn->name, lua_tostring(hlua->T, -1));
6822 lua_pop(hlua->T, 1);
6823 return 1;
6824
6825 case HLUA_E_ERR:
6826 /* Display log. */
6827 SEND_ERR(NULL, "Lua cli '%s' return an unknown error.\n",
6828 fcn->name);
6829 return 1;
6830
6831 default:
6832 return 1;
6833 }
6834
6835 return 1;
6836}
6837
6838static void hlua_cli_io_release_fct(struct appctx *appctx)
6839{
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006840 hlua_ctx_destroy(appctx->ctx.hlua_cli.hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006841 appctx->ctx.hlua_cli.hlua = NULL;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01006842}
6843
6844/* This function is an LUA binding used for registering
6845 * new keywords in the cli. It expects a list of keywords
6846 * which are the "path". It is limited to 5 keywords. A
6847 * description of the command, a function to be executed
6848 * for the parsing and a function for io handlers.
6849 */
6850__LJMP static int hlua_register_cli(lua_State *L)
6851{
6852 struct cli_kw_list *cli_kws;
6853 const char *message;
6854 int ref_io;
6855 int len;
6856 struct hlua_function *fcn;
6857 int index;
6858 int i;
6859
6860 MAY_LJMP(check_args(L, 3, "register_cli"));
6861
6862 /* First argument : an array of maximum 5 keywords. */
6863 if (!lua_istable(L, 1))
6864 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table"));
6865
6866 /* Second argument : string with contextual message. */
6867 message = MAY_LJMP(luaL_checkstring(L, 2));
6868
6869 /* Third and fourth argument : lua function. */
6870 ref_io = MAY_LJMP(hlua_checkfunction(L, 3));
6871
6872 /* Allocate and fill the sample fetch keyword struct. */
6873 cli_kws = calloc(1, sizeof(*cli_kws) + sizeof(struct cli_kw) * 2);
6874 if (!cli_kws)
6875 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6876 fcn = calloc(1, sizeof(*fcn));
6877 if (!fcn)
6878 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6879
6880 /* Fill path. */
6881 index = 0;
6882 lua_pushnil(L);
6883 while(lua_next(L, 1) != 0) {
6884 if (index >= 5)
6885 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table with a maximum of 5 entries"));
6886 if (lua_type(L, -1) != LUA_TSTRING)
6887 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table filled with strings"));
6888 cli_kws->kw[0].str_kw[index] = strdup(lua_tostring(L, -1));
6889 if (!cli_kws->kw[0].str_kw[index])
6890 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6891 index++;
6892 lua_pop(L, 1);
6893 }
6894
6895 /* Copy help message. */
6896 cli_kws->kw[0].usage = strdup(message);
6897 if (!cli_kws->kw[0].usage)
6898 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6899
6900 /* Fill fcn io handler. */
6901 len = strlen("<lua.cli>") + 1;
6902 for (i = 0; i < index; i++)
6903 len += strlen(cli_kws->kw[0].str_kw[i]) + 1;
6904 fcn->name = calloc(1, len);
6905 if (!fcn->name)
6906 WILL_LJMP(luaL_error(L, "lua out of memory error."));
6907 strncat((char *)fcn->name, "<lua.cli", len);
6908 for (i = 0; i < index; i++) {
6909 strncat((char *)fcn->name, ".", len);
6910 strncat((char *)fcn->name, cli_kws->kw[0].str_kw[i], len);
6911 }
6912 strncat((char *)fcn->name, ">", len);
6913 fcn->function_ref = ref_io;
6914
6915 /* Fill last entries. */
6916 cli_kws->kw[0].private = fcn;
6917 cli_kws->kw[0].parse = hlua_cli_parse_fct;
6918 cli_kws->kw[0].io_handler = hlua_cli_io_handler_fct;
6919 cli_kws->kw[0].io_release = hlua_cli_io_release_fct;
6920
6921 /* Register this new converter */
6922 cli_register_kw(cli_kws);
6923
6924 return 0;
6925}
6926
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006927static int hlua_read_timeout(char **args, int section_type, struct proxy *curpx,
6928 struct proxy *defpx, const char *file, int line,
6929 char **err, unsigned int *timeout)
6930{
6931 const char *error;
6932
6933 error = parse_time_err(args[1], timeout, TIME_UNIT_MS);
6934 if (error && *error != '\0') {
6935 memprintf(err, "%s: invalid timeout", args[0]);
6936 return -1;
6937 }
6938 return 0;
6939}
6940
6941static int hlua_session_timeout(char **args, int section_type, struct proxy *curpx,
6942 struct proxy *defpx, const char *file, int line,
6943 char **err)
6944{
6945 return hlua_read_timeout(args, section_type, curpx, defpx,
6946 file, line, err, &hlua_timeout_session);
6947}
6948
6949static int hlua_task_timeout(char **args, int section_type, struct proxy *curpx,
6950 struct proxy *defpx, const char *file, int line,
6951 char **err)
6952{
6953 return hlua_read_timeout(args, section_type, curpx, defpx,
6954 file, line, err, &hlua_timeout_task);
6955}
6956
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006957static int hlua_applet_timeout(char **args, int section_type, struct proxy *curpx,
6958 struct proxy *defpx, const char *file, int line,
6959 char **err)
6960{
6961 return hlua_read_timeout(args, section_type, curpx, defpx,
6962 file, line, err, &hlua_timeout_applet);
6963}
6964
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01006965static int hlua_forced_yield(char **args, int section_type, struct proxy *curpx,
6966 struct proxy *defpx, const char *file, int line,
6967 char **err)
6968{
6969 char *error;
6970
6971 hlua_nb_instruction = strtoll(args[1], &error, 10);
6972 if (*error != '\0') {
6973 memprintf(err, "%s: invalid number", args[0]);
6974 return -1;
6975 }
6976 return 0;
6977}
6978
Willy Tarreau32f61e22015-03-18 17:54:59 +01006979static int hlua_parse_maxmem(char **args, int section_type, struct proxy *curpx,
6980 struct proxy *defpx, const char *file, int line,
6981 char **err)
6982{
6983 char *error;
6984
6985 if (*(args[1]) == 0) {
6986 memprintf(err, "'%s' expects an integer argument (Lua memory size in MB).\n", args[0]);
6987 return -1;
6988 }
6989 hlua_global_allocator.limit = strtoll(args[1], &error, 10) * 1024L * 1024L;
6990 if (*error != '\0') {
6991 memprintf(err, "%s: invalid number %s (error at '%c')", args[0], args[1], *error);
6992 return -1;
6993 }
6994 return 0;
6995}
6996
6997
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01006998/* This function is called by the main configuration key "lua-load". It loads and
6999 * execute an lua file during the parsing of the HAProxy configuration file. It is
7000 * the main lua entry point.
7001 *
7002 * This funtion runs with the HAProxy keywords API. It returns -1 if an error is
7003 * occured, otherwise it returns 0.
7004 *
7005 * In some error case, LUA set an error message in top of the stack. This function
7006 * returns this error message in the HAProxy logs and pop it from the stack.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02007007 *
7008 * This function can fail with an abort() due to an Lua critical error.
7009 * We are in the configuration parsing process of HAProxy, this abort() is
7010 * tolerated.
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01007011 */
7012static int hlua_load(char **args, int section_type, struct proxy *curpx,
7013 struct proxy *defpx, const char *file, int line,
7014 char **err)
7015{
7016 int error;
7017
7018 /* Just load and compile the file. */
7019 error = luaL_loadfile(gL.T, args[1]);
7020 if (error) {
7021 memprintf(err, "error in lua file '%s': %s", args[1], lua_tostring(gL.T, -1));
7022 lua_pop(gL.T, 1);
7023 return -1;
7024 }
7025
7026 /* If no syntax error where detected, execute the code. */
7027 error = lua_pcall(gL.T, 0, LUA_MULTRET, 0);
7028 switch (error) {
7029 case LUA_OK:
7030 break;
7031 case LUA_ERRRUN:
7032 memprintf(err, "lua runtime error: %s\n", lua_tostring(gL.T, -1));
7033 lua_pop(gL.T, 1);
7034 return -1;
7035 case LUA_ERRMEM:
7036 memprintf(err, "lua out of memory error\n");
7037 return -1;
7038 case LUA_ERRERR:
7039 memprintf(err, "lua message handler error: %s\n", lua_tostring(gL.T, -1));
7040 lua_pop(gL.T, 1);
7041 return -1;
7042 case LUA_ERRGCMM:
7043 memprintf(err, "lua garbage collector error: %s\n", lua_tostring(gL.T, -1));
7044 lua_pop(gL.T, 1);
7045 return -1;
7046 default:
7047 memprintf(err, "lua unknonwn error: %s\n", lua_tostring(gL.T, -1));
7048 lua_pop(gL.T, 1);
7049 return -1;
7050 }
7051
7052 return 0;
7053}
7054
7055/* configuration keywords declaration */
7056static struct cfg_kw_list cfg_kws = {{ },{
Thierry FOURNIERbd413492015-03-03 16:52:26 +01007057 { CFG_GLOBAL, "lua-load", hlua_load },
7058 { CFG_GLOBAL, "tune.lua.session-timeout", hlua_session_timeout },
7059 { CFG_GLOBAL, "tune.lua.task-timeout", hlua_task_timeout },
Thierry FOURNIER56da1012015-10-01 08:42:31 +02007060 { CFG_GLOBAL, "tune.lua.service-timeout", hlua_applet_timeout },
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01007061 { CFG_GLOBAL, "tune.lua.forced-yield", hlua_forced_yield },
Willy Tarreau32f61e22015-03-18 17:54:59 +01007062 { CFG_GLOBAL, "tune.lua.maxmem", hlua_parse_maxmem },
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01007063 { 0, NULL, NULL },
7064}};
7065
Thierry FOURNIERbabae282015-09-17 11:36:37 +02007066/* This function can fail with an abort() due to an Lua critical error.
7067 * We are in the initialisation process of HAProxy, this abort() is
7068 * tolerated.
7069 */
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01007070int hlua_post_init()
7071{
7072 struct hlua_init_function *init;
7073 const char *msg;
7074 enum hlua_exec ret;
Thierry Fournierfd107a22016-02-19 19:57:23 +01007075 const char *error;
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01007076
Thierry Fournier3d4a6752016-02-19 20:53:30 +01007077 /* Call post initialisation function in safe environement. */
7078 if (!SET_SAFE_LJMP(gL.T)) {
7079 if (lua_type(gL.T, -1) == LUA_TSTRING)
7080 error = lua_tostring(gL.T, -1);
7081 else
7082 error = "critical error";
7083 fprintf(stderr, "Lua post-init: %s.\n", error);
7084 exit(1);
7085 }
7086 hlua_fcn_post_init(gL.T);
7087 RESET_SAFE_LJMP(gL.T);
7088
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01007089 list_for_each_entry(init, &hlua_init_functions, l) {
7090 lua_rawgeti(gL.T, LUA_REGISTRYINDEX, init->function_ref);
7091 ret = hlua_ctx_resume(&gL, 0);
7092 switch (ret) {
7093 case HLUA_E_OK:
7094 lua_pop(gL.T, -1);
7095 return 1;
7096 case HLUA_E_AGAIN:
7097 Alert("lua init: yield not allowed.\n");
7098 return 0;
7099 case HLUA_E_ERRMSG:
7100 msg = lua_tostring(gL.T, -1);
7101 Alert("lua init: %s.\n", msg);
7102 return 0;
7103 case HLUA_E_ERR:
7104 default:
7105 Alert("lua init: unknown runtime error.\n");
7106 return 0;
7107 }
7108 }
7109 return 1;
7110}
7111
Willy Tarreau32f61e22015-03-18 17:54:59 +01007112/* The memory allocator used by the Lua stack. <ud> is a pointer to the
7113 * allocator's context. <ptr> is the pointer to alloc/free/realloc. <osize>
7114 * is the previously allocated size or the kind of object in case of a new
7115 * allocation. <nsize> is the requested new size.
7116 */
7117static void *hlua_alloc(void *ud, void *ptr, size_t osize, size_t nsize)
7118{
7119 struct hlua_mem_allocator *zone = ud;
7120
7121 if (nsize == 0) {
7122 /* it's a free */
7123 if (ptr)
7124 zone->allocated -= osize;
7125 free(ptr);
7126 return NULL;
7127 }
7128
7129 if (!ptr) {
7130 /* it's a new allocation */
7131 if (zone->limit && zone->allocated + nsize > zone->limit)
7132 return NULL;
7133
7134 ptr = malloc(nsize);
7135 if (ptr)
7136 zone->allocated += nsize;
7137 return ptr;
7138 }
7139
7140 /* it's a realloc */
7141 if (zone->limit && zone->allocated + nsize - osize > zone->limit)
7142 return NULL;
7143
7144 ptr = realloc(ptr, nsize);
7145 if (ptr)
7146 zone->allocated += nsize - osize;
7147 return ptr;
7148}
7149
Thierry FOURNIERbabae282015-09-17 11:36:37 +02007150/* Ithis function can fail with an abort() due to an Lua critical error.
7151 * We are in the initialisation process of HAProxy, this abort() is
7152 * tolerated.
7153 */
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +01007154void hlua_init(void)
7155{
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01007156 int i;
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01007157 int idx;
7158 struct sample_fetch *sf;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01007159 struct sample_conv *sc;
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01007160 char *p;
Thierry Fournierfd107a22016-02-19 19:57:23 +01007161 const char *error_msg;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01007162#ifdef USE_OPENSSL
Willy Tarreau80f5fae2015-02-27 16:38:20 +01007163 struct srv_kw *kw;
7164 int tmp_error;
7165 char *error;
Thierry FOURNIER36d13742015-03-17 16:48:53 +01007166 char *args[] = { /* SSL client configuration. */
7167 "ssl",
7168 "verify",
7169 "none",
Thierry FOURNIER36d13742015-03-17 16:48:53 +01007170 NULL
7171 };
Willy Tarreau80f5fae2015-02-27 16:38:20 +01007172#endif
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01007173
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007174 /* Initialise struct hlua and com signals pool */
7175 pool2_hlua = create_pool("hlua", sizeof(struct hlua), MEM_F_SHARED);
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +01007176 pool2_hlua_com = create_pool("hlua_com", sizeof(struct hlua_com), MEM_F_SHARED);
7177
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01007178 /* Register configuration keywords. */
7179 cfg_register_keywords(&cfg_kws);
7180
Thierry FOURNIER380d0932015-01-23 14:27:52 +01007181 /* Init main lua stack. */
7182 gL.Mref = LUA_REFNIL;
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01007183 gL.flags = 0;
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +01007184 LIST_INIT(&gL.com);
Willy Tarreau42ef75f2017-04-12 21:40:29 +02007185 gL.T = lua_newstate(hlua_alloc, &hlua_global_allocator);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01007186 hlua_sethlua(&gL);
7187 gL.Tref = LUA_REFNIL;
7188 gL.task = NULL;
7189
Thierry FOURNIERbabae282015-09-17 11:36:37 +02007190 /* From this point, until the end of the initialisation fucntion,
7191 * the Lua function can fail with an abort. We are in the initialisation
7192 * process of HAProxy, this abort() is tolerated.
7193 */
7194
Thierry FOURNIER380d0932015-01-23 14:27:52 +01007195 /* Initialise lua. */
7196 luaL_openlibs(gL.T);
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01007197
Thierry Fournier75933d42016-01-21 09:30:18 +01007198 /* Set safe environment for the initialisation. */
7199 if (!SET_SAFE_LJMP(gL.T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01007200 if (lua_type(gL.T, -1) == LUA_TSTRING)
7201 error_msg = lua_tostring(gL.T, -1);
7202 else
7203 error_msg = "critical error";
7204 fprintf(stderr, "Lua init: %s.\n", error_msg);
Thierry Fournier75933d42016-01-21 09:30:18 +01007205 exit(1);
7206 }
7207
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01007208 /*
7209 *
7210 * Create "core" object.
7211 *
7212 */
7213
Thierry FOURNIERa2d8c652015-03-11 17:29:39 +01007214 /* This table entry is the object "core" base. */
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01007215 lua_newtable(gL.T);
7216
7217 /* Push the loglevel constants. */
Willy Tarreau80f5fae2015-02-27 16:38:20 +01007218 for (i = 0; i < NB_LOG_LEVELS; i++)
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01007219 hlua_class_const_int(gL.T, log_levels[i], i);
7220
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01007221 /* Register special functions. */
7222 hlua_class_function(gL.T, "register_init", hlua_register_init);
Thierry FOURNIER24f33532015-01-23 12:13:00 +01007223 hlua_class_function(gL.T, "register_task", hlua_register_task);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01007224 hlua_class_function(gL.T, "register_fetches", hlua_register_fetches);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01007225 hlua_class_function(gL.T, "register_converters", hlua_register_converters);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007226 hlua_class_function(gL.T, "register_action", hlua_register_action);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007227 hlua_class_function(gL.T, "register_service", hlua_register_service);
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007228 hlua_class_function(gL.T, "register_cli", hlua_register_cli);
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01007229 hlua_class_function(gL.T, "yield", hlua_yield);
Willy Tarreau59551662015-03-10 14:23:13 +01007230 hlua_class_function(gL.T, "set_nice", hlua_set_nice);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01007231 hlua_class_function(gL.T, "sleep", hlua_sleep);
7232 hlua_class_function(gL.T, "msleep", hlua_msleep);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01007233 hlua_class_function(gL.T, "add_acl", hlua_add_acl);
7234 hlua_class_function(gL.T, "del_acl", hlua_del_acl);
7235 hlua_class_function(gL.T, "set_map", hlua_set_map);
7236 hlua_class_function(gL.T, "del_map", hlua_del_map);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007237 hlua_class_function(gL.T, "tcp", hlua_socket_new);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01007238 hlua_class_function(gL.T, "log", hlua_log);
7239 hlua_class_function(gL.T, "Debug", hlua_log_debug);
7240 hlua_class_function(gL.T, "Info", hlua_log_info);
7241 hlua_class_function(gL.T, "Warning", hlua_log_warning);
7242 hlua_class_function(gL.T, "Alert", hlua_log_alert);
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02007243 hlua_class_function(gL.T, "done", hlua_done);
Thierry Fournierfb0b5462016-01-21 09:28:58 +01007244 hlua_fcn_reg_core_fcn(gL.T);
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01007245
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01007246 lua_setglobal(gL.T, "core");
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01007247
7248 /*
7249 *
Thierry FOURNIER3def3932015-04-07 11:27:54 +02007250 * Register class Map
7251 *
7252 */
7253
7254 /* This table entry is the object "Map" base. */
7255 lua_newtable(gL.T);
7256
7257 /* register pattern types. */
7258 for (i=0; i<PAT_MATCH_NUM; i++)
7259 hlua_class_const_int(gL.T, pat_match_names[i], i);
Thierry FOURNIER4dc71972017-01-28 08:33:08 +01007260 for (i=0; i<PAT_MATCH_NUM; i++) {
7261 snprintf(trash.str, trash.size, "_%s", pat_match_names[i]);
7262 hlua_class_const_int(gL.T, trash.str, i);
7263 }
Thierry FOURNIER3def3932015-04-07 11:27:54 +02007264
7265 /* register constructor. */
7266 hlua_class_function(gL.T, "new", hlua_map_new);
7267
7268 /* Create and fill the metatable. */
7269 lua_newtable(gL.T);
7270
7271 /* Create and fille the __index entry. */
7272 lua_pushstring(gL.T, "__index");
7273 lua_newtable(gL.T);
7274
7275 /* Register . */
7276 hlua_class_function(gL.T, "lookup", hlua_map_lookup);
7277 hlua_class_function(gL.T, "slookup", hlua_map_slookup);
7278
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02007279 lua_rawset(gL.T, -3);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02007280
Thierry Fournier45e78d72016-02-19 18:34:46 +01007281 /* Register previous table in the registry with reference and named entry.
7282 * The function hlua_register_metatable() pops the stack, so we
7283 * previously create a copy of the table.
7284 */
Thierry FOURNIER3def3932015-04-07 11:27:54 +02007285 lua_pushvalue(gL.T, -1); /* Copy the -1 entry and push it on the stack. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01007286 class_map_ref = hlua_register_metatable(gL.T, CLASS_MAP);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02007287
7288 /* Assign the metatable to the mai Map object. */
7289 lua_setmetatable(gL.T, -2);
7290
7291 /* Set a name to the table. */
7292 lua_setglobal(gL.T, "Map");
7293
7294 /*
7295 *
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01007296 * Register class Channel
7297 *
7298 */
7299
7300 /* Create and fill the metatable. */
7301 lua_newtable(gL.T);
7302
7303 /* Create and fille the __index entry. */
7304 lua_pushstring(gL.T, "__index");
7305 lua_newtable(gL.T);
7306
7307 /* Register . */
7308 hlua_class_function(gL.T, "get", hlua_channel_get);
7309 hlua_class_function(gL.T, "dup", hlua_channel_dup);
7310 hlua_class_function(gL.T, "getline", hlua_channel_getline);
7311 hlua_class_function(gL.T, "set", hlua_channel_set);
7312 hlua_class_function(gL.T, "append", hlua_channel_append);
7313 hlua_class_function(gL.T, "send", hlua_channel_send);
7314 hlua_class_function(gL.T, "forward", hlua_channel_forward);
7315 hlua_class_function(gL.T, "get_in_len", hlua_channel_get_in_len);
7316 hlua_class_function(gL.T, "get_out_len", hlua_channel_get_out_len);
Thierry FOURNIER / OZON.IO65192f32016-11-07 15:28:40 +01007317 hlua_class_function(gL.T, "is_full", hlua_channel_is_full);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01007318
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02007319 lua_rawset(gL.T, -3);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01007320
7321 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01007322 class_channel_ref = hlua_register_metatable(gL.T, CLASS_CHANNEL);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01007323
7324 /*
7325 *
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01007326 * Register class Fetches
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01007327 *
7328 */
7329
7330 /* Create and fill the metatable. */
7331 lua_newtable(gL.T);
7332
7333 /* Create and fille the __index entry. */
7334 lua_pushstring(gL.T, "__index");
7335 lua_newtable(gL.T);
7336
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01007337 /* Browse existing fetches and create the associated
7338 * object method.
7339 */
7340 sf = NULL;
7341 while ((sf = sample_fetch_getnext(sf, &idx)) != NULL) {
7342
7343 /* Dont register the keywork if the arguments check function are
7344 * not safe during the runtime.
7345 */
7346 if ((sf->val_args != NULL) &&
7347 (sf->val_args != val_payload_lv) &&
7348 (sf->val_args != val_hdr))
7349 continue;
7350
7351 /* gL.Tua doesn't support '.' and '-' in the function names, replace it
7352 * by an underscore.
7353 */
7354 strncpy(trash.str, sf->kw, trash.size);
7355 trash.str[trash.size - 1] = '\0';
7356 for (p = trash.str; *p; p++)
7357 if (*p == '.' || *p == '-' || *p == '+')
7358 *p = '_';
7359
7360 /* Register the function. */
7361 lua_pushstring(gL.T, trash.str);
Willy Tarreau2ec22742015-03-10 14:27:20 +01007362 lua_pushlightuserdata(gL.T, sf);
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01007363 lua_pushcclosure(gL.T, hlua_run_sample_fetch, 1);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02007364 lua_rawset(gL.T, -3);
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01007365 }
7366
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02007367 lua_rawset(gL.T, -3);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01007368
7369 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01007370 class_fetches_ref = hlua_register_metatable(gL.T, CLASS_FETCHES);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01007371
7372 /*
7373 *
Thierry FOURNIER594afe72015-03-10 23:58:30 +01007374 * Register class Converters
7375 *
7376 */
7377
7378 /* Create and fill the metatable. */
7379 lua_newtable(gL.T);
7380
7381 /* Create and fill the __index entry. */
7382 lua_pushstring(gL.T, "__index");
7383 lua_newtable(gL.T);
7384
7385 /* Browse existing converters and create the associated
7386 * object method.
7387 */
7388 sc = NULL;
7389 while ((sc = sample_conv_getnext(sc, &idx)) != NULL) {
7390 /* Dont register the keywork if the arguments check function are
7391 * not safe during the runtime.
7392 */
7393 if (sc->val_args != NULL)
7394 continue;
7395
7396 /* gL.Tua doesn't support '.' and '-' in the function names, replace it
7397 * by an underscore.
7398 */
7399 strncpy(trash.str, sc->kw, trash.size);
7400 trash.str[trash.size - 1] = '\0';
7401 for (p = trash.str; *p; p++)
7402 if (*p == '.' || *p == '-' || *p == '+')
7403 *p = '_';
7404
7405 /* Register the function. */
7406 lua_pushstring(gL.T, trash.str);
7407 lua_pushlightuserdata(gL.T, sc);
7408 lua_pushcclosure(gL.T, hlua_run_sample_conv, 1);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02007409 lua_rawset(gL.T, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01007410 }
7411
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02007412 lua_rawset(gL.T, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01007413
7414 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01007415 class_converters_ref = hlua_register_metatable(gL.T, CLASS_CONVERTERS);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01007416
7417 /*
7418 *
Thierry FOURNIER08504f42015-03-16 14:17:08 +01007419 * Register class HTTP
7420 *
7421 */
7422
7423 /* Create and fill the metatable. */
7424 lua_newtable(gL.T);
7425
7426 /* Create and fille the __index entry. */
7427 lua_pushstring(gL.T, "__index");
7428 lua_newtable(gL.T);
7429
7430 /* Register Lua functions. */
7431 hlua_class_function(gL.T, "req_get_headers",hlua_http_req_get_headers);
7432 hlua_class_function(gL.T, "req_del_header", hlua_http_req_del_hdr);
7433 hlua_class_function(gL.T, "req_rep_header", hlua_http_req_rep_hdr);
7434 hlua_class_function(gL.T, "req_rep_value", hlua_http_req_rep_val);
7435 hlua_class_function(gL.T, "req_add_header", hlua_http_req_add_hdr);
7436 hlua_class_function(gL.T, "req_set_header", hlua_http_req_set_hdr);
7437 hlua_class_function(gL.T, "req_set_method", hlua_http_req_set_meth);
7438 hlua_class_function(gL.T, "req_set_path", hlua_http_req_set_path);
7439 hlua_class_function(gL.T, "req_set_query", hlua_http_req_set_query);
7440 hlua_class_function(gL.T, "req_set_uri", hlua_http_req_set_uri);
7441
7442 hlua_class_function(gL.T, "res_get_headers",hlua_http_res_get_headers);
7443 hlua_class_function(gL.T, "res_del_header", hlua_http_res_del_hdr);
7444 hlua_class_function(gL.T, "res_rep_header", hlua_http_res_rep_hdr);
7445 hlua_class_function(gL.T, "res_rep_value", hlua_http_res_rep_val);
7446 hlua_class_function(gL.T, "res_add_header", hlua_http_res_add_hdr);
7447 hlua_class_function(gL.T, "res_set_header", hlua_http_res_set_hdr);
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02007448 hlua_class_function(gL.T, "res_set_status", hlua_http_res_set_status);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01007449
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02007450 lua_rawset(gL.T, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01007451
7452 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01007453 class_http_ref = hlua_register_metatable(gL.T, CLASS_HTTP);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01007454
7455 /*
7456 *
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007457 * Register class AppletTCP
7458 *
7459 */
7460
7461 /* Create and fill the metatable. */
7462 lua_newtable(gL.T);
7463
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007464 /* Create and fille the __index entry. */
7465 lua_pushstring(gL.T, "__index");
7466 lua_newtable(gL.T);
7467
7468 /* Register Lua functions. */
Thierry FOURNIER / OZON.IO3e1d7912016-12-12 12:29:34 +01007469 hlua_class_function(gL.T, "getline", hlua_applet_tcp_getline);
7470 hlua_class_function(gL.T, "receive", hlua_applet_tcp_recv);
7471 hlua_class_function(gL.T, "send", hlua_applet_tcp_send);
7472 hlua_class_function(gL.T, "set_priv", hlua_applet_tcp_set_priv);
7473 hlua_class_function(gL.T, "get_priv", hlua_applet_tcp_get_priv);
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01007474 hlua_class_function(gL.T, "set_var", hlua_applet_tcp_set_var);
7475 hlua_class_function(gL.T, "unset_var", hlua_applet_tcp_unset_var);
7476 hlua_class_function(gL.T, "get_var", hlua_applet_tcp_get_var);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007477
7478 lua_settable(gL.T, -3);
7479
7480 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01007481 class_applet_tcp_ref = hlua_register_metatable(gL.T, CLASS_APPLET_TCP);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007482
7483 /*
7484 *
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007485 * Register class AppletHTTP
7486 *
7487 */
7488
7489 /* Create and fill the metatable. */
7490 lua_newtable(gL.T);
7491
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007492 /* Create and fille the __index entry. */
7493 lua_pushstring(gL.T, "__index");
7494 lua_newtable(gL.T);
7495
7496 /* Register Lua functions. */
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01007497 hlua_class_function(gL.T, "set_priv", hlua_applet_http_set_priv);
7498 hlua_class_function(gL.T, "get_priv", hlua_applet_http_get_priv);
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01007499 hlua_class_function(gL.T, "set_var", hlua_applet_http_set_var);
7500 hlua_class_function(gL.T, "unset_var", hlua_applet_http_unset_var);
7501 hlua_class_function(gL.T, "get_var", hlua_applet_http_get_var);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007502 hlua_class_function(gL.T, "getline", hlua_applet_http_getline);
7503 hlua_class_function(gL.T, "receive", hlua_applet_http_recv);
7504 hlua_class_function(gL.T, "send", hlua_applet_http_send);
7505 hlua_class_function(gL.T, "add_header", hlua_applet_http_addheader);
7506 hlua_class_function(gL.T, "set_status", hlua_applet_http_status);
7507 hlua_class_function(gL.T, "start_response", hlua_applet_http_start_response);
7508
7509 lua_settable(gL.T, -3);
7510
7511 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01007512 class_applet_http_ref = hlua_register_metatable(gL.T, CLASS_APPLET_HTTP);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007513
7514 /*
7515 *
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01007516 * Register class TXN
7517 *
7518 */
7519
7520 /* Create and fill the metatable. */
7521 lua_newtable(gL.T);
7522
7523 /* Create and fille the __index entry. */
7524 lua_pushstring(gL.T, "__index");
7525 lua_newtable(gL.T);
7526
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01007527 /* Register Lua functions. */
Willy Tarreau59551662015-03-10 14:23:13 +01007528 hlua_class_function(gL.T, "set_priv", hlua_set_priv);
7529 hlua_class_function(gL.T, "get_priv", hlua_get_priv);
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02007530 hlua_class_function(gL.T, "set_var", hlua_set_var);
Christopher Faulet85d79c92016-11-09 16:54:56 +01007531 hlua_class_function(gL.T, "unset_var", hlua_unset_var);
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02007532 hlua_class_function(gL.T, "get_var", hlua_get_var);
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02007533 hlua_class_function(gL.T, "done", hlua_txn_done);
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01007534 hlua_class_function(gL.T, "set_loglevel",hlua_txn_set_loglevel);
7535 hlua_class_function(gL.T, "set_tos", hlua_txn_set_tos);
7536 hlua_class_function(gL.T, "set_mark", hlua_txn_set_mark);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01007537 hlua_class_function(gL.T, "deflog", hlua_txn_deflog);
7538 hlua_class_function(gL.T, "log", hlua_txn_log);
7539 hlua_class_function(gL.T, "Debug", hlua_txn_log_debug);
7540 hlua_class_function(gL.T, "Info", hlua_txn_log_info);
7541 hlua_class_function(gL.T, "Warning", hlua_txn_log_warning);
7542 hlua_class_function(gL.T, "Alert", hlua_txn_log_alert);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01007543
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02007544 lua_rawset(gL.T, -3);
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01007545
7546 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01007547 class_txn_ref = hlua_register_metatable(gL.T, CLASS_TXN);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007548
7549 /*
7550 *
7551 * Register class Socket
7552 *
7553 */
7554
7555 /* Create and fill the metatable. */
7556 lua_newtable(gL.T);
7557
7558 /* Create and fille the __index entry. */
7559 lua_pushstring(gL.T, "__index");
7560 lua_newtable(gL.T);
7561
Baptiste Assmann84bb4932015-03-02 21:40:06 +01007562#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007563 hlua_class_function(gL.T, "connect_ssl", hlua_socket_connect_ssl);
Baptiste Assmann84bb4932015-03-02 21:40:06 +01007564#endif
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007565 hlua_class_function(gL.T, "connect", hlua_socket_connect);
7566 hlua_class_function(gL.T, "send", hlua_socket_send);
7567 hlua_class_function(gL.T, "receive", hlua_socket_receive);
7568 hlua_class_function(gL.T, "close", hlua_socket_close);
7569 hlua_class_function(gL.T, "getpeername", hlua_socket_getpeername);
7570 hlua_class_function(gL.T, "getsockname", hlua_socket_getsockname);
7571 hlua_class_function(gL.T, "setoption", hlua_socket_setoption);
7572 hlua_class_function(gL.T, "settimeout", hlua_socket_settimeout);
7573
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02007574 lua_rawset(gL.T, -3); /* Push the last 2 entries in the table at index -3 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007575
7576 /* Register the garbage collector entry. */
7577 lua_pushstring(gL.T, "__gc");
7578 lua_pushcclosure(gL.T, hlua_socket_gc, 0);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02007579 lua_rawset(gL.T, -3); /* Push the last 2 entries in the table at index -3 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007580
7581 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01007582 class_socket_ref = hlua_register_metatable(gL.T, CLASS_SOCKET);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007583
7584 /* Proxy and server configuration initialisation. */
7585 memset(&socket_proxy, 0, sizeof(socket_proxy));
7586 init_new_proxy(&socket_proxy);
7587 socket_proxy.parent = NULL;
7588 socket_proxy.last_change = now.tv_sec;
7589 socket_proxy.id = "LUA-SOCKET";
7590 socket_proxy.cap = PR_CAP_FE | PR_CAP_BE;
7591 socket_proxy.maxconn = 0;
7592 socket_proxy.accept = NULL;
7593 socket_proxy.options2 |= PR_O2_INDEPSTR;
7594 socket_proxy.srv = NULL;
7595 socket_proxy.conn_retries = 0;
7596 socket_proxy.timeout.connect = 5000; /* By default the timeout connection is 5s. */
7597
7598 /* Init TCP server: unchanged parameters */
7599 memset(&socket_tcp, 0, sizeof(socket_tcp));
7600 socket_tcp.next = NULL;
7601 socket_tcp.proxy = &socket_proxy;
7602 socket_tcp.obj_type = OBJ_TYPE_SERVER;
7603 LIST_INIT(&socket_tcp.actconns);
7604 LIST_INIT(&socket_tcp.pendconns);
Willy Tarreau600802a2015-08-04 17:19:06 +02007605 LIST_INIT(&socket_tcp.priv_conns);
Willy Tarreau173a1c62015-08-05 10:31:57 +02007606 LIST_INIT(&socket_tcp.idle_conns);
Willy Tarreau7017cb02015-08-05 16:35:23 +02007607 LIST_INIT(&socket_tcp.safe_conns);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007608 socket_tcp.state = SRV_ST_RUNNING; /* early server setup */
7609 socket_tcp.last_change = 0;
7610 socket_tcp.id = "LUA-TCP-CONN";
7611 socket_tcp.check.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
7612 socket_tcp.agent.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
7613 socket_tcp.pp_opts = 0; /* Remove proxy protocol. */
7614
7615 /* XXX: Copy default parameter from default server,
7616 * but the default server is not initialized.
7617 */
7618 socket_tcp.maxqueue = socket_proxy.defsrv.maxqueue;
7619 socket_tcp.minconn = socket_proxy.defsrv.minconn;
7620 socket_tcp.maxconn = socket_proxy.defsrv.maxconn;
7621 socket_tcp.slowstart = socket_proxy.defsrv.slowstart;
7622 socket_tcp.onerror = socket_proxy.defsrv.onerror;
7623 socket_tcp.onmarkeddown = socket_proxy.defsrv.onmarkeddown;
7624 socket_tcp.onmarkedup = socket_proxy.defsrv.onmarkedup;
7625 socket_tcp.consecutive_errors_limit = socket_proxy.defsrv.consecutive_errors_limit;
7626 socket_tcp.uweight = socket_proxy.defsrv.iweight;
7627 socket_tcp.iweight = socket_proxy.defsrv.iweight;
7628
7629 socket_tcp.check.status = HCHK_STATUS_INI;
7630 socket_tcp.check.rise = socket_proxy.defsrv.check.rise;
7631 socket_tcp.check.fall = socket_proxy.defsrv.check.fall;
7632 socket_tcp.check.health = socket_tcp.check.rise; /* socket, but will fall down at first failure */
7633 socket_tcp.check.server = &socket_tcp;
7634
7635 socket_tcp.agent.status = HCHK_STATUS_INI;
7636 socket_tcp.agent.rise = socket_proxy.defsrv.agent.rise;
7637 socket_tcp.agent.fall = socket_proxy.defsrv.agent.fall;
7638 socket_tcp.agent.health = socket_tcp.agent.rise; /* socket, but will fall down at first failure */
7639 socket_tcp.agent.server = &socket_tcp;
7640
Willy Tarreaua261e9b2016-12-22 20:44:00 +01007641 socket_tcp.xprt = xprt_get(XPRT_RAW);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007642
7643#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007644 /* Init TCP server: unchanged parameters */
7645 memset(&socket_ssl, 0, sizeof(socket_ssl));
7646 socket_ssl.next = NULL;
7647 socket_ssl.proxy = &socket_proxy;
7648 socket_ssl.obj_type = OBJ_TYPE_SERVER;
7649 LIST_INIT(&socket_ssl.actconns);
7650 LIST_INIT(&socket_ssl.pendconns);
Willy Tarreau600802a2015-08-04 17:19:06 +02007651 LIST_INIT(&socket_ssl.priv_conns);
Willy Tarreau173a1c62015-08-05 10:31:57 +02007652 LIST_INIT(&socket_ssl.idle_conns);
Willy Tarreau7017cb02015-08-05 16:35:23 +02007653 LIST_INIT(&socket_ssl.safe_conns);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007654 socket_ssl.state = SRV_ST_RUNNING; /* early server setup */
7655 socket_ssl.last_change = 0;
7656 socket_ssl.id = "LUA-SSL-CONN";
7657 socket_ssl.check.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
7658 socket_ssl.agent.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
7659 socket_ssl.pp_opts = 0; /* Remove proxy protocol. */
7660
7661 /* XXX: Copy default parameter from default server,
7662 * but the default server is not initialized.
7663 */
7664 socket_ssl.maxqueue = socket_proxy.defsrv.maxqueue;
7665 socket_ssl.minconn = socket_proxy.defsrv.minconn;
7666 socket_ssl.maxconn = socket_proxy.defsrv.maxconn;
7667 socket_ssl.slowstart = socket_proxy.defsrv.slowstart;
7668 socket_ssl.onerror = socket_proxy.defsrv.onerror;
7669 socket_ssl.onmarkeddown = socket_proxy.defsrv.onmarkeddown;
7670 socket_ssl.onmarkedup = socket_proxy.defsrv.onmarkedup;
7671 socket_ssl.consecutive_errors_limit = socket_proxy.defsrv.consecutive_errors_limit;
7672 socket_ssl.uweight = socket_proxy.defsrv.iweight;
7673 socket_ssl.iweight = socket_proxy.defsrv.iweight;
7674
7675 socket_ssl.check.status = HCHK_STATUS_INI;
7676 socket_ssl.check.rise = socket_proxy.defsrv.check.rise;
7677 socket_ssl.check.fall = socket_proxy.defsrv.check.fall;
7678 socket_ssl.check.health = socket_ssl.check.rise; /* socket, but will fall down at first failure */
7679 socket_ssl.check.server = &socket_ssl;
7680
7681 socket_ssl.agent.status = HCHK_STATUS_INI;
7682 socket_ssl.agent.rise = socket_proxy.defsrv.agent.rise;
7683 socket_ssl.agent.fall = socket_proxy.defsrv.agent.fall;
7684 socket_ssl.agent.health = socket_ssl.agent.rise; /* socket, but will fall down at first failure */
7685 socket_ssl.agent.server = &socket_ssl;
7686
Thierry FOURNIER36d13742015-03-17 16:48:53 +01007687 socket_ssl.use_ssl = 1;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01007688 socket_ssl.xprt = xprt_get(XPRT_SSL);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007689
Thierry FOURNIER36d13742015-03-17 16:48:53 +01007690 for (idx = 0; args[idx] != NULL; idx++) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007691 if ((kw = srv_find_kw(args[idx])) != NULL) { /* Maybe it's registered server keyword */
7692 /*
7693 *
7694 * If the keyword is not known, we can search in the registered
7695 * server keywords. This is usefull to configure special SSL
7696 * features like client certificates and ssl_verify.
7697 *
7698 */
7699 tmp_error = kw->parse(args, &idx, &socket_proxy, &socket_ssl, &error);
7700 if (tmp_error != 0) {
7701 fprintf(stderr, "INTERNAL ERROR: %s\n", error);
7702 abort(); /* This must be never arrives because the command line
7703 not editable by the user. */
7704 }
7705 idx += kw->skip;
7706 }
7707 }
7708
7709 /* Initialize SSL server. */
Willy Tarreau17d45382016-12-22 21:16:08 +01007710 if (socket_ssl.xprt->prepare_srv)
7711 socket_ssl.xprt->prepare_srv(&socket_ssl);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01007712#endif
Thierry Fournier75933d42016-01-21 09:30:18 +01007713
7714 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +01007715}
Willy Tarreaubb57d942016-12-21 19:04:56 +01007716
7717__attribute__((constructor))
7718static void __hlua_init(void)
7719{
7720 char *ptr = NULL;
7721 memprintf(&ptr, "Built with Lua version : %s", LUA_RELEASE);
7722 hap_register_build_opts(ptr, 1);
7723}