blob: 693ea3140b9f5560494e2c52e41db220215183a0 [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>
Mark Lakes56cc1252018-03-27 09:48:06 +020014#include <limits.h>
Thierry FOURNIERbabae282015-09-17 11:36:37 +020015#include <setjmp.h>
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +010016
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +010017#include <lauxlib.h>
18#include <lua.h>
19#include <lualib.h>
20
Thierry FOURNIER463119c2015-03-10 00:35:36 +010021#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 503
22#error "Requires Lua 5.3 or later."
Cyril Bontédc0306e2015-03-02 00:08:40 +010023#endif
24
Thierry FOURNIER380d0932015-01-23 14:27:52 +010025#include <ebpttree.h>
26
27#include <common/cfgparse.h>
Willy Tarreaub059b892018-10-16 17:57:36 +020028#include <common/compiler.h>
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +020029#include <common/hathreads.h>
Willy Tarreau0108d902018-11-25 19:14:37 +010030#include <common/initcall.h>
31#include <common/xref.h>
Christopher Faulet724a12c2018-12-13 22:12:15 +010032#include <common/h1.h>
Thierry FOURNIER380d0932015-01-23 14:27:52 +010033
William Lallemand9ed62032016-11-21 17:49:11 +010034#include <types/cli.h>
Thierry FOURNIER380d0932015-01-23 14:27:52 +010035#include <types/hlua.h>
36#include <types/proxy.h>
William Lallemand9ed62032016-11-21 17:49:11 +010037#include <types/stats.h>
Thierry FOURNIER380d0932015-01-23 14:27:52 +010038
Thierry FOURNIER55da1652015-01-23 11:36:30 +010039#include <proto/arg.h>
Willy Tarreau8a8d83b2015-04-13 13:24:54 +020040#include <proto/applet.h>
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010041#include <proto/channel.h>
William Lallemand9ed62032016-11-21 17:49:11 +010042#include <proto/cli.h>
Willy Tarreaua71f6422016-11-16 17:00:14 +010043#include <proto/connection.h>
William Lallemand9ed62032016-11-21 17:49:11 +010044#include <proto/stats.h>
Thierry FOURNIER9a819e72015-02-16 20:22:55 +010045#include <proto/hdr_idx.h>
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +010046#include <proto/hlua.h>
Thierry Fournierfb0b5462016-01-21 09:28:58 +010047#include <proto/hlua_fcn.h>
Willy Tarreau79e57332018-10-02 16:01:16 +020048#include <proto/http_fetch.h>
Christopher Faulet724a12c2018-12-13 22:12:15 +010049#include <proto/http_htx.h>
Willy Tarreau61c112a2018-10-02 16:43:32 +020050#include <proto/http_rules.h>
Thierry FOURNIER3def3932015-04-07 11:27:54 +020051#include <proto/map.h>
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010052#include <proto/obj_type.h>
Patrick Hemmer268a7072018-05-11 12:52:31 -040053#include <proto/queue.h>
Thierry FOURNIER83758bb2015-02-04 13:21:04 +010054#include <proto/pattern.h>
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +010055#include <proto/payload.h>
56#include <proto/proto_http.h>
57#include <proto/sample.h>
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010058#include <proto/server.h>
Willy Tarreaufeb76402015-04-03 14:10:06 +020059#include <proto/session.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020060#include <proto/stream.h>
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010061#include <proto/stream_interface.h>
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +010062#include <proto/task.h>
Willy Tarreau39713102016-11-25 15:49:32 +010063#include <proto/tcp_rules.h>
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +020064#include <proto/vars.h>
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +010065
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +010066/* Lua uses longjmp to perform yield or throwing errors. This
67 * macro is used only for identifying the function that can
68 * not return because a longjmp is executed.
69 * __LJMP marks a prototype of hlua file that can use longjmp.
70 * WILL_LJMP() marks an lua function that will use longjmp.
71 * MAY_LJMP() marks an lua function that may use longjmp.
72 */
73#define __LJMP
Willy Tarreau4e7cc332018-10-20 17:45:48 +020074#define WILL_LJMP(func) do { func; my_unreachable(); } while(0)
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +010075#define MAY_LJMP(func) func
76
Thierry FOURNIERbabae282015-09-17 11:36:37 +020077/* This couple of function executes securely some Lua calls outside of
78 * the lua runtime environment. Each Lua call can return a longjmp
79 * if it encounter a memory error.
80 *
81 * Lua documentation extract:
82 *
83 * If an error happens outside any protected environment, Lua calls
84 * a panic function (see lua_atpanic) and then calls abort, thus
85 * exiting the host application. Your panic function can avoid this
86 * exit by never returning (e.g., doing a long jump to your own
87 * recovery point outside Lua).
88 *
89 * The panic function runs as if it were a message handler (see
90 * §2.3); in particular, the error message is at the top of the
91 * stack. However, there is no guarantee about stack space. To push
92 * anything on the stack, the panic function must first check the
93 * available space (see §4.2).
94 *
95 * We must check all the Lua entry point. This includes:
96 * - The include/proto/hlua.h exported functions
97 * - the task wrapper function
98 * - The action wrapper function
99 * - The converters wrapper function
100 * - The sample-fetch wrapper functions
101 *
102 * It is tolerated that the initilisation function returns an abort.
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -0800103 * Before each Lua abort, an error message is written on stderr.
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200104 *
105 * The macro SET_SAFE_LJMP initialise the longjmp. The Macro
106 * RESET_SAFE_LJMP reset the longjmp. These function must be macro
107 * because they must be exists in the program stack when the longjmp
108 * is called.
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +0200109 *
110 * Note that the Lua processing is not really thread safe. It provides
111 * heavy system which consists to add our own lock function in the Lua
112 * code and recompile the library. This system will probably not accepted
113 * by maintainers of various distribs.
114 *
115 * Our main excution point of the Lua is the function lua_resume(). A
116 * quick looking on the Lua sources displays a lua_lock() a the start
117 * of function and a lua_unlock() at the end of the function. So I
118 * conclude that the Lua thread safe mode just perform a mutex around
119 * all execution. So I prefer to do this in the HAProxy code, it will be
120 * easier for distro maintainers.
121 *
122 * Note that the HAProxy lua functions rounded by the macro SET_SAFE_LJMP
123 * and RESET_SAFE_LJMP manipulates the Lua stack, so it will be careful
124 * to set mutex around these functions.
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200125 */
Willy Tarreau86abe442018-11-25 20:12:18 +0100126__decl_spinlock(hlua_global_lock);
Thierry FOURNIERffbad792017-07-12 11:39:04 +0200127THREAD_LOCAL jmp_buf safe_ljmp_env;
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200128static int hlua_panic_safe(lua_State *L) { return 0; }
129static int hlua_panic_ljmp(lua_State *L) { longjmp(safe_ljmp_env, 1); }
130
131#define SET_SAFE_LJMP(__L) \
132 ({ \
133 int ret; \
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100134 HA_SPIN_LOCK(LUA_LOCK, &hlua_global_lock); \
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200135 if (setjmp(safe_ljmp_env) != 0) { \
136 lua_atpanic(__L, hlua_panic_safe); \
137 ret = 0; \
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100138 HA_SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock); \
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200139 } else { \
140 lua_atpanic(__L, hlua_panic_ljmp); \
141 ret = 1; \
142 } \
143 ret; \
144 })
145
146/* If we are the last function catching Lua errors, we
147 * must reset the panic function.
148 */
149#define RESET_SAFE_LJMP(__L) \
150 do { \
151 lua_atpanic(__L, hlua_panic_safe); \
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100152 HA_SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock); \
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200153 } while(0)
154
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200155/* Applet status flags */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200156#define APPLET_DONE 0x01 /* applet processing is done. */
Christopher Faulet18c2e8d2019-03-01 12:02:08 +0100157/* unused: 0x02 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200158#define APPLET_HDR_SENT 0x04 /* Response header sent. */
159#define APPLET_CHUNKED 0x08 /* Use transfer encoding chunked. */
160#define APPLET_LAST_CHK 0x10 /* Last chunk sent. */
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +0100161#define APPLET_HTTP11 0x20 /* Last chunk sent. */
Christopher Faulet56a3d6e2019-02-27 22:06:23 +0100162#define APPLET_RSP_SENT 0x40 /* The response was fully sent */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200163
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100164/* The main Lua execution context. */
165struct hlua gL;
166
Thierry FOURNIERebed6e92016-12-16 11:54:07 +0100167/* This is the memory pool containing struct lua for applets
168 * (including cli).
169 */
Willy Tarreau8ceae722018-11-26 11:58:30 +0100170DECLARE_STATIC_POOL(pool_head_hlua, "hlua", sizeof(struct hlua));
Thierry FOURNIERebed6e92016-12-16 11:54:07 +0100171
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +0100172/* Used for Socket connection. */
173static struct proxy socket_proxy;
174static struct server socket_tcp;
175#ifdef USE_OPENSSL
176static struct server socket_ssl;
177#endif
178
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +0100179/* List head of the function called at the initialisation time. */
180struct list hlua_init_functions = LIST_HEAD_INIT(hlua_init_functions);
181
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +0100182/* The following variables contains the reference of the different
183 * Lua classes. These references are useful for identify metadata
184 * associated with an object.
185 */
Thierry FOURNIER65f34c62015-02-16 20:11:43 +0100186static int class_txn_ref;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +0100187static int class_socket_ref;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +0100188static int class_channel_ref;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +0100189static int class_fetches_ref;
Thierry FOURNIER594afe72015-03-10 23:58:30 +0100190static int class_converters_ref;
Thierry FOURNIER08504f42015-03-16 14:17:08 +0100191static int class_http_ref;
Thierry FOURNIER3def3932015-04-07 11:27:54 +0200192static int class_map_ref;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200193static int class_applet_tcp_ref;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200194static int class_applet_http_ref;
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +0100195
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100196/* Global Lua execution timeout. By default Lua, execution linked
Willy Tarreau87b09662015-04-03 00:22:06 +0200197 * with stream (actions, sample-fetches and converters) have a
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100198 * short timeout. Lua linked with tasks doesn't have a timeout
199 * because a task may remain alive during all the haproxy execution.
200 */
201static unsigned int hlua_timeout_session = 4000; /* session timeout. */
202static unsigned int hlua_timeout_task = TICK_ETERNITY; /* task timeout. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200203static unsigned int hlua_timeout_applet = 4000; /* applet timeout. */
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100204
Thierry FOURNIERee9f8022015-03-03 17:37:37 +0100205/* Interrupts the Lua processing each "hlua_nb_instruction" instructions.
206 * it is used for preventing infinite loops.
207 *
208 * I test the scheer with an infinite loop containing one incrementation
209 * and one test. I run this loop between 10 seconds, I raise a ceil of
210 * 710M loops from one interrupt each 9000 instructions, so I fix the value
211 * to one interrupt each 10 000 instructions.
212 *
213 * configured | Number of
214 * instructions | loops executed
215 * between two | in milions
216 * forced yields |
217 * ---------------+---------------
218 * 10 | 160
219 * 500 | 670
220 * 1000 | 680
221 * 5000 | 700
222 * 7000 | 700
223 * 8000 | 700
224 * 9000 | 710 <- ceil
225 * 10000 | 710
226 * 100000 | 710
227 * 1000000 | 710
228 *
229 */
230static unsigned int hlua_nb_instruction = 10000;
231
Willy Tarreau32f61e22015-03-18 17:54:59 +0100232/* Descriptor for the memory allocation state. If limit is not null, it will
233 * be enforced on any memory allocation.
234 */
235struct hlua_mem_allocator {
236 size_t allocated;
237 size_t limit;
238};
239
240static struct hlua_mem_allocator hlua_global_allocator;
241
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200242static const char error_500[] =
Jarno Huuskonen16ad94a2017-01-09 14:17:10 +0200243 "HTTP/1.0 500 Internal Server Error\r\n"
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200244 "Cache-Control: no-cache\r\n"
245 "Connection: close\r\n"
246 "Content-Type: text/html\r\n"
247 "\r\n"
Joseph Herlant7fe15772018-11-15 10:07:32 -0800248 "<html><body><h1>500 Internal Server Error</h1>\nAn internal server error occurred.\n</body></html>\n";
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200249
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100250/* These functions converts types between HAProxy internal args or
251 * sample and LUA types. Another function permits to check if the
252 * LUA stack contains arguments according with an required ARG_T
253 * format.
254 */
255static int hlua_arg2lua(lua_State *L, const struct arg *arg);
256static int hlua_lua2arg(lua_State *L, int ud, struct arg *arg);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100257__LJMP static int hlua_lua2arg_check(lua_State *L, int first, struct arg *argp,
David Carlier0c437f42016-04-27 16:21:56 +0100258 uint64_t mask, struct proxy *p);
Willy Tarreau5eadada2015-03-10 17:28:54 +0100259static int hlua_smp2lua(lua_State *L, struct sample *smp);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100260static int hlua_smp2lua_str(lua_State *L, struct sample *smp);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100261static int hlua_lua2smp(lua_State *L, int ud, struct sample *smp);
262
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200263__LJMP static int hlua_http_get_headers(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg);
264
Thierry FOURNIER23bc3752015-09-11 19:15:43 +0200265#define SEND_ERR(__be, __fmt, __args...) \
266 do { \
267 send_log(__be, LOG_ERR, __fmt, ## __args); \
268 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) \
Christopher Faulet767a84b2017-11-24 16:50:31 +0100269 ha_alert(__fmt, ## __args); \
Thierry FOURNIER23bc3752015-09-11 19:15:43 +0200270 } while (0)
271
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100272/* Used to check an Lua function type in the stack. It creates and
273 * returns a reference of the function. This function throws an
274 * error if the rgument is not a "function".
275 */
276__LJMP unsigned int hlua_checkfunction(lua_State *L, int argno)
277{
278 if (!lua_isfunction(L, argno)) {
Thierry FOURNIERfd1e9552018-02-23 18:41:18 +0100279 const char *msg = lua_pushfstring(L, "function expected, got %s", luaL_typename(L, argno));
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100280 WILL_LJMP(luaL_argerror(L, argno, msg));
281 }
282 lua_pushvalue(L, argno);
283 return luaL_ref(L, LUA_REGISTRYINDEX);
284}
285
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200286/* Return the string that is of the top of the stack. */
287const char *hlua_get_top_error_string(lua_State *L)
288{
289 if (lua_gettop(L) < 1)
290 return "unknown error";
291 if (lua_type(L, -1) != LUA_TSTRING)
292 return "unknown error";
293 return lua_tostring(L, -1);
294}
295
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200296__LJMP static const char *hlua_traceback(lua_State *L)
297{
298 lua_Debug ar;
299 int level = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +0200300 struct buffer *msg = get_trash_chunk();
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200301 int filled = 0;
302
303 while (lua_getstack(L, level++, &ar)) {
304
305 /* Add separator */
306 if (filled)
307 chunk_appendf(msg, ", ");
308 filled = 1;
309
310 /* Fill fields:
311 * 'S': fills in the fields source, short_src, linedefined, lastlinedefined, and what;
312 * 'l': fills in the field currentline;
313 * 'n': fills in the field name and namewhat;
314 * 't': fills in the field istailcall;
315 */
316 lua_getinfo(L, "Slnt", &ar);
317
318 /* Append code localisation */
319 if (ar.currentline > 0)
320 chunk_appendf(msg, "%s:%d ", ar.short_src, ar.currentline);
321 else
322 chunk_appendf(msg, "%s ", ar.short_src);
323
324 /*
325 * Get function name
326 *
327 * if namewhat is no empty, name is defined.
328 * what contains "Lua" for Lua function, "C" for C function,
329 * or "main" for main code.
330 */
331 if (*ar.namewhat != '\0' && ar.name != NULL) /* is there a name from code? */
332 chunk_appendf(msg, "%s '%s'", ar.namewhat, ar.name); /* use it */
333
334 else if (*ar.what == 'm') /* "main", the code is not executed in a function */
335 chunk_appendf(msg, "main chunk");
336
337 else if (*ar.what != 'C') /* for Lua functions, use <file:line> */
338 chunk_appendf(msg, "C function line %d", ar.linedefined);
339
340 else /* nothing left... */
341 chunk_appendf(msg, "?");
342
343
344 /* Display tailed call */
345 if (ar.istailcall)
346 chunk_appendf(msg, " ...");
347 }
348
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200349 return msg->area;
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200350}
351
352
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100353/* This function check the number of arguments available in the
354 * stack. If the number of arguments available is not the same
355 * then <nb> an error is throwed.
356 */
357__LJMP static inline void check_args(lua_State *L, int nb, char *fcn)
358{
359 if (lua_gettop(L) == nb)
360 return;
361 WILL_LJMP(luaL_error(L, "'%s' needs %d arguments", fcn, nb));
362}
363
Mark Lakes22154b42018-01-29 14:38:40 -0800364/* This function pushes an error string prefixed by the file name
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100365 * and the line number where the error is encountered.
366 */
367static int hlua_pusherror(lua_State *L, const char *fmt, ...)
368{
369 va_list argp;
370 va_start(argp, fmt);
371 luaL_where(L, 1);
372 lua_pushvfstring(L, fmt, argp);
373 va_end(argp);
374 lua_concat(L, 2);
375 return 1;
376}
377
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100378/* This functions is used with sample fetch and converters. It
379 * converts the HAProxy configuration argument in a lua stack
380 * values.
381 *
382 * It takes an array of "arg", and each entry of the array is
383 * converted and pushed in the LUA stack.
384 */
385static int hlua_arg2lua(lua_State *L, const struct arg *arg)
386{
387 switch (arg->type) {
388 case ARGT_SINT:
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100389 case ARGT_TIME:
390 case ARGT_SIZE:
Thierry FOURNIERf90838b2015-03-06 13:48:32 +0100391 lua_pushinteger(L, arg->data.sint);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100392 break;
393
394 case ARGT_STR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200395 lua_pushlstring(L, arg->data.str.area, arg->data.str.data);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100396 break;
397
398 case ARGT_IPV4:
399 case ARGT_IPV6:
400 case ARGT_MSK4:
401 case ARGT_MSK6:
402 case ARGT_FE:
403 case ARGT_BE:
404 case ARGT_TAB:
405 case ARGT_SRV:
406 case ARGT_USR:
407 case ARGT_MAP:
408 default:
409 lua_pushnil(L);
410 break;
411 }
412 return 1;
413}
414
415/* This function take one entrie in an LUA stack at the index "ud",
416 * and try to convert it in an HAProxy argument entry. This is useful
417 * with sample fetch wrappers. The input arguments are gived to the
418 * lua wrapper and converted as arg list by thi function.
419 */
420static int hlua_lua2arg(lua_State *L, int ud, struct arg *arg)
421{
422 switch (lua_type(L, ud)) {
423
424 case LUA_TNUMBER:
425 case LUA_TBOOLEAN:
426 arg->type = ARGT_SINT;
427 arg->data.sint = lua_tointeger(L, ud);
428 break;
429
430 case LUA_TSTRING:
431 arg->type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200432 arg->data.str.area = (char *)lua_tolstring(L, ud, (size_t *)&arg->data.str.data);
Tim Duesterhusf371b832019-09-29 23:03:07 +0200433 /* We don't know the actual size of the underlying allocation, so be conservative. */
434 arg->data.str.size = arg->data.str.data;
435 arg->data.str.head = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100436 break;
437
438 case LUA_TUSERDATA:
439 case LUA_TNIL:
440 case LUA_TTABLE:
441 case LUA_TFUNCTION:
442 case LUA_TTHREAD:
443 case LUA_TLIGHTUSERDATA:
444 arg->type = ARGT_SINT;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +0200445 arg->data.sint = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100446 break;
447 }
448 return 1;
449}
450
451/* the following functions are used to convert a struct sample
452 * in Lua type. This useful to convert the return of the
453 * fetchs or converters.
454 */
Willy Tarreau5eadada2015-03-10 17:28:54 +0100455static int hlua_smp2lua(lua_State *L, struct sample *smp)
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100456{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200457 switch (smp->data.type) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100458 case SMP_T_SINT:
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100459 case SMP_T_BOOL:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200460 lua_pushinteger(L, smp->data.u.sint);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100461 break;
462
463 case SMP_T_BIN:
464 case SMP_T_STR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200465 lua_pushlstring(L, smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100466 break;
467
468 case SMP_T_METH:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200469 switch (smp->data.u.meth.meth) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100470 case HTTP_METH_OPTIONS: lua_pushstring(L, "OPTIONS"); break;
471 case HTTP_METH_GET: lua_pushstring(L, "GET"); break;
472 case HTTP_METH_HEAD: lua_pushstring(L, "HEAD"); break;
473 case HTTP_METH_POST: lua_pushstring(L, "POST"); break;
474 case HTTP_METH_PUT: lua_pushstring(L, "PUT"); break;
475 case HTTP_METH_DELETE: lua_pushstring(L, "DELETE"); break;
476 case HTTP_METH_TRACE: lua_pushstring(L, "TRACE"); break;
477 case HTTP_METH_CONNECT: lua_pushstring(L, "CONNECT"); break;
478 case HTTP_METH_OTHER:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200479 lua_pushlstring(L, smp->data.u.meth.str.area, smp->data.u.meth.str.data);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100480 break;
481 default:
482 lua_pushnil(L);
483 break;
484 }
485 break;
486
487 case SMP_T_IPV4:
488 case SMP_T_IPV6:
489 case SMP_T_ADDR: /* This type is never used to qualify a sample. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200490 if (sample_casts[smp->data.type][SMP_T_STR] &&
491 sample_casts[smp->data.type][SMP_T_STR](smp))
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200492 lua_pushlstring(L, smp->data.u.str.area, smp->data.u.str.data);
Willy Tarreau5eadada2015-03-10 17:28:54 +0100493 else
494 lua_pushnil(L);
495 break;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100496 default:
497 lua_pushnil(L);
498 break;
499 }
500 return 1;
501}
502
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100503/* the following functions are used to convert a struct sample
504 * in Lua strings. This is useful to convert the return of the
505 * fetchs or converters.
506 */
507static int hlua_smp2lua_str(lua_State *L, struct sample *smp)
508{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200509 switch (smp->data.type) {
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100510
511 case SMP_T_BIN:
512 case SMP_T_STR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200513 lua_pushlstring(L, smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100514 break;
515
516 case SMP_T_METH:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200517 switch (smp->data.u.meth.meth) {
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100518 case HTTP_METH_OPTIONS: lua_pushstring(L, "OPTIONS"); break;
519 case HTTP_METH_GET: lua_pushstring(L, "GET"); break;
520 case HTTP_METH_HEAD: lua_pushstring(L, "HEAD"); break;
521 case HTTP_METH_POST: lua_pushstring(L, "POST"); break;
522 case HTTP_METH_PUT: lua_pushstring(L, "PUT"); break;
523 case HTTP_METH_DELETE: lua_pushstring(L, "DELETE"); break;
524 case HTTP_METH_TRACE: lua_pushstring(L, "TRACE"); break;
525 case HTTP_METH_CONNECT: lua_pushstring(L, "CONNECT"); break;
526 case HTTP_METH_OTHER:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200527 lua_pushlstring(L, smp->data.u.meth.str.area, smp->data.u.meth.str.data);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100528 break;
529 default:
530 lua_pushstring(L, "");
531 break;
532 }
533 break;
534
535 case SMP_T_SINT:
536 case SMP_T_BOOL:
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100537 case SMP_T_IPV4:
538 case SMP_T_IPV6:
539 case SMP_T_ADDR: /* This type is never used to qualify a sample. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200540 if (sample_casts[smp->data.type][SMP_T_STR] &&
541 sample_casts[smp->data.type][SMP_T_STR](smp))
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200542 lua_pushlstring(L, smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100543 else
544 lua_pushstring(L, "");
545 break;
546 default:
547 lua_pushstring(L, "");
548 break;
549 }
550 return 1;
551}
552
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100553/* the following functions are used to convert an Lua type in a
554 * struct sample. This is useful to provide data from a converter
555 * to the LUA code.
556 */
557static int hlua_lua2smp(lua_State *L, int ud, struct sample *smp)
558{
559 switch (lua_type(L, ud)) {
560
561 case LUA_TNUMBER:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200562 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200563 smp->data.u.sint = lua_tointeger(L, ud);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100564 break;
565
566
567 case LUA_TBOOLEAN:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200568 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200569 smp->data.u.sint = lua_toboolean(L, ud);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100570 break;
571
572 case LUA_TSTRING:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200573 smp->data.type = SMP_T_STR;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100574 smp->flags |= SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200575 smp->data.u.str.area = (char *)lua_tolstring(L, ud, (size_t *)&smp->data.u.str.data);
Tim Duesterhusf371b832019-09-29 23:03:07 +0200576 /* We don't know the actual size of the underlying allocation, so be conservative. */
577 smp->data.u.str.size = smp->data.u.str.data;
578 smp->data.u.str.head = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100579 break;
580
581 case LUA_TUSERDATA:
582 case LUA_TNIL:
583 case LUA_TTABLE:
584 case LUA_TFUNCTION:
585 case LUA_TTHREAD:
586 case LUA_TLIGHTUSERDATA:
Thierry FOURNIER93405e12015-08-26 14:19:03 +0200587 case LUA_TNONE:
588 default:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200589 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200590 smp->data.u.sint = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100591 break;
592 }
593 return 1;
594}
595
596/* This function check the "argp" builded by another conversion function
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -0800597 * is in accord with the expected argp defined by the "mask". The function
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100598 * returns true or false. It can be adjust the types if there compatibles.
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100599 *
600 * This function assumes thant the argp argument contains ARGM_NBARGS + 1
601 * entries.
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100602 */
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100603__LJMP int hlua_lua2arg_check(lua_State *L, int first, struct arg *argp,
David Carlier0c437f42016-04-27 16:21:56 +0100604 uint64_t mask, struct proxy *p)
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100605{
606 int min_arg;
607 int idx;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100608 struct proxy *px;
609 char *sname, *pname;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100610
611 idx = 0;
612 min_arg = ARGM(mask);
613 mask >>= ARGM_BITS;
614
615 while (1) {
616
617 /* Check oversize. */
618 if (idx >= ARGM_NBARGS && argp[idx].type != ARGT_STOP) {
Cyril Bonté577a36a2015-03-02 00:08:38 +0100619 WILL_LJMP(luaL_argerror(L, first + idx, "Malformed argument mask"));
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100620 }
621
622 /* Check for mandatory arguments. */
623 if (argp[idx].type == ARGT_STOP) {
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100624 if (idx < min_arg) {
625
626 /* If miss other argument than the first one, we return an error. */
627 if (idx > 0)
628 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
629
630 /* If first argument have a certain type, some default values
631 * may be used. See the function smp_resolve_args().
632 */
633 switch (mask & ARGT_MASK) {
634
635 case ARGT_FE:
636 if (!(p->cap & PR_CAP_FE))
637 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
638 argp[idx].data.prx = p;
639 argp[idx].type = ARGT_FE;
640 argp[idx+1].type = ARGT_STOP;
641 break;
642
643 case ARGT_BE:
644 if (!(p->cap & PR_CAP_BE))
645 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
646 argp[idx].data.prx = p;
647 argp[idx].type = ARGT_BE;
648 argp[idx+1].type = ARGT_STOP;
649 break;
650
651 case ARGT_TAB:
652 argp[idx].data.prx = p;
653 argp[idx].type = ARGT_TAB;
654 argp[idx+1].type = ARGT_STOP;
655 break;
656
657 default:
658 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
659 break;
660 }
661 }
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100662 return 0;
663 }
664
665 /* Check for exceed the number of requiered argument. */
666 if ((mask & ARGT_MASK) == ARGT_STOP &&
667 argp[idx].type != ARGT_STOP) {
668 WILL_LJMP(luaL_argerror(L, first + idx, "Last argument expected"));
669 }
670
671 if ((mask & ARGT_MASK) == ARGT_STOP &&
672 argp[idx].type == ARGT_STOP) {
673 return 0;
674 }
675
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100676 /* Convert some argument types. */
677 switch (mask & ARGT_MASK) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100678 case ARGT_SINT:
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100679 if (argp[idx].type != ARGT_SINT)
680 WILL_LJMP(luaL_argerror(L, first + idx, "integer expected"));
681 argp[idx].type = ARGT_SINT;
682 break;
683
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100684 case ARGT_TIME:
685 if (argp[idx].type != ARGT_SINT)
686 WILL_LJMP(luaL_argerror(L, first + idx, "integer expected"));
Thierry FOURNIER29176f32015-07-07 00:41:29 +0200687 argp[idx].type = ARGT_TIME;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100688 break;
689
690 case ARGT_SIZE:
691 if (argp[idx].type != ARGT_SINT)
692 WILL_LJMP(luaL_argerror(L, first + idx, "integer expected"));
Thierry FOURNIER29176f32015-07-07 00:41:29 +0200693 argp[idx].type = ARGT_SIZE;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100694 break;
695
696 case ARGT_FE:
697 if (argp[idx].type != ARGT_STR)
698 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200699 memcpy(trash.area, argp[idx].data.str.area,
700 argp[idx].data.str.data);
701 trash.area[argp[idx].data.str.data] = 0;
702 argp[idx].data.prx = proxy_fe_by_name(trash.area);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100703 if (!argp[idx].data.prx)
704 WILL_LJMP(luaL_argerror(L, first + idx, "frontend doesn't exist"));
705 argp[idx].type = ARGT_FE;
706 break;
707
708 case ARGT_BE:
709 if (argp[idx].type != ARGT_STR)
710 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200711 memcpy(trash.area, argp[idx].data.str.area,
712 argp[idx].data.str.data);
713 trash.area[argp[idx].data.str.data] = 0;
714 argp[idx].data.prx = proxy_be_by_name(trash.area);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100715 if (!argp[idx].data.prx)
716 WILL_LJMP(luaL_argerror(L, first + idx, "backend doesn't exist"));
717 argp[idx].type = ARGT_BE;
718 break;
719
720 case ARGT_TAB:
721 if (argp[idx].type != ARGT_STR)
722 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200723 memcpy(trash.area, argp[idx].data.str.area,
724 argp[idx].data.str.data);
725 trash.area[argp[idx].data.str.data] = 0;
Tim Duesterhuse351e762019-09-29 23:03:09 +0200726 argp[idx].data.t = stktable_find_by_name(trash.area);
727 if (!argp[idx].data.t)
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100728 WILL_LJMP(luaL_argerror(L, first + idx, "table doesn't exist"));
729 argp[idx].type = ARGT_TAB;
730 break;
731
732 case ARGT_SRV:
733 if (argp[idx].type != ARGT_STR)
734 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200735 memcpy(trash.area, argp[idx].data.str.area,
736 argp[idx].data.str.data);
737 trash.area[argp[idx].data.str.data] = 0;
738 sname = strrchr(trash.area, '/');
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100739 if (sname) {
740 *sname++ = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200741 pname = trash.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +0200742 px = proxy_be_by_name(pname);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100743 if (!px)
744 WILL_LJMP(luaL_argerror(L, first + idx, "backend doesn't exist"));
745 }
746 else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200747 sname = trash.area;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100748 px = p;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100749 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100750 argp[idx].data.srv = findserver(px, sname);
751 if (!argp[idx].data.srv)
752 WILL_LJMP(luaL_argerror(L, first + idx, "server doesn't exist"));
753 argp[idx].type = ARGT_SRV;
754 break;
755
756 case ARGT_IPV4:
Christopher Faulete7f1fcf2020-08-07 09:07:26 +0200757 if (argp[idx].type != ARGT_STR)
758 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200759 memcpy(trash.area, argp[idx].data.str.area,
760 argp[idx].data.str.data);
761 trash.area[argp[idx].data.str.data] = 0;
762 if (inet_pton(AF_INET, trash.area, &argp[idx].data.ipv4))
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100763 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv4 address"));
764 argp[idx].type = ARGT_IPV4;
765 break;
766
767 case ARGT_MSK4:
Christopher Fauletff8de2c2020-08-07 09:11:22 +0200768 if (argp[idx].type == ARGT_SINT)
769 len2mask4(argp[idx].data.sint, &argp[idx].data.ipv4);
770 else if (argp[idx].type == ARGT_STR) {
771 memcpy(trash.area, argp[idx].data.str.area,
772 argp[idx].data.str.data);
773 trash.area[argp[idx].data.str.data] = 0;
774 if (!str2mask(trash.area, &argp[idx].data.ipv4))
775 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv4 mask"));
776 }
777 else
778 WILL_LJMP(luaL_argerror(L, first + idx, "integer or string expected"));
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100779 argp[idx].type = ARGT_MSK4;
780 break;
781
782 case ARGT_IPV6:
Christopher Faulete7f1fcf2020-08-07 09:07:26 +0200783 if (argp[idx].type != ARGT_STR)
784 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200785 memcpy(trash.area, argp[idx].data.str.area,
786 argp[idx].data.str.data);
787 trash.area[argp[idx].data.str.data] = 0;
788 if (inet_pton(AF_INET6, trash.area, &argp[idx].data.ipv6))
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100789 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv6 address"));
790 argp[idx].type = ARGT_IPV6;
791 break;
792
793 case ARGT_MSK6:
Christopher Fauletff8de2c2020-08-07 09:11:22 +0200794 if (argp[idx].type == ARGT_SINT)
795 len2mask6(argp[idx].data.sint, &argp[idx].data.ipv6);
796 else if (argp[idx].type == ARGT_STR) {
797 memcpy(trash.area, argp[idx].data.str.area,
798 argp[idx].data.str.data);
799 trash.area[argp[idx].data.str.data] = 0;
800 if (!str2mask6(trash.area, &argp[idx].data.ipv6))
801 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv6 mask"));
802 }
803 else
804 WILL_LJMP(luaL_argerror(L, first + idx, "integer or string expected"));
Tim Duesterhusb814da62018-01-25 16:24:50 +0100805 argp[idx].type = ARGT_MSK6;
806 break;
807
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100808 case ARGT_MAP:
809 case ARGT_REG:
810 case ARGT_USR:
811 WILL_LJMP(luaL_argerror(L, first + idx, "type not yet supported"));
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100812 break;
813 }
814
815 /* Check for type of argument. */
816 if ((mask & ARGT_MASK) != argp[idx].type) {
817 const char *msg = lua_pushfstring(L, "'%s' expected, got '%s'",
818 arg_type_names[(mask & ARGT_MASK)],
819 arg_type_names[argp[idx].type & ARGT_MASK]);
820 WILL_LJMP(luaL_argerror(L, first + idx, msg));
821 }
822
823 /* Next argument. */
824 mask >>= ARGT_BITS;
825 idx++;
826 }
827}
828
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100829/*
830 * The following functions are used to make correspondance between the the
831 * executed lua pointer and the "struct hlua *" that contain the context.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100832 *
833 * - hlua_gethlua : return the hlua context associated with an lua_State.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100834 * - hlua_sethlua : create the association between hlua context and lua_state.
835 */
836static inline struct hlua *hlua_gethlua(lua_State *L)
837{
Thierry FOURNIER38c5fd62015-03-10 02:40:29 +0100838 struct hlua **hlua = lua_getextraspace(L);
839 return *hlua;
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100840}
841static inline void hlua_sethlua(struct hlua *hlua)
842{
Thierry FOURNIER38c5fd62015-03-10 02:40:29 +0100843 struct hlua **hlua_store = lua_getextraspace(hlua->T);
844 *hlua_store = hlua;
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100845}
846
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100847/* This function is used to send logs. It try to send on screen (stderr)
848 * and on the default syslog server.
849 */
850static inline void hlua_sendlog(struct proxy *px, int level, const char *msg)
851{
852 struct tm tm;
853 char *p;
854
855 /* Cleanup the log message. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200856 p = trash.area;
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100857 for (; *msg != '\0'; msg++, p++) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200858 if (p >= trash.area + trash.size - 1) {
Thierry FOURNIERccf00632015-09-16 12:47:03 +0200859 /* Break the message if exceed the buffer size. */
860 *(p-4) = ' ';
861 *(p-3) = '.';
862 *(p-2) = '.';
863 *(p-1) = '.';
864 break;
865 }
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100866 if (isprint(*msg))
867 *p = *msg;
868 else
869 *p = '.';
870 }
871 *p = '\0';
872
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200873 send_log(px, level, "%s\n", trash.area);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100874 if (!(global.mode & MODE_QUIET) || (global.mode & (MODE_VERBOSE | MODE_STARTING))) {
Christopher Fauletb290edf2020-10-02 18:13:52 +0200875 if (level == LOG_DEBUG && !(global.mode & MODE_DEBUG))
876 return;
877
Willy Tarreaua678b432015-08-28 10:14:59 +0200878 get_localtime(date.tv_sec, &tm);
879 fprintf(stderr, "[%s] %03d/%02d%02d%02d (%d) : %s\n",
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100880 log_levels[level], tm.tm_yday, tm.tm_hour, tm.tm_min, tm.tm_sec,
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200881 (int)getpid(), trash.area);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100882 fflush(stderr);
883 }
884}
885
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100886/* This function just ensure that the yield will be always
887 * returned with a timeout and permit to set some flags
888 */
889__LJMP void hlua_yieldk(lua_State *L, int nresults, int ctx,
Thierry FOURNIERf90838b2015-03-06 13:48:32 +0100890 lua_KFunction k, int timeout, unsigned int flags)
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100891{
892 struct hlua *hlua = hlua_gethlua(L);
893
894 /* Set the wake timeout. If timeout is required, we set
895 * the expiration time.
896 */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +0200897 hlua->wake_time = timeout;
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100898
Thierry FOURNIER4abd3ae2015-03-03 17:29:06 +0100899 hlua->flags |= flags;
900
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100901 /* Process the yield. */
Willy Tarreau9635e032018-10-16 17:52:55 +0200902 MAY_LJMP(lua_yieldk(L, nresults, ctx, k));
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100903}
904
Willy Tarreau87b09662015-04-03 00:22:06 +0200905/* This function initialises the Lua environment stored in the stream.
906 * It must be called at the start of the stream. This function creates
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100907 * an LUA coroutine. It can not be use to crete the main LUA context.
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200908 *
909 * This function is particular. it initialises a new Lua thread. If the
910 * initialisation fails (example: out of memory error), the lua function
911 * throws an error (longjmp).
912 *
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +0100913 * In some case (at least one), this function can be called from safe
914 * environement, so we must not initialise it. While the support of
915 * threads appear, the safe environment set a lock to ensure only one
916 * Lua execution at a time. If we initialize safe environment in another
917 * safe environmenet, we have a dead lock.
918 *
919 * set "already_safe" true if the context is initialized form safe
920 * Lua fonction.
921 *
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -0800922 * This function manipulates two Lua stacks: the main and the thread. Only
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200923 * the main stack can fail. The thread is not manipulated. This function
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -0800924 * MUST NOT manipulate the created thread stack state, because it is not
925 * proctected against errors thrown by the thread stack.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100926 */
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +0100927int hlua_ctx_init(struct hlua *lua, struct task *task, int already_safe)
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100928{
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +0100929 if (!already_safe) {
930 if (!SET_SAFE_LJMP(gL.T)) {
931 lua->Tref = LUA_REFNIL;
932 return 0;
933 }
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200934 }
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100935 lua->Mref = LUA_REFNIL;
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +0100936 lua->flags = 0;
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100937 LIST_INIT(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100938 lua->T = lua_newthread(gL.T);
939 if (!lua->T) {
940 lua->Tref = LUA_REFNIL;
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +0100941 if (!already_safe)
942 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100943 return 0;
944 }
945 hlua_sethlua(lua);
946 lua->Tref = luaL_ref(gL.T, LUA_REGISTRYINDEX);
947 lua->task = task;
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +0100948 if (!already_safe)
949 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100950 return 1;
951}
952
Willy Tarreau87b09662015-04-03 00:22:06 +0200953/* Used to destroy the Lua coroutine when the attached stream or task
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100954 * is destroyed. The destroy also the memory context. The struct "lua"
955 * is not freed.
956 */
957void hlua_ctx_destroy(struct hlua *lua)
958{
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +0100959 if (!lua)
Thierry FOURNIERa718b292015-03-04 16:48:34 +0100960 return;
961
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +0100962 if (!lua->T)
963 goto end;
964
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100965 /* Purge all the pending signals. */
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200966 notification_purge(&lua->com);
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100967
Thierry FOURNIER75d02082017-07-12 13:41:33 +0200968 if (!SET_SAFE_LJMP(lua->T))
969 return;
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100970 luaL_unref(lua->T, LUA_REGISTRYINDEX, lua->Mref);
Thierry FOURNIER75d02082017-07-12 13:41:33 +0200971 RESET_SAFE_LJMP(lua->T);
Thierry FOURNIER5a50a852015-09-23 16:59:28 +0200972
Thierry FOURNIER75d02082017-07-12 13:41:33 +0200973 if (!SET_SAFE_LJMP(gL.T))
974 return;
975 luaL_unref(gL.T, LUA_REGISTRYINDEX, lua->Tref);
976 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER5a50a852015-09-23 16:59:28 +0200977 /* Forces a garbage collecting process. If the Lua program is finished
978 * without error, we run the GC on the thread pointer. Its freed all
979 * the unused memory.
980 * If the thread is finnish with an error or is currently yielded,
981 * it seems that the GC applied on the thread doesn't clean anything,
982 * so e run the GC on the main thread.
983 * NOTE: maybe this action locks all the Lua threads untiml the en of
984 * the garbage collection.
985 */
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +0200986 if (lua->flags & HLUA_MUST_GC) {
Thierry FOURNIER7bd10d52017-07-17 00:44:40 +0200987 if (!SET_SAFE_LJMP(gL.T))
Thierry FOURNIER75d02082017-07-12 13:41:33 +0200988 return;
Thierry FOURNIER7bd10d52017-07-17 00:44:40 +0200989 lua_gc(gL.T, LUA_GCCOLLECT, 0);
990 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +0200991 }
Thierry FOURNIER5a50a852015-09-23 16:59:28 +0200992
Thierry FOURNIERa7b536b2015-09-21 22:50:24 +0200993 lua->T = NULL;
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +0100994
995end:
Willy Tarreaubafbe012017-11-24 17:34:44 +0100996 pool_free(pool_head_hlua, lua);
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100997}
998
999/* This function is used to restore the Lua context when a coroutine
1000 * fails. This function copy the common memory between old coroutine
1001 * and the new coroutine. The old coroutine is destroyed, and its
1002 * replaced by the new coroutine.
1003 * If the flag "keep_msg" is set, the last entry of the old is assumed
1004 * as string error message and it is copied in the new stack.
1005 */
1006static int hlua_ctx_renew(struct hlua *lua, int keep_msg)
1007{
1008 lua_State *T;
1009 int new_ref;
1010
1011 /* Renew the main LUA stack doesn't have sense. */
1012 if (lua == &gL)
1013 return 0;
1014
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001015 /* New Lua coroutine. */
1016 T = lua_newthread(gL.T);
1017 if (!T)
1018 return 0;
1019
1020 /* Copy last error message. */
1021 if (keep_msg)
1022 lua_xmove(lua->T, T, 1);
1023
1024 /* Copy data between the coroutines. */
1025 lua_rawgeti(lua->T, LUA_REGISTRYINDEX, lua->Mref);
1026 lua_xmove(lua->T, T, 1);
1027 new_ref = luaL_ref(T, LUA_REGISTRYINDEX); /* Valur poped. */
1028
1029 /* Destroy old data. */
1030 luaL_unref(lua->T, LUA_REGISTRYINDEX, lua->Mref);
1031
1032 /* The thread is garbage collected by Lua. */
1033 luaL_unref(gL.T, LUA_REGISTRYINDEX, lua->Tref);
1034
1035 /* Fill the struct with the new coroutine values. */
1036 lua->Mref = new_ref;
1037 lua->T = T;
1038 lua->Tref = luaL_ref(gL.T, LUA_REGISTRYINDEX);
1039
1040 /* Set context. */
1041 hlua_sethlua(lua);
1042
1043 return 1;
1044}
1045
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001046void hlua_hook(lua_State *L, lua_Debug *ar)
1047{
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001048 struct hlua *hlua = hlua_gethlua(L);
1049
1050 /* Lua cannot yield when its returning from a function,
1051 * so, we can fix the interrupt hook to 1 instruction,
1052 * expecting that the function is finnished.
1053 */
1054 if (lua_gethookmask(L) & LUA_MASKRET) {
1055 lua_sethook(hlua->T, hlua_hook, LUA_MASKCOUNT, 1);
1056 return;
1057 }
1058
1059 /* restore the interrupt condition. */
1060 lua_sethook(hlua->T, hlua_hook, LUA_MASKCOUNT, hlua_nb_instruction);
1061
1062 /* If we interrupt the Lua processing in yieldable state, we yield.
1063 * If the state is not yieldable, trying yield causes an error.
1064 */
1065 if (lua_isyieldable(L))
Willy Tarreau9635e032018-10-16 17:52:55 +02001066 MAY_LJMP(hlua_yieldk(L, 0, 0, NULL, TICK_ETERNITY, HLUA_CTRLYIELD));
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001067
Thierry FOURNIERa85cfb12015-03-13 14:50:06 +01001068 /* If we cannot yield, update the clock and check the timeout. */
1069 tv_update_date(0, 1);
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001070 hlua->run_time += now_ms - hlua->start_time;
1071 if (hlua->max_time && hlua->run_time >= hlua->max_time) {
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001072 lua_pushfstring(L, "execution timeout");
1073 WILL_LJMP(lua_error(L));
1074 }
1075
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001076 /* Update the start time. */
1077 hlua->start_time = now_ms;
1078
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001079 /* Try to interrupt the process at the end of the current
1080 * unyieldable function.
1081 */
1082 lua_sethook(hlua->T, hlua_hook, LUA_MASKRET|LUA_MASKCOUNT, hlua_nb_instruction);
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001083}
1084
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001085/* This function start or resumes the Lua stack execution. If the flag
1086 * "yield_allowed" if no set and the LUA stack execution returns a yield
1087 * The function return an error.
1088 *
1089 * The function can returns 4 values:
1090 * - HLUA_E_OK : The execution is terminated without any errors.
1091 * - HLUA_E_AGAIN : The execution must continue at the next associated
1092 * task wakeup.
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001093 * - HLUA_E_ERRMSG : An error has occurred, an error message is set in
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001094 * the top of the stack.
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001095 * - HLUA_E_ERR : An error has occurred without error message.
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001096 *
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001097 * If an error occurred, the stack is renewed and it is ready to run new
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001098 * LUA code.
1099 */
1100static enum hlua_exec hlua_ctx_resume(struct hlua *lua, int yield_allowed)
1101{
Christopher Faulet20699902020-07-28 10:33:25 +02001102#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 504
1103 int nres;
1104#endif
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001105 int ret;
1106 const char *msg;
Thierry FOURNIERfc044c92018-06-07 14:40:48 +02001107 const char *trace;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001108
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001109 /* Initialise run time counter. */
1110 if (!HLUA_IS_RUNNING(lua))
1111 lua->run_time = 0;
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001112
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +02001113 /* Lock the whole Lua execution. This lock must be before the
1114 * label "resume_execution".
1115 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001116 HA_SPIN_LOCK(LUA_LOCK, &hlua_global_lock);
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +02001117
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001118resume_execution:
1119
1120 /* This hook interrupts the Lua processing each 'hlua_nb_instruction'
1121 * instructions. it is used for preventing infinite loops.
1122 */
1123 lua_sethook(lua->T, hlua_hook, LUA_MASKCOUNT, hlua_nb_instruction);
1124
Thierry FOURNIER1bfc09b2015-03-05 17:10:14 +01001125 /* Remove all flags except the running flags. */
Thierry FOURNIER2f3867f2015-09-28 01:02:01 +02001126 HLUA_SET_RUN(lua);
1127 HLUA_CLR_CTRLYIELD(lua);
1128 HLUA_CLR_WAKERESWR(lua);
1129 HLUA_CLR_WAKEREQWR(lua);
Thierry FOURNIER1bfc09b2015-03-05 17:10:14 +01001130
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001131 /* Update the start time. */
1132 lua->start_time = now_ms;
1133
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001134 /* Call the function. */
Christopher Faulet20699902020-07-28 10:33:25 +02001135#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 504
1136 ret = lua_resume(lua->T, gL.T, lua->nargs, &nres);
1137#else
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001138 ret = lua_resume(lua->T, gL.T, lua->nargs);
Christopher Faulet20699902020-07-28 10:33:25 +02001139#endif
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001140 switch (ret) {
1141
1142 case LUA_OK:
1143 ret = HLUA_E_OK;
1144 break;
1145
1146 case LUA_YIELD:
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001147 /* Check if the execution timeout is expired. It it is the case, we
1148 * break the Lua execution.
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001149 */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001150 tv_update_date(0, 1);
1151 lua->run_time += now_ms - lua->start_time;
1152 if (lua->max_time && lua->run_time > lua->max_time) {
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001153 lua_settop(lua->T, 0); /* Empty the stack. */
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001154 ret = HLUA_E_ETMOUT;
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001155 break;
1156 }
1157 /* Process the forced yield. if the general yield is not allowed or
1158 * if no task were associated this the current Lua execution
1159 * coroutine, we resume the execution. Else we want to return in the
1160 * scheduler and we want to be waked up again, to continue the
1161 * current Lua execution. So we schedule our own task.
1162 */
1163 if (HLUA_IS_CTRLYIELDING(lua)) {
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001164 if (!yield_allowed || !lua->task)
1165 goto resume_execution;
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001166 task_wakeup(lua->task, TASK_WOKEN_MSG);
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001167 }
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001168 if (!yield_allowed) {
1169 lua_settop(lua->T, 0); /* Empty the stack. */
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001170 ret = HLUA_E_YIELD;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001171 break;
1172 }
1173 ret = HLUA_E_AGAIN;
1174 break;
1175
1176 case LUA_ERRRUN:
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001177
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001178 /* Special exit case. The traditional exit is returned as an error
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001179 * because the errors ares the only one mean to return immediately
1180 * from and lua execution.
1181 */
1182 if (lua->flags & HLUA_EXIT) {
1183 ret = HLUA_E_OK;
Thierry FOURNIERe1587b32015-08-28 09:54:13 +02001184 hlua_ctx_renew(lua, 0);
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001185 break;
1186 }
1187
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001188 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001189 if (!lua_checkstack(lua->T, 1)) {
1190 ret = HLUA_E_ERR;
1191 break;
1192 }
1193 msg = lua_tostring(lua->T, -1);
1194 lua_settop(lua->T, 0); /* Empty the stack. */
1195 lua_pop(lua->T, 1);
Thierry FOURNIERfc044c92018-06-07 14:40:48 +02001196 trace = hlua_traceback(lua->T);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001197 if (msg)
Thierry FOURNIERfc044c92018-06-07 14:40:48 +02001198 lua_pushfstring(lua->T, "runtime error: %s from %s", msg, trace);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001199 else
Thierry FOURNIERfc044c92018-06-07 14:40:48 +02001200 lua_pushfstring(lua->T, "unknown runtime error from %s", trace);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001201 ret = HLUA_E_ERRMSG;
1202 break;
1203
1204 case LUA_ERRMEM:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001205 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001206 lua_settop(lua->T, 0); /* Empty the stack. */
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001207 ret = HLUA_E_NOMEM;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001208 break;
1209
1210 case LUA_ERRERR:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001211 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001212 if (!lua_checkstack(lua->T, 1)) {
1213 ret = HLUA_E_ERR;
1214 break;
1215 }
1216 msg = lua_tostring(lua->T, -1);
1217 lua_settop(lua->T, 0); /* Empty the stack. */
1218 lua_pop(lua->T, 1);
1219 if (msg)
1220 lua_pushfstring(lua->T, "message handler error: %s", msg);
1221 else
1222 lua_pushfstring(lua->T, "message handler error");
1223 ret = HLUA_E_ERRMSG;
1224 break;
1225
1226 default:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001227 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001228 lua_settop(lua->T, 0); /* Empty the stack. */
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001229 ret = HLUA_E_ERR;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001230 break;
1231 }
1232
Thierry FOURNIER6ab4d8e2015-09-27 22:17:19 +02001233 /* This GC permits to destroy some object when a Lua timeout strikes. */
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +02001234 if (lua->flags & HLUA_MUST_GC &&
1235 ret != HLUA_E_AGAIN)
Thierry FOURNIER6ab4d8e2015-09-27 22:17:19 +02001236 lua_gc(lua->T, LUA_GCCOLLECT, 0);
1237
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001238 switch (ret) {
1239 case HLUA_E_AGAIN:
1240 break;
1241
1242 case HLUA_E_ERRMSG:
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001243 notification_purge(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001244 hlua_ctx_renew(lua, 1);
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001245 HLUA_CLR_RUN(lua);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001246 break;
1247
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001248 case HLUA_E_ETMOUT:
1249 case HLUA_E_NOMEM:
1250 case HLUA_E_YIELD:
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001251 case HLUA_E_ERR:
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001252 HLUA_CLR_RUN(lua);
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001253 notification_purge(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001254 hlua_ctx_renew(lua, 0);
1255 break;
1256
1257 case HLUA_E_OK:
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001258 HLUA_CLR_RUN(lua);
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001259 notification_purge(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001260 break;
1261 }
1262
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +02001263 /* This is the main exit point, remove the Lua lock. */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001264 HA_SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock);
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +02001265
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001266 return ret;
1267}
1268
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001269/* This function exit the current code. */
1270__LJMP static int hlua_done(lua_State *L)
1271{
1272 struct hlua *hlua = hlua_gethlua(L);
1273
1274 hlua->flags |= HLUA_EXIT;
1275 WILL_LJMP(lua_error(L));
1276
1277 return 0;
1278}
1279
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001280/* This function is an LUA binding. It provides a function
1281 * for deleting ACL from a referenced ACL file.
1282 */
1283__LJMP static int hlua_del_acl(lua_State *L)
1284{
1285 const char *name;
1286 const char *key;
1287 struct pat_ref *ref;
1288
1289 MAY_LJMP(check_args(L, 2, "del_acl"));
1290
1291 name = MAY_LJMP(luaL_checkstring(L, 1));
1292 key = MAY_LJMP(luaL_checkstring(L, 2));
1293
1294 ref = pat_ref_lookup(name);
1295 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001296 WILL_LJMP(luaL_error(L, "'del_acl': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001297
Christopher Faulet9fa1f4e2020-06-03 18:39:16 +02001298 HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001299 pat_ref_delete(ref, key);
Christopher Faulet9fa1f4e2020-06-03 18:39:16 +02001300 HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001301 return 0;
1302}
1303
1304/* This function is an LUA binding. It provides a function
1305 * for deleting map entry from a referenced map file.
1306 */
1307static int hlua_del_map(lua_State *L)
1308{
1309 const char *name;
1310 const char *key;
1311 struct pat_ref *ref;
1312
1313 MAY_LJMP(check_args(L, 2, "del_map"));
1314
1315 name = MAY_LJMP(luaL_checkstring(L, 1));
1316 key = MAY_LJMP(luaL_checkstring(L, 2));
1317
1318 ref = pat_ref_lookup(name);
1319 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001320 WILL_LJMP(luaL_error(L, "'del_map': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001321
Christopher Faulet9fa1f4e2020-06-03 18:39:16 +02001322 HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001323 pat_ref_delete(ref, key);
Christopher Faulet9fa1f4e2020-06-03 18:39:16 +02001324 HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001325 return 0;
1326}
1327
1328/* This function is an LUA binding. It provides a function
1329 * for adding ACL pattern from a referenced ACL file.
1330 */
1331static int hlua_add_acl(lua_State *L)
1332{
1333 const char *name;
1334 const char *key;
1335 struct pat_ref *ref;
1336
1337 MAY_LJMP(check_args(L, 2, "add_acl"));
1338
1339 name = MAY_LJMP(luaL_checkstring(L, 1));
1340 key = MAY_LJMP(luaL_checkstring(L, 2));
1341
1342 ref = pat_ref_lookup(name);
1343 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001344 WILL_LJMP(luaL_error(L, "'add_acl': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001345
Christopher Faulet9fa1f4e2020-06-03 18:39:16 +02001346 HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001347 if (pat_ref_find_elt(ref, key) == NULL)
1348 pat_ref_add(ref, key, NULL, NULL);
Christopher Faulet9fa1f4e2020-06-03 18:39:16 +02001349 HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001350 return 0;
1351}
1352
1353/* This function is an LUA binding. It provides a function
1354 * for setting map pattern and sample from a referenced map
1355 * file.
1356 */
1357static int hlua_set_map(lua_State *L)
1358{
1359 const char *name;
1360 const char *key;
1361 const char *value;
1362 struct pat_ref *ref;
1363
1364 MAY_LJMP(check_args(L, 3, "set_map"));
1365
1366 name = MAY_LJMP(luaL_checkstring(L, 1));
1367 key = MAY_LJMP(luaL_checkstring(L, 2));
1368 value = MAY_LJMP(luaL_checkstring(L, 3));
1369
1370 ref = pat_ref_lookup(name);
1371 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001372 WILL_LJMP(luaL_error(L, "'set_map': unknown map file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001373
Christopher Faulet9fa1f4e2020-06-03 18:39:16 +02001374 HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001375 if (pat_ref_find_elt(ref, key) != NULL)
1376 pat_ref_set(ref, key, value, NULL);
1377 else
1378 pat_ref_add(ref, key, value, NULL);
Christopher Faulet9fa1f4e2020-06-03 18:39:16 +02001379 HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001380 return 0;
1381}
1382
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01001383/* A class is a lot of memory that contain data. This data can be a table,
1384 * an integer or user data. This data is associated with a metatable. This
1385 * metatable have an original version registred in the global context with
1386 * the name of the object (_G[<name>] = <metable> ).
1387 *
1388 * A metable is a table that modify the standard behavior of a standard
1389 * access to the associated data. The entries of this new metatable are
1390 * defined as is:
1391 *
1392 * http://lua-users.org/wiki/MetatableEvents
1393 *
1394 * __index
1395 *
1396 * we access an absent field in a table, the result is nil. This is
1397 * true, but it is not the whole truth. Actually, such access triggers
1398 * the interpreter to look for an __index metamethod: If there is no
1399 * such method, as usually happens, then the access results in nil;
1400 * otherwise, the metamethod will provide the result.
1401 *
1402 * Control 'prototype' inheritance. When accessing "myTable[key]" and
1403 * the key does not appear in the table, but the metatable has an __index
1404 * property:
1405 *
1406 * - if the value is a function, the function is called, passing in the
1407 * table and the key; the return value of that function is returned as
1408 * the result.
1409 *
1410 * - if the value is another table, the value of the key in that table is
1411 * asked for and returned (and if it doesn't exist in that table, but that
1412 * table's metatable has an __index property, then it continues on up)
1413 *
1414 * - Use "rawget(myTable,key)" to skip this metamethod.
1415 *
1416 * http://www.lua.org/pil/13.4.1.html
1417 *
1418 * __newindex
1419 *
1420 * Like __index, but control property assignment.
1421 *
1422 * __mode - Control weak references. A string value with one or both
1423 * of the characters 'k' and 'v' which specifies that the the
1424 * keys and/or values in the table are weak references.
1425 *
1426 * __call - Treat a table like a function. When a table is followed by
1427 * parenthesis such as "myTable( 'foo' )" and the metatable has
1428 * a __call key pointing to a function, that function is invoked
1429 * (passing any specified arguments) and the return value is
1430 * returned.
1431 *
1432 * __metatable - Hide the metatable. When "getmetatable( myTable )" is
1433 * called, if the metatable for myTable has a __metatable
1434 * key, the value of that key is returned instead of the
1435 * actual metatable.
1436 *
1437 * __tostring - Control string representation. When the builtin
1438 * "tostring( myTable )" function is called, if the metatable
1439 * for myTable has a __tostring property set to a function,
1440 * that function is invoked (passing myTable to it) and the
1441 * return value is used as the string representation.
1442 *
1443 * __len - Control table length. When the table length is requested using
1444 * the length operator ( '#' ), if the metatable for myTable has
1445 * a __len key pointing to a function, that function is invoked
1446 * (passing myTable to it) and the return value used as the value
1447 * of "#myTable".
1448 *
1449 * __gc - Userdata finalizer code. When userdata is set to be garbage
1450 * collected, if the metatable has a __gc field pointing to a
1451 * function, that function is first invoked, passing the userdata
1452 * to it. The __gc metamethod is not called for tables.
1453 * (See http://lua-users.org/lists/lua-l/2006-11/msg00508.html)
1454 *
1455 * Special metamethods for redefining standard operators:
1456 * http://www.lua.org/pil/13.1.html
1457 *
1458 * __add "+"
1459 * __sub "-"
1460 * __mul "*"
1461 * __div "/"
1462 * __unm "!"
1463 * __pow "^"
1464 * __concat ".."
1465 *
1466 * Special methods for redfining standar relations
1467 * http://www.lua.org/pil/13.2.html
1468 *
1469 * __eq "=="
1470 * __lt "<"
1471 * __le "<="
1472 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001473
1474/*
1475 *
1476 *
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001477 * Class Map
1478 *
1479 *
1480 */
1481
1482/* Returns a struct hlua_map if the stack entry "ud" is
1483 * a class session, otherwise it throws an error.
1484 */
1485__LJMP static struct map_descriptor *hlua_checkmap(lua_State *L, int ud)
1486{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02001487 return MAY_LJMP(hlua_checkudata(L, ud, class_map_ref));
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001488}
1489
1490/* This function is the map constructor. It don't need
1491 * the class Map object. It creates and return a new Map
1492 * object. It must be called only during "body" or "init"
1493 * context because it process some filesystem accesses.
1494 */
1495__LJMP static int hlua_map_new(struct lua_State *L)
1496{
1497 const char *fn;
1498 int match = PAT_MATCH_STR;
1499 struct sample_conv conv;
1500 const char *file = "";
1501 int line = 0;
1502 lua_Debug ar;
1503 char *err = NULL;
1504 struct arg args[2];
1505
1506 if (lua_gettop(L) < 1 || lua_gettop(L) > 2)
1507 WILL_LJMP(luaL_error(L, "'new' needs at least 1 argument."));
1508
1509 fn = MAY_LJMP(luaL_checkstring(L, 1));
1510
1511 if (lua_gettop(L) >= 2) {
1512 match = MAY_LJMP(luaL_checkinteger(L, 2));
1513 if (match < 0 || match >= PAT_MATCH_NUM)
1514 WILL_LJMP(luaL_error(L, "'new' needs a valid match method."));
1515 }
1516
1517 /* Get Lua filename and line number. */
1518 if (lua_getstack(L, 1, &ar)) { /* check function at level */
1519 lua_getinfo(L, "Sl", &ar); /* get info about it */
1520 if (ar.currentline > 0) { /* is there info? */
1521 file = ar.short_src;
1522 line = ar.currentline;
1523 }
1524 }
1525
1526 /* fill fake sample_conv struct. */
1527 conv.kw = ""; /* unused. */
1528 conv.process = NULL; /* unused. */
1529 conv.arg_mask = 0; /* unused. */
1530 conv.val_args = NULL; /* unused. */
1531 conv.out_type = SMP_T_STR;
1532 conv.private = (void *)(long)match;
1533 switch (match) {
1534 case PAT_MATCH_STR: conv.in_type = SMP_T_STR; break;
1535 case PAT_MATCH_BEG: conv.in_type = SMP_T_STR; break;
1536 case PAT_MATCH_SUB: conv.in_type = SMP_T_STR; break;
1537 case PAT_MATCH_DIR: conv.in_type = SMP_T_STR; break;
1538 case PAT_MATCH_DOM: conv.in_type = SMP_T_STR; break;
1539 case PAT_MATCH_END: conv.in_type = SMP_T_STR; break;
1540 case PAT_MATCH_REG: conv.in_type = SMP_T_STR; break;
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001541 case PAT_MATCH_INT: conv.in_type = SMP_T_SINT; break;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001542 case PAT_MATCH_IP: conv.in_type = SMP_T_ADDR; break;
1543 default:
1544 WILL_LJMP(luaL_error(L, "'new' doesn't support this match mode."));
1545 }
1546
1547 /* fill fake args. */
1548 args[0].type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001549 args[0].data.str.area = (char *)fn;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001550 args[1].type = ARGT_STOP;
1551
1552 /* load the map. */
1553 if (!sample_load_map(args, &conv, file, line, &err)) {
1554 /* error case: we cant use luaL_error because we must
1555 * free the err variable.
1556 */
1557 luaL_where(L, 1);
1558 lua_pushfstring(L, "'new': %s.", err);
1559 lua_concat(L, 2);
1560 free(err);
1561 WILL_LJMP(lua_error(L));
1562 }
1563
1564 /* create the lua object. */
1565 lua_newtable(L);
1566 lua_pushlightuserdata(L, args[0].data.map);
1567 lua_rawseti(L, -2, 0);
1568
1569 /* Pop a class Map metatable and affect it to the userdata. */
1570 lua_rawgeti(L, LUA_REGISTRYINDEX, class_map_ref);
1571 lua_setmetatable(L, -2);
1572
1573
1574 return 1;
1575}
1576
1577__LJMP static inline int _hlua_map_lookup(struct lua_State *L, int str)
1578{
1579 struct map_descriptor *desc;
1580 struct pattern *pat;
1581 struct sample smp;
1582
1583 MAY_LJMP(check_args(L, 2, "lookup"));
1584 desc = MAY_LJMP(hlua_checkmap(L, 1));
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001585 if (desc->pat.expect_type == SMP_T_SINT) {
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001586 smp.data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001587 smp.data.u.sint = MAY_LJMP(luaL_checkinteger(L, 2));
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001588 }
1589 else {
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001590 smp.data.type = SMP_T_STR;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001591 smp.flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001592 smp.data.u.str.area = (char *)MAY_LJMP(luaL_checklstring(L, 2, (size_t *)&smp.data.u.str.data));
Thierry Fournier8e553842020-11-10 20:38:20 +01001593 smp.data.u.str.size = smp.data.u.str.data + 1;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001594 }
1595
1596 pat = pattern_exec_match(&desc->pat, &smp, 1);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001597 if (!pat || !pat->data) {
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001598 if (str)
1599 lua_pushstring(L, "");
1600 else
1601 lua_pushnil(L);
1602 return 1;
1603 }
1604
1605 /* The Lua pattern must return a string, so we can't check the returned type */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001606 lua_pushlstring(L, pat->data->u.str.area, pat->data->u.str.data);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001607 return 1;
1608}
1609
1610__LJMP static int hlua_map_lookup(struct lua_State *L)
1611{
1612 return _hlua_map_lookup(L, 0);
1613}
1614
1615__LJMP static int hlua_map_slookup(struct lua_State *L)
1616{
1617 return _hlua_map_lookup(L, 1);
1618}
1619
1620/*
1621 *
1622 *
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001623 * Class Socket
1624 *
1625 *
1626 */
1627
1628__LJMP static struct hlua_socket *hlua_checksocket(lua_State *L, int ud)
1629{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02001630 return MAY_LJMP(hlua_checkudata(L, ud, class_socket_ref));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001631}
1632
1633/* This function is the handler called for each I/O on the established
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001634 * connection. It is used for notify space available to send or data
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001635 * received.
1636 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02001637static void hlua_socket_handler(struct appctx *appctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001638{
Willy Tarreau00a37f02015-04-13 12:05:19 +02001639 struct stream_interface *si = appctx->owner;
Olivier Houchard9aaf7782017-09-13 18:30:23 +02001640 struct connection *c = cs_conn(objt_cs(si_opposite(si)->end));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001641
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02001642 if (appctx->ctx.hlua_cosocket.die) {
1643 si_shutw(si);
1644 si_shutr(si);
1645 si_ic(si)->flags |= CF_READ_NULL;
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001646 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1647 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02001648 stream_shutdown(si_strm(si), SF_ERR_KILLED);
1649 }
1650
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001651 /* If the connection object is not available, close all the
1652 * streams and wakeup everything waiting for.
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001653 */
1654 if (!c) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001655 si_shutw(si);
1656 si_shutr(si);
Willy Tarreau2bb4a962014-11-28 11:11:05 +01001657 si_ic(si)->flags |= CF_READ_NULL;
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001658 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1659 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Willy Tarreaud4da1962015-04-20 01:31:23 +02001660 return;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001661 }
1662
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001663 /* If we cant write, wakeup the pending write signals. */
1664 if (channel_output_closed(si_ic(si)))
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001665 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001666
1667 /* If we cant read, wakeup the pending read signals. */
1668 if (channel_input_closed(si_oc(si)))
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001669 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001670
Thierry FOURNIER316e3192015-09-04 18:25:53 +02001671 /* if the connection is not estabkished, inform the stream that we want
1672 * to be notified whenever the connection completes.
1673 */
1674 if (!(c->flags & CO_FL_CONNECTED)) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01001675 si_cant_get(si);
Willy Tarreau12c24232018-12-06 15:29:50 +01001676 si_rx_conn_blk(si);
Willy Tarreau3367d412018-11-15 10:57:41 +01001677 si_rx_endp_more(si);
Willy Tarreaud4da1962015-04-20 01:31:23 +02001678 return;
Thierry FOURNIER316e3192015-09-04 18:25:53 +02001679 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001680
1681 /* This function is called after the connect. */
Thierry FOURNIER18d09902016-12-16 09:25:38 +01001682 appctx->ctx.hlua_cosocket.connected = 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001683
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001684 /* Wake the tasks which wants to write if the buffer have available space. */
Thierry FOURNIEReba6f642015-09-26 22:01:07 +02001685 if (channel_may_recv(si_ic(si)))
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001686 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001687
1688 /* Wake the tasks which wants to read if the buffer contains data. */
Thierry FOURNIEReba6f642015-09-26 22:01:07 +02001689 if (!channel_is_empty(si_oc(si)))
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001690 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
Thierry FOURNIER101b9762018-05-27 01:27:40 +02001691
1692 /* Some data were injected in the buffer, notify the stream
1693 * interface.
1694 */
1695 if (!channel_is_empty(si_ic(si)))
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01001696 si_update(si);
Thierry FOURNIER101b9762018-05-27 01:27:40 +02001697
1698 /* If write notifications are registered, we considers we want
Willy Tarreau3367d412018-11-15 10:57:41 +01001699 * to write, so we clear the blocking flag.
Thierry FOURNIER101b9762018-05-27 01:27:40 +02001700 */
1701 if (notification_registered(&appctx->ctx.hlua_cosocket.wake_on_write))
Willy Tarreau3367d412018-11-15 10:57:41 +01001702 si_rx_endp_more(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001703}
1704
Willy Tarreau87b09662015-04-03 00:22:06 +02001705/* This function is called when the "struct stream" is destroyed.
1706 * Remove the link from the object to this stream.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001707 * Wake all the pending signals.
1708 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02001709static void hlua_socket_release(struct appctx *appctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001710{
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001711 struct xref *peer;
1712
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001713 /* Remove my link in the original object. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001714 peer = xref_get_peer_and_lock(&appctx->ctx.hlua_cosocket.xref);
1715 if (peer)
1716 xref_disconnect(&appctx->ctx.hlua_cosocket.xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001717
1718 /* Wake all the task waiting for me. */
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001719 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1720 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001721}
1722
1723/* If the garbage collectio of the object is launch, nobody
Willy Tarreau87b09662015-04-03 00:22:06 +02001724 * uses this object. If the stream does not exists, just quit.
1725 * Send the shutdown signal to the stream. In some cases,
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001726 * pending signal can rest in the read and write lists. destroy
1727 * it.
1728 */
1729__LJMP static int hlua_socket_gc(lua_State *L)
1730{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001731 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001732 struct appctx *appctx;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001733 struct xref *peer;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001734
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001735 MAY_LJMP(check_args(L, 1, "__gc"));
1736
1737 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001738 peer = xref_get_peer_and_lock(&socket->xref);
1739 if (!peer)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001740 return 0;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001741 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001742
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001743 /* Set the flag which destroy the session. */
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02001744 appctx->ctx.hlua_cosocket.die = 1;
1745 appctx_wakeup(appctx);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001746
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001747 /* Remove all reference between the Lua stack and the coroutine stream. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001748 xref_disconnect(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001749 return 0;
1750}
1751
1752/* The close function send shutdown signal and break the
Willy Tarreau87b09662015-04-03 00:22:06 +02001753 * links between the stream and the object.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001754 */
sada05ed3302018-05-11 11:48:18 -07001755__LJMP static int hlua_socket_close_helper(lua_State *L)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001756{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001757 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001758 struct appctx *appctx;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001759 struct xref *peer;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001760
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001761 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02001762
1763 /* Check if we run on the same thread than the xreator thread.
1764 * We cannot access to the socket if the thread is different.
1765 */
1766 if (socket->tid != tid)
1767 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
1768
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001769 peer = xref_get_peer_and_lock(&socket->xref);
1770 if (!peer)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001771 return 0;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001772 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001773
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001774 /* Set the flag which destroy the session. */
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02001775 appctx->ctx.hlua_cosocket.die = 1;
1776 appctx_wakeup(appctx);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001777
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001778 /* Remove all reference between the Lua stack and the coroutine stream. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001779 xref_disconnect(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001780 return 0;
1781}
1782
sada05ed3302018-05-11 11:48:18 -07001783/* The close function calls close_helper.
1784 */
1785__LJMP static int hlua_socket_close(lua_State *L)
1786{
1787 MAY_LJMP(check_args(L, 1, "close"));
1788 return hlua_socket_close_helper(L);
1789}
1790
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001791/* This Lua function assumes that the stack contain three parameters.
1792 * 1 - USERDATA containing a struct socket
1793 * 2 - INTEGER with values of the macro defined below
1794 * If the integer is -1, we must read at most one line.
1795 * If the integer is -2, we ust read all the data until the
1796 * end of the stream.
1797 * If the integer is positive value, we must read a number of
1798 * bytes corresponding to this value.
1799 */
1800#define HLSR_READ_LINE (-1)
1801#define HLSR_READ_ALL (-2)
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001802__LJMP static int hlua_socket_receive_yield(struct lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001803{
1804 struct hlua_socket *socket = MAY_LJMP(hlua_checksocket(L, 1));
1805 int wanted = lua_tointeger(L, 2);
1806 struct hlua *hlua = hlua_gethlua(L);
1807 struct appctx *appctx;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02001808 size_t len;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001809 int nblk;
Willy Tarreau206ba832018-06-14 15:27:31 +02001810 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02001811 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02001812 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02001813 size_t len2;
Thierry FOURNIER00543922015-03-09 18:35:06 +01001814 int skip_at_end = 0;
Willy Tarreau81389672015-03-10 12:03:52 +01001815 struct channel *oc;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001816 struct stream_interface *si;
1817 struct stream *s;
1818 struct xref *peer;
Thierry FOURNIER8c126c72018-05-25 16:27:44 +02001819 int missing_bytes;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001820
1821 /* Check if this lua stack is schedulable. */
1822 if (!hlua || !hlua->task)
1823 WILL_LJMP(luaL_error(L, "The 'receive' function is only allowed in "
1824 "'frontend', 'backend' or 'task'"));
1825
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02001826 /* Check if we run on the same thread than the xreator thread.
1827 * We cannot access to the socket if the thread is different.
1828 */
1829 if (socket->tid != tid)
1830 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
1831
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001832 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001833 peer = xref_get_peer_and_lock(&socket->xref);
1834 if (!peer)
1835 goto no_peer;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001836 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
1837 si = appctx->owner;
1838 s = si_strm(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001839
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001840 oc = &s->res;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001841 if (wanted == HLSR_READ_LINE) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001842 /* Read line. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02001843 nblk = co_getline_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001844 if (nblk < 0) /* Connection close. */
1845 goto connection_closed;
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001846 if (nblk == 0) /* No data available. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001847 goto connection_empty;
Thierry FOURNIER00543922015-03-09 18:35:06 +01001848
1849 /* remove final \r\n. */
1850 if (nblk == 1) {
1851 if (blk1[len1-1] == '\n') {
1852 len1--;
1853 skip_at_end++;
1854 if (blk1[len1-1] == '\r') {
1855 len1--;
1856 skip_at_end++;
1857 }
1858 }
1859 }
1860 else {
1861 if (blk2[len2-1] == '\n') {
1862 len2--;
1863 skip_at_end++;
1864 if (blk2[len2-1] == '\r') {
1865 len2--;
1866 skip_at_end++;
1867 }
1868 }
1869 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001870 }
1871
1872 else if (wanted == HLSR_READ_ALL) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001873 /* Read all the available data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02001874 nblk = co_getblk_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001875 if (nblk < 0) /* Connection close. */
1876 goto connection_closed;
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001877 if (nblk == 0) /* No data available. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001878 goto connection_empty;
1879 }
1880
1881 else {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001882 /* Read a block of data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02001883 nblk = co_getblk_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001884 if (nblk < 0) /* Connection close. */
1885 goto connection_closed;
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001886 if (nblk == 0) /* No data available. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001887 goto connection_empty;
1888
Thierry FOURNIER8c126c72018-05-25 16:27:44 +02001889 missing_bytes = wanted - socket->b.n;
1890 if (len1 > missing_bytes) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001891 nblk = 1;
Thierry FOURNIER8c126c72018-05-25 16:27:44 +02001892 len1 = missing_bytes;
1893 } if (nblk == 2 && len1 + len2 > missing_bytes)
1894 len2 = missing_bytes - len1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001895 }
1896
1897 len = len1;
1898
1899 luaL_addlstring(&socket->b, blk1, len1);
1900 if (nblk == 2) {
1901 len += len2;
1902 luaL_addlstring(&socket->b, blk2, len2);
1903 }
1904
1905 /* Consume data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02001906 co_skip(oc, len + skip_at_end);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001907
1908 /* Don't wait anything. */
Thierry FOURNIER7e4ee472018-05-25 15:03:50 +02001909 appctx_wakeup(appctx);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001910
1911 /* If the pattern reclaim to read all the data
1912 * in the connection, got out.
1913 */
1914 if (wanted == HLSR_READ_ALL)
1915 goto connection_empty;
Thierry FOURNIER8c126c72018-05-25 16:27:44 +02001916 else if (wanted >= 0 && socket->b.n < wanted)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001917 goto connection_empty;
1918
1919 /* Return result. */
1920 luaL_pushresult(&socket->b);
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001921 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001922 return 1;
1923
1924connection_closed:
1925
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001926 xref_unlock(&socket->xref, peer);
1927
1928no_peer:
1929
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001930 /* If the buffer containds data. */
1931 if (socket->b.n > 0) {
1932 luaL_pushresult(&socket->b);
1933 return 1;
1934 }
1935 lua_pushnil(L);
1936 lua_pushstring(L, "connection closed.");
1937 return 2;
1938
1939connection_empty:
1940
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001941 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_read, hlua->task)) {
1942 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001943 WILL_LJMP(luaL_error(L, "out of memory"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001944 }
1945 xref_unlock(&socket->xref, peer);
Willy Tarreau9635e032018-10-16 17:52:55 +02001946 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_receive_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001947 return 0;
1948}
1949
Tim Duesterhusb33754c2018-01-04 19:32:14 +01001950/* This Lua function gets two parameters. The first one can be string
1951 * or a number. If the string is "*l", the user requires one line. If
1952 * the string is "*a", the user requires all the contents of the stream.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001953 * If the value is a number, the user require a number of bytes equal
1954 * to the value. The default value is "*l" (a line).
1955 *
Tim Duesterhusb33754c2018-01-04 19:32:14 +01001956 * This parameter with a variable type is converted in integer. This
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001957 * integer takes this values:
1958 * -1 : read a line
1959 * -2 : read all the stream
Tim Duesterhusb33754c2018-01-04 19:32:14 +01001960 * >0 : amount of bytes.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001961 *
Tim Duesterhusb33754c2018-01-04 19:32:14 +01001962 * The second parameter is optional. It contains a string that must be
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001963 * concatenated with the read data.
1964 */
1965__LJMP static int hlua_socket_receive(struct lua_State *L)
1966{
1967 int wanted = HLSR_READ_LINE;
1968 const char *pattern;
1969 int type;
1970 char *error;
1971 size_t len;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001972 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001973
1974 if (lua_gettop(L) < 1 || lua_gettop(L) > 3)
1975 WILL_LJMP(luaL_error(L, "The 'receive' function requires between 1 and 3 arguments."));
1976
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001977 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001978
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02001979 /* Check if we run on the same thread than the xreator thread.
1980 * We cannot access to the socket if the thread is different.
1981 */
1982 if (socket->tid != tid)
1983 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
1984
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001985 /* check for pattern. */
1986 if (lua_gettop(L) >= 2) {
1987 type = lua_type(L, 2);
1988 if (type == LUA_TSTRING) {
1989 pattern = lua_tostring(L, 2);
1990 if (strcmp(pattern, "*a") == 0)
1991 wanted = HLSR_READ_ALL;
1992 else if (strcmp(pattern, "*l") == 0)
1993 wanted = HLSR_READ_LINE;
1994 else {
1995 wanted = strtoll(pattern, &error, 10);
1996 if (*error != '\0')
1997 WILL_LJMP(luaL_error(L, "Unsupported pattern."));
1998 }
1999 }
2000 else if (type == LUA_TNUMBER) {
2001 wanted = lua_tointeger(L, 2);
2002 if (wanted < 0)
2003 WILL_LJMP(luaL_error(L, "Unsupported size."));
2004 }
2005 }
2006
2007 /* Set pattern. */
2008 lua_pushinteger(L, wanted);
Tim Duesterhusc6e377e2018-01-04 19:32:13 +01002009
2010 /* Check if we would replace the top by itself. */
2011 if (lua_gettop(L) != 2)
2012 lua_replace(L, 2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002013
Tim Duesterhusb33754c2018-01-04 19:32:14 +01002014 /* init buffer, and fill it with prefix. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002015 luaL_buffinit(L, &socket->b);
2016
2017 /* Check prefix. */
2018 if (lua_gettop(L) >= 3) {
2019 if (lua_type(L, 3) != LUA_TSTRING)
2020 WILL_LJMP(luaL_error(L, "Expect a 'string' for the prefix"));
2021 pattern = lua_tolstring(L, 3, &len);
2022 luaL_addlstring(&socket->b, pattern, len);
2023 }
2024
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002025 return __LJMP(hlua_socket_receive_yield(L, 0, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002026}
2027
2028/* Write the Lua input string in the output buffer.
Mark Lakes22154b42018-01-29 14:38:40 -08002029 * This function returns a yield if no space is available.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002030 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002031static int hlua_socket_write_yield(struct lua_State *L,int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002032{
2033 struct hlua_socket *socket;
2034 struct hlua *hlua = hlua_gethlua(L);
2035 struct appctx *appctx;
2036 size_t buf_len;
2037 const char *buf;
2038 int len;
2039 int send_len;
2040 int sent;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002041 struct xref *peer;
2042 struct stream_interface *si;
2043 struct stream *s;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002044
2045 /* Check if this lua stack is schedulable. */
2046 if (!hlua || !hlua->task)
2047 WILL_LJMP(luaL_error(L, "The 'write' function is only allowed in "
2048 "'frontend', 'backend' or 'task'"));
2049
2050 /* Get object */
2051 socket = MAY_LJMP(hlua_checksocket(L, 1));
2052 buf = MAY_LJMP(luaL_checklstring(L, 2, &buf_len));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002053 sent = MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002054
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002055 /* Check if we run on the same thread than the xreator thread.
2056 * We cannot access to the socket if the thread is different.
2057 */
2058 if (socket->tid != tid)
2059 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2060
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002061 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002062 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002063 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002064 lua_pushinteger(L, -1);
2065 return 1;
2066 }
2067 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2068 si = appctx->owner;
2069 s = si_strm(si);
2070
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002071 /* Check for connection close. */
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002072 if (channel_output_closed(&s->req)) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002073 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002074 lua_pushinteger(L, -1);
2075 return 1;
2076 }
2077
2078 /* Update the input buffer data. */
2079 buf += sent;
2080 send_len = buf_len - sent;
2081
2082 /* All the data are sent. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002083 if (sent >= buf_len) {
2084 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002085 return 1; /* Implicitly return the length sent. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002086 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002087
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002088 /* Check if the buffer is available because HAProxy doesn't allocate
Thierry FOURNIER486d52a2015-03-09 17:51:43 +01002089 * the request buffer if its not required.
2090 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002091 if (s->req.buf.size == 0) {
Willy Tarreau581abd32018-10-25 10:21:41 +02002092 if (!si_alloc_ibuf(si, &appctx->buffer_wait))
Christopher Faulet33834b12016-12-19 09:29:06 +01002093 goto hlua_socket_write_yield_return;
Thierry FOURNIER486d52a2015-03-09 17:51:43 +01002094 }
2095
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002096 /* Check for available space. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002097 len = b_room(&s->req.buf);
Christopher Faulet33834b12016-12-19 09:29:06 +01002098 if (len <= 0) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002099 goto hlua_socket_write_yield_return;
Christopher Faulet33834b12016-12-19 09:29:06 +01002100 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002101
2102 /* send data */
2103 if (len < send_len)
2104 send_len = len;
Thierry FOURNIER66b89192018-05-27 01:14:47 +02002105 len = ci_putblk(&s->req, buf, send_len);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002106
2107 /* "Not enough space" (-1), "Buffer too little to contain
2108 * the data" (-2) are not expected because the available length
2109 * is tested.
2110 * Other unknown error are also not expected.
2111 */
2112 if (len <= 0) {
Willy Tarreaubc18da12015-03-13 14:00:47 +01002113 if (len == -1)
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002114 s->req.flags |= CF_WAKE_WRITE;
Willy Tarreaubc18da12015-03-13 14:00:47 +01002115
sada05ed3302018-05-11 11:48:18 -07002116 MAY_LJMP(hlua_socket_close_helper(L));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002117 lua_pop(L, 1);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002118 lua_pushinteger(L, -1);
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002119 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002120 return 1;
2121 }
2122
2123 /* update buffers. */
Thierry FOURNIER101b9762018-05-27 01:27:40 +02002124 appctx_wakeup(appctx);
Willy Tarreaude70fa12015-09-26 11:25:05 +02002125
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002126 s->req.rex = TICK_ETERNITY;
2127 s->res.wex = TICK_ETERNITY;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002128
2129 /* Update length sent. */
2130 lua_pop(L, 1);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002131 lua_pushinteger(L, sent + len);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002132
2133 /* All the data buffer is sent ? */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002134 if (sent + len >= buf_len) {
2135 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002136 return 1;
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002137 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002138
2139hlua_socket_write_yield_return:
Thierry FOURNIERba42fcd2018-05-27 00:59:48 +02002140 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task)) {
2141 xref_unlock(&socket->xref, peer);
2142 WILL_LJMP(luaL_error(L, "out of memory"));
2143 }
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002144 xref_unlock(&socket->xref, peer);
Willy Tarreau9635e032018-10-16 17:52:55 +02002145 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_write_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002146 return 0;
2147}
2148
2149/* This function initiate the send of data. It just check the input
2150 * parameters and push an integer in the Lua stack that contain the
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002151 * amount of data written to the buffer. This is used by the function
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002152 * "hlua_socket_write_yield" that can yield.
2153 *
2154 * The Lua function gets between 3 and 4 parameters. The first one is
2155 * the associated object. The second is a string buffer. The third is
2156 * a facultative integer that represents where is the buffer position
2157 * of the start of the data that can send. The first byte is the
2158 * position "1". The default value is "1". The fourth argument is a
2159 * facultative integer that represents where is the buffer position
2160 * of the end of the data that can send. The default is the last byte.
2161 */
2162static int hlua_socket_send(struct lua_State *L)
2163{
2164 int i;
2165 int j;
2166 const char *buf;
2167 size_t buf_len;
2168
2169 /* Check number of arguments. */
2170 if (lua_gettop(L) < 2 || lua_gettop(L) > 4)
2171 WILL_LJMP(luaL_error(L, "'send' needs between 2 and 4 arguments"));
2172
2173 /* Get the string. */
2174 buf = MAY_LJMP(luaL_checklstring(L, 2, &buf_len));
2175
2176 /* Get and check j. */
2177 if (lua_gettop(L) == 4) {
2178 j = MAY_LJMP(luaL_checkinteger(L, 4));
2179 if (j < 0)
2180 j = buf_len + j + 1;
2181 if (j > buf_len)
2182 j = buf_len + 1;
2183 lua_pop(L, 1);
2184 }
2185 else
2186 j = buf_len;
2187
2188 /* Get and check i. */
2189 if (lua_gettop(L) == 3) {
2190 i = MAY_LJMP(luaL_checkinteger(L, 3));
2191 if (i < 0)
2192 i = buf_len + i + 1;
2193 if (i > buf_len)
2194 i = buf_len + 1;
2195 lua_pop(L, 1);
2196 } else
2197 i = 1;
2198
2199 /* Check bth i and j. */
2200 if (i > j) {
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002201 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002202 return 1;
2203 }
2204 if (i == 0 && j == 0) {
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002205 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002206 return 1;
2207 }
2208 if (i == 0)
2209 i = 1;
2210 if (j == 0)
2211 j = 1;
2212
2213 /* Pop the string. */
2214 lua_pop(L, 1);
2215
2216 /* Update the buffer length. */
2217 buf += i - 1;
2218 buf_len = j - i + 1;
2219 lua_pushlstring(L, buf, buf_len);
2220
2221 /* This unsigned is used to remember the amount of sent data. */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002222 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002223
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002224 return MAY_LJMP(hlua_socket_write_yield(L, 0, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002225}
2226
Willy Tarreau22b0a682015-06-17 19:43:49 +02002227#define SOCKET_INFO_MAX_LEN sizeof("[0000:0000:0000:0000:0000:0000:0000:0000]:12345")
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002228__LJMP static inline int hlua_socket_info(struct lua_State *L, struct sockaddr_storage *addr)
2229{
2230 static char buffer[SOCKET_INFO_MAX_LEN];
2231 int ret;
2232 int len;
2233 char *p;
2234
2235 ret = addr_to_str(addr, buffer+1, SOCKET_INFO_MAX_LEN-1);
2236 if (ret <= 0) {
2237 lua_pushnil(L);
2238 return 1;
2239 }
2240
2241 if (ret == AF_UNIX) {
2242 lua_pushstring(L, buffer+1);
2243 return 1;
2244 }
2245 else if (ret == AF_INET6) {
2246 buffer[0] = '[';
2247 len = strlen(buffer);
2248 buffer[len] = ']';
2249 len++;
2250 buffer[len] = ':';
2251 len++;
2252 p = buffer;
2253 }
2254 else if (ret == AF_INET) {
2255 p = buffer + 1;
2256 len = strlen(p);
2257 p[len] = ':';
2258 len++;
2259 }
2260 else {
2261 lua_pushnil(L);
2262 return 1;
2263 }
2264
2265 if (port_to_str(addr, p + len, SOCKET_INFO_MAX_LEN-1 - len) <= 0) {
2266 lua_pushnil(L);
2267 return 1;
2268 }
2269
2270 lua_pushstring(L, p);
2271 return 1;
2272}
2273
2274/* Returns information about the peer of the connection. */
2275__LJMP static int hlua_socket_getpeername(struct lua_State *L)
2276{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002277 struct hlua_socket *socket;
2278 struct connection *conn;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002279 struct xref *peer;
2280 struct appctx *appctx;
2281 struct stream_interface *si;
2282 struct stream *s;
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002283 int ret;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002284
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002285 MAY_LJMP(check_args(L, 1, "getpeername"));
2286
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002287 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002288
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002289 /* Check if we run on the same thread than the xreator thread.
2290 * We cannot access to the socket if the thread is different.
2291 */
2292 if (socket->tid != tid)
2293 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2294
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002295 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002296 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002297 if (!peer) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002298 lua_pushnil(L);
2299 return 1;
2300 }
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002301 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2302 si = appctx->owner;
2303 s = si_strm(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002304
Olivier Houchard9aaf7782017-09-13 18:30:23 +02002305 conn = cs_conn(objt_cs(s->si[1].end));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002306 if (!conn) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002307 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002308 lua_pushnil(L);
2309 return 1;
2310 }
2311
Willy Tarreaua71f6422016-11-16 17:00:14 +01002312 conn_get_to_addr(conn);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002313 if (!(conn->flags & CO_FL_ADDR_TO_SET)) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002314 xref_unlock(&socket->xref, peer);
Willy Tarreaua71f6422016-11-16 17:00:14 +01002315 lua_pushnil(L);
2316 return 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002317 }
2318
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002319 ret = MAY_LJMP(hlua_socket_info(L, &conn->addr.to));
2320 xref_unlock(&socket->xref, peer);
2321 return ret;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002322}
2323
2324/* Returns information about my connection side. */
2325static int hlua_socket_getsockname(struct lua_State *L)
2326{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002327 struct hlua_socket *socket;
2328 struct connection *conn;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002329 struct appctx *appctx;
2330 struct xref *peer;
2331 struct stream_interface *si;
2332 struct stream *s;
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002333 int ret;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002334
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002335 MAY_LJMP(check_args(L, 1, "getsockname"));
2336
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002337 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002338
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002339 /* Check if we run on the same thread than the xreator thread.
2340 * We cannot access to the socket if the thread is different.
2341 */
2342 if (socket->tid != tid)
2343 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2344
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002345 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002346 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002347 if (!peer) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002348 lua_pushnil(L);
2349 return 1;
2350 }
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002351 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2352 si = appctx->owner;
2353 s = si_strm(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002354
Olivier Houchard9aaf7782017-09-13 18:30:23 +02002355 conn = cs_conn(objt_cs(s->si[1].end));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002356 if (!conn) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002357 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002358 lua_pushnil(L);
2359 return 1;
2360 }
2361
Willy Tarreaua71f6422016-11-16 17:00:14 +01002362 conn_get_from_addr(conn);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002363 if (!(conn->flags & CO_FL_ADDR_FROM_SET)) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002364 xref_unlock(&socket->xref, peer);
Willy Tarreaua71f6422016-11-16 17:00:14 +01002365 lua_pushnil(L);
2366 return 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002367 }
2368
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002369 ret = hlua_socket_info(L, &conn->addr.from);
2370 xref_unlock(&socket->xref, peer);
2371 return ret;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002372}
2373
2374/* This struct define the applet. */
Willy Tarreau30576452015-04-13 13:50:30 +02002375static struct applet update_applet = {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002376 .obj_type = OBJ_TYPE_APPLET,
2377 .name = "<LUA_TCP>",
2378 .fct = hlua_socket_handler,
2379 .release = hlua_socket_release,
2380};
2381
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002382__LJMP static int hlua_socket_connect_yield(struct lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002383{
2384 struct hlua_socket *socket = MAY_LJMP(hlua_checksocket(L, 1));
2385 struct hlua *hlua = hlua_gethlua(L);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002386 struct xref *peer;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002387 struct appctx *appctx;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002388 struct stream_interface *si;
2389 struct stream *s;
2390
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002391 /* Check if we run on the same thread than the xreator thread.
2392 * We cannot access to the socket if the thread is different.
2393 */
2394 if (socket->tid != tid)
2395 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2396
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002397 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002398 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002399 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002400 lua_pushnil(L);
2401 lua_pushstring(L, "Can't connect");
2402 return 2;
2403 }
2404 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2405 si = appctx->owner;
2406 s = si_strm(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002407
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002408 /* Check if we run on the same thread than the xreator thread.
2409 * We cannot access to the socket if the thread is different.
2410 */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002411 if (socket->tid != tid) {
2412 xref_unlock(&socket->xref, peer);
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002413 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002414 }
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002415
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002416 /* Check for connection close. */
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002417 if (!hlua || channel_output_closed(&s->req)) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002418 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002419 lua_pushnil(L);
2420 lua_pushstring(L, "Can't connect");
2421 return 2;
2422 }
2423
Willy Tarreaue09101e2018-10-16 17:37:12 +02002424 appctx = __objt_appctx(s->si[0].end);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002425
2426 /* Check for connection established. */
Thierry FOURNIER18d09902016-12-16 09:25:38 +01002427 if (appctx->ctx.hlua_cosocket.connected) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002428 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002429 lua_pushinteger(L, 1);
2430 return 1;
2431 }
2432
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002433 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task)) {
2434 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002435 WILL_LJMP(luaL_error(L, "out of memory error"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002436 }
2437 xref_unlock(&socket->xref, peer);
Willy Tarreau9635e032018-10-16 17:52:55 +02002438 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_connect_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002439 return 0;
2440}
2441
2442/* This function fail or initite the connection. */
2443__LJMP static int hlua_socket_connect(struct lua_State *L)
2444{
2445 struct hlua_socket *socket;
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002446 int port = -1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002447 const char *ip;
2448 struct connection *conn;
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002449 struct hlua *hlua;
2450 struct appctx *appctx;
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002451 int low, high;
2452 struct sockaddr_storage *addr;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002453 struct xref *peer;
2454 struct stream_interface *si;
2455 struct stream *s;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002456
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002457 if (lua_gettop(L) < 2)
2458 WILL_LJMP(luaL_error(L, "connect: need at least 2 arguments"));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002459
2460 /* Get args. */
2461 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002462
2463 /* Check if we run on the same thread than the xreator thread.
2464 * We cannot access to the socket if the thread is different.
2465 */
2466 if (socket->tid != tid)
2467 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2468
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002469 ip = MAY_LJMP(luaL_checkstring(L, 2));
Tim Duesterhus6edab862018-01-06 19:04:45 +01002470 if (lua_gettop(L) >= 3) {
2471 luaL_Buffer b;
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002472 port = MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002473
Tim Duesterhus6edab862018-01-06 19:04:45 +01002474 /* Force the ip to end with a colon, to support IPv6 addresses
2475 * that are not enclosed within square brackets.
2476 */
2477 if (port > 0) {
2478 luaL_buffinit(L, &b);
2479 luaL_addstring(&b, ip);
2480 luaL_addchar(&b, ':');
2481 luaL_pushresult(&b);
2482 ip = lua_tolstring(L, lua_gettop(L), NULL);
2483 }
2484 }
2485
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002486 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002487 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002488 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002489 lua_pushnil(L);
2490 return 1;
2491 }
2492 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2493 si = appctx->owner;
2494 s = si_strm(si);
2495
2496 /* Initialise connection. */
Olivier Houchard9aaf7782017-09-13 18:30:23 +02002497 conn = cs_conn(si_alloc_cs(&s->si[1], NULL));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002498 if (!conn) {
2499 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002500 WILL_LJMP(luaL_error(L, "connect: internal error"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002501 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002502
Willy Tarreau3adac082015-09-26 17:51:09 +02002503 /* needed for the connection not to be closed */
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002504 conn->target = s->target;
Willy Tarreau3adac082015-09-26 17:51:09 +02002505
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002506 /* Parse ip address. */
Willy Tarreau48ef4c92017-01-06 18:32:38 +01002507 addr = str2sa_range(ip, NULL, &low, &high, NULL, NULL, NULL, 0);
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002508 if (!addr) {
2509 xref_unlock(&socket->xref, peer);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002510 WILL_LJMP(luaL_error(L, "connect: cannot parse destination address '%s'", ip));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002511 }
2512 if (low != high) {
2513 xref_unlock(&socket->xref, peer);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002514 WILL_LJMP(luaL_error(L, "connect: port ranges not supported : address '%s'", ip));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002515 }
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002516 memcpy(&conn->addr.to, addr, sizeof(struct sockaddr_storage));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002517
2518 /* Set port. */
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002519 if (low == 0) {
2520 if (conn->addr.to.ss_family == AF_INET) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002521 if (port == -1) {
2522 xref_unlock(&socket->xref, peer);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002523 WILL_LJMP(luaL_error(L, "connect: port missing"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002524 }
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002525 ((struct sockaddr_in *)&conn->addr.to)->sin_port = htons(port);
2526 } else if (conn->addr.to.ss_family == AF_INET6) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002527 if (port == -1) {
2528 xref_unlock(&socket->xref, peer);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002529 WILL_LJMP(luaL_error(L, "connect: port missing"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002530 }
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002531 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_port = htons(port);
2532 }
2533 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002534
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002535 hlua = hlua_gethlua(L);
Willy Tarreaue09101e2018-10-16 17:37:12 +02002536 appctx = __objt_appctx(s->si[0].end);
Willy Tarreaubdc97a82015-08-24 15:42:28 +02002537
2538 /* inform the stream that we want to be notified whenever the
2539 * connection completes.
2540 */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002541 si_cant_get(&s->si[0]);
Willy Tarreau3367d412018-11-15 10:57:41 +01002542 si_rx_endp_more(&s->si[0]);
Thierry FOURNIER8c8fbbe2015-09-26 17:02:35 +02002543 appctx_wakeup(appctx);
Willy Tarreaubdc97a82015-08-24 15:42:28 +02002544
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +02002545 hlua->flags |= HLUA_MUST_GC;
2546
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002547 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task)) {
2548 xref_unlock(&socket->xref, peer);
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002549 WILL_LJMP(luaL_error(L, "out of memory"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002550 }
2551 xref_unlock(&socket->xref, peer);
PiBa-NL706d5ee2018-05-05 23:51:42 +02002552
2553 task_wakeup(s->task, TASK_WOKEN_INIT);
2554 /* Return yield waiting for connection. */
2555
Willy Tarreau9635e032018-10-16 17:52:55 +02002556 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_connect_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002557
2558 return 0;
2559}
2560
Baptiste Assmann84bb4932015-03-02 21:40:06 +01002561#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002562__LJMP static int hlua_socket_connect_ssl(struct lua_State *L)
2563{
2564 struct hlua_socket *socket;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002565 struct xref *peer;
2566 struct appctx *appctx;
2567 struct stream_interface *si;
2568 struct stream *s;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002569
2570 MAY_LJMP(check_args(L, 3, "connect_ssl"));
2571 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002572
2573 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002574 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002575 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002576 lua_pushnil(L);
2577 return 1;
2578 }
2579 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2580 si = appctx->owner;
2581 s = si_strm(si);
2582
2583 s->target = &socket_ssl.obj_type;
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002584 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002585 return MAY_LJMP(hlua_socket_connect(L));
2586}
Baptiste Assmann84bb4932015-03-02 21:40:06 +01002587#endif
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002588
2589__LJMP static int hlua_socket_setoption(struct lua_State *L)
2590{
2591 return 0;
2592}
2593
2594__LJMP static int hlua_socket_settimeout(struct lua_State *L)
2595{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002596 struct hlua_socket *socket;
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002597 int tmout;
Mark Lakes56cc1252018-03-27 09:48:06 +02002598 double dtmout;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002599 struct xref *peer;
2600 struct appctx *appctx;
2601 struct stream_interface *si;
2602 struct stream *s;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002603
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002604 MAY_LJMP(check_args(L, 2, "settimeout"));
2605
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002606 socket = MAY_LJMP(hlua_checksocket(L, 1));
Mark Lakes56cc1252018-03-27 09:48:06 +02002607
Cyril Bonté7ee465f2018-08-19 22:08:50 +02002608 /* convert the timeout to millis */
2609 dtmout = MAY_LJMP(luaL_checknumber(L, 2)) * 1000;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002610
Thierry Fournier17a921b2018-03-08 09:59:02 +01002611 /* Check for negative values */
Mark Lakes56cc1252018-03-27 09:48:06 +02002612 if (dtmout < 0)
Thierry Fournier17a921b2018-03-08 09:59:02 +01002613 WILL_LJMP(luaL_error(L, "settimeout: cannot set negatives values"));
2614
Mark Lakes56cc1252018-03-27 09:48:06 +02002615 if (dtmout > INT_MAX) /* overflow check */
Cyril Bonté7ee465f2018-08-19 22:08:50 +02002616 WILL_LJMP(luaL_error(L, "settimeout: cannot set values larger than %d ms", INT_MAX));
Mark Lakes56cc1252018-03-27 09:48:06 +02002617
2618 tmout = MS_TO_TICKS((int)dtmout);
Cyril Bonté7ee465f2018-08-19 22:08:50 +02002619 if (tmout == 0)
2620 tmout++; /* very small timeouts are adjusted to a minium of 1ms */
Mark Lakes56cc1252018-03-27 09:48:06 +02002621
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002622 /* Check if we run on the same thread than the xreator thread.
2623 * We cannot access to the socket if the thread is different.
2624 */
2625 if (socket->tid != tid)
2626 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2627
Mark Lakes56cc1252018-03-27 09:48:06 +02002628 /* check for connection break. If some data were read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002629 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002630 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002631 hlua_pusherror(L, "socket: not yet initialised, you can't set timeouts.");
2632 WILL_LJMP(lua_error(L));
2633 return 0;
2634 }
2635 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2636 si = appctx->owner;
2637 s = si_strm(si);
2638
Cyril Bonté7bb63452018-08-17 23:51:02 +02002639 s->sess->fe->timeout.connect = tmout;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002640 s->req.rto = tmout;
2641 s->req.wto = tmout;
2642 s->res.rto = tmout;
2643 s->res.wto = tmout;
Cyril Bonté7bb63452018-08-17 23:51:02 +02002644 s->req.rex = tick_add_ifset(now_ms, tmout);
2645 s->req.wex = tick_add_ifset(now_ms, tmout);
2646 s->res.rex = tick_add_ifset(now_ms, tmout);
2647 s->res.wex = tick_add_ifset(now_ms, tmout);
2648
2649 s->task->expire = tick_add_ifset(now_ms, tmout);
2650 task_queue(s->task);
2651
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002652 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002653
Thierry Fourniere9636f12018-03-08 09:54:32 +01002654 lua_pushinteger(L, 1);
Tim Duesterhus119a5f12018-01-06 19:16:25 +01002655 return 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002656}
2657
2658__LJMP static int hlua_socket_new(lua_State *L)
2659{
2660 struct hlua_socket *socket;
2661 struct appctx *appctx;
Willy Tarreau15b5e142015-04-04 14:38:25 +02002662 struct session *sess;
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002663 struct stream *strm;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002664
2665 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002666 if (!lua_checkstack(L, 3)) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002667 hlua_pusherror(L, "socket: full stack");
2668 goto out_fail_conf;
2669 }
2670
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002671 /* Create the object: obj[0] = userdata. */
2672 lua_newtable(L);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002673 socket = MAY_LJMP(lua_newuserdata(L, sizeof(*socket)));
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002674 lua_rawseti(L, -2, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002675 memset(socket, 0, sizeof(*socket));
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002676 socket->tid = tid;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002677
Thierry FOURNIER4a6170c2015-03-09 17:07:10 +01002678 /* Check if the various memory pools are intialized. */
Willy Tarreaubafbe012017-11-24 17:34:44 +01002679 if (!pool_head_stream || !pool_head_buffer) {
Thierry FOURNIER4a6170c2015-03-09 17:07:10 +01002680 hlua_pusherror(L, "socket: uninitialized pools.");
2681 goto out_fail_conf;
2682 }
2683
Willy Tarreau87b09662015-04-03 00:22:06 +02002684 /* Pop a class stream metatable and affect it to the userdata. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002685 lua_rawgeti(L, LUA_REGISTRYINDEX, class_socket_ref);
2686 lua_setmetatable(L, -2);
2687
Willy Tarreaud420a972015-04-06 00:39:18 +02002688 /* Create the applet context */
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01002689 appctx = appctx_new(&update_applet, tid_bit);
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002690 if (!appctx) {
2691 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaufeb76402015-04-03 14:10:06 +02002692 goto out_fail_conf;
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002693 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002694
Thierry FOURNIER18d09902016-12-16 09:25:38 +01002695 appctx->ctx.hlua_cosocket.connected = 0;
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02002696 appctx->ctx.hlua_cosocket.die = 0;
Thierry FOURNIER18d09902016-12-16 09:25:38 +01002697 LIST_INIT(&appctx->ctx.hlua_cosocket.wake_on_write);
2698 LIST_INIT(&appctx->ctx.hlua_cosocket.wake_on_read);
Willy Tarreaub2bf8332015-04-04 15:58:58 +02002699
Willy Tarreaud420a972015-04-06 00:39:18 +02002700 /* Now create a session, task and stream for this applet */
2701 sess = session_new(&socket_proxy, NULL, &appctx->obj_type);
2702 if (!sess) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002703 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaud420a972015-04-06 00:39:18 +02002704 goto out_fail_sess;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002705 }
2706
Willy Tarreau87787ac2017-08-28 16:22:54 +02002707 strm = stream_new(sess, &appctx->obj_type);
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002708 if (!strm) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002709 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaud420a972015-04-06 00:39:18 +02002710 goto out_fail_stream;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002711 }
2712
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002713 /* Initialise cross reference between stream and Lua socket object. */
2714 xref_create(&socket->xref, &appctx->ctx.hlua_cosocket.xref);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002715
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002716 /* Configure "right" stream interface. this "si" is used to connect
2717 * and retrieve data from the server. The connection is initialized
2718 * with the "struct server".
2719 */
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002720 si_set_state(&strm->si[1], SI_ST_ASS);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002721
2722 /* Force destination server. */
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002723 strm->flags |= SF_DIRECT | SF_ASSIGNED | SF_ADDR_SET | SF_BE_ASSIGNED;
2724 strm->target = &socket_tcp.obj_type;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002725
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002726 return 1;
2727
Willy Tarreaud420a972015-04-06 00:39:18 +02002728 out_fail_stream:
Willy Tarreau11c36242015-04-04 15:54:03 +02002729 session_free(sess);
Willy Tarreaud420a972015-04-06 00:39:18 +02002730 out_fail_sess:
2731 appctx_free(appctx);
2732 out_fail_conf:
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002733 WILL_LJMP(lua_error(L));
2734 return 0;
2735}
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01002736
2737/*
2738 *
2739 *
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002740 * Class Channel
2741 *
2742 *
2743 */
2744
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01002745/* This function is called before the Lua execution. It stores
2746 * the differents parsers state before executing some Lua code.
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002747 */
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01002748static inline void consistency_set(struct stream *stream, int opt, struct hlua_consistency *c)
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002749{
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01002750 c->mode = stream->be->mode;
2751 switch (c->mode) {
2752 case PR_MODE_HTTP:
2753 c->data.http.dir = opt & SMP_OPT_DIR;
2754 if (c->data.http.dir == SMP_OPT_DIR_REQ)
2755 c->data.http.state = stream->txn->req.msg_state;
2756 else
2757 c->data.http.state = stream->txn->rsp.msg_state;
2758 break;
2759 default:
2760 break;
2761 }
2762}
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002763
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01002764/* This function is called after the Lua execution. it
2765 * returns true if the parser state is consistent, otherwise,
2766 * it return false.
2767 *
2768 * In HTTP mode, the parser state must be in the same state
2769 * or greater when we exit the function. Even if we do a
2770 * control yield. This prevent to break the HTTP message
2771 * from the Lua code.
2772 */
2773static inline int consistency_check(struct stream *stream, int opt, struct hlua_consistency *c)
2774{
2775 if (c->mode != stream->be->mode)
2776 return 0;
2777
2778 switch (c->mode) {
2779 case PR_MODE_HTTP:
2780 if (c->data.http.dir != (opt & SMP_OPT_DIR))
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002781 return 0;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01002782 if (c->data.http.dir == SMP_OPT_DIR_REQ)
2783 return stream->txn->req.msg_state >= c->data.http.state;
2784 else
2785 return stream->txn->rsp.msg_state >= c->data.http.state;
2786 default:
2787 return 1;
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002788 }
2789 return 1;
2790}
2791
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002792/* Returns the struct hlua_channel join to the class channel in the
2793 * stack entry "ud" or throws an argument error.
2794 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002795__LJMP static struct channel *hlua_checkchannel(lua_State *L, int ud)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002796{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002797 return MAY_LJMP(hlua_checkudata(L, ud, class_channel_ref));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002798}
2799
Willy Tarreau47860ed2015-03-10 14:07:50 +01002800/* Pushes the channel onto the top of the stack. If the stask does not have a
2801 * free slots, the function fails and returns 0;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002802 */
Willy Tarreau2a71af42015-03-10 13:51:50 +01002803static int hlua_channel_new(lua_State *L, struct channel *channel)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002804{
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002805 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002806 if (!lua_checkstack(L, 3))
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002807 return 0;
2808
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002809 lua_newtable(L);
Willy Tarreau47860ed2015-03-10 14:07:50 +01002810 lua_pushlightuserdata(L, channel);
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002811 lua_rawseti(L, -2, 0);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002812
2813 /* Pop a class sesison metatable and affect it to the userdata. */
2814 lua_rawgeti(L, LUA_REGISTRYINDEX, class_channel_ref);
2815 lua_setmetatable(L, -2);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002816 return 1;
2817}
2818
2819/* Duplicate all the data present in the input channel and put it
2820 * in a string LUA variables. Returns -1 and push a nil value in
2821 * the stack if the channel is closed and all the data are consumed,
2822 * returns 0 if no data are available, otherwise it returns the length
2823 * of the builded string.
2824 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002825static inline int _hlua_channel_dup(struct channel *chn, lua_State *L)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002826{
2827 char *blk1;
2828 char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02002829 size_t len1;
2830 size_t len2;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002831 int ret;
2832 luaL_Buffer b;
2833
Willy Tarreau06d80a92017-10-19 14:32:15 +02002834 ret = ci_getblk_nc(chn, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002835 if (unlikely(ret == 0))
2836 return 0;
2837
2838 if (unlikely(ret < 0)) {
2839 lua_pushnil(L);
2840 return -1;
2841 }
2842
2843 luaL_buffinit(L, &b);
2844 luaL_addlstring(&b, blk1, len1);
2845 if (unlikely(ret == 2))
2846 luaL_addlstring(&b, blk2, len2);
2847 luaL_pushresult(&b);
2848
2849 if (unlikely(ret == 2))
2850 return len1 + len2;
2851 return len1;
2852}
2853
2854/* "_hlua_channel_dup" wrapper. If no data are available, it returns
2855 * a yield. This function keep the data in the buffer.
2856 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002857__LJMP static int hlua_channel_dup_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002858{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002859 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002860
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002861 chn = MAY_LJMP(hlua_checkchannel(L, 1));
2862
Christopher Faulet3f829a42018-12-13 21:56:45 +01002863 if (chn_strm(chn)->be->mode == PR_MODE_HTTP)
2864 WILL_LJMP(lua_error(L));
2865
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002866 if (_hlua_channel_dup(chn, L) == 0)
Willy Tarreau9635e032018-10-16 17:52:55 +02002867 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_dup_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002868 return 1;
2869}
2870
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002871/* Check arguments for the function "hlua_channel_dup_yield". */
2872__LJMP static int hlua_channel_dup(lua_State *L)
2873{
2874 MAY_LJMP(check_args(L, 1, "dup"));
2875 MAY_LJMP(hlua_checkchannel(L, 1));
2876 return MAY_LJMP(hlua_channel_dup_yield(L, 0, 0));
2877}
2878
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002879/* "_hlua_channel_dup" wrapper. If no data are available, it returns
2880 * a yield. This function consumes the data in the buffer. It returns
2881 * a string containing the data or a nil pointer if no data are available
2882 * and the channel is closed.
2883 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002884__LJMP static int hlua_channel_get_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002885{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002886 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002887 int ret;
2888
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002889 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002890
Christopher Faulet3f829a42018-12-13 21:56:45 +01002891 if (chn_strm(chn)->be->mode == PR_MODE_HTTP)
2892 WILL_LJMP(lua_error(L));
2893
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002894 ret = _hlua_channel_dup(chn, L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002895 if (unlikely(ret == 0))
Willy Tarreau9635e032018-10-16 17:52:55 +02002896 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_get_yield, TICK_ETERNITY, 0));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002897
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002898 if (unlikely(ret == -1))
2899 return 1;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002900
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002901 b_sub(&chn->buf, ret);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002902 return 1;
2903}
2904
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002905/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002906__LJMP static int hlua_channel_get(lua_State *L)
2907{
2908 MAY_LJMP(check_args(L, 1, "get"));
2909 MAY_LJMP(hlua_checkchannel(L, 1));
2910 return MAY_LJMP(hlua_channel_get_yield(L, 0, 0));
2911}
2912
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002913/* This functions consumes and returns one line. If the channel is closed,
2914 * and the last data does not contains a final '\n', the data are returned
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002915 * without the final '\n'. When no more data are available, it returns nil
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002916 * value.
2917 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002918__LJMP static int hlua_channel_getline_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002919{
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002920 char *blk1;
2921 char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02002922 size_t len1;
2923 size_t len2;
2924 size_t len;
Willy Tarreau47860ed2015-03-10 14:07:50 +01002925 struct channel *chn;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002926 int ret;
2927 luaL_Buffer b;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002928
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002929 chn = MAY_LJMP(hlua_checkchannel(L, 1));
2930
Christopher Faulet3f829a42018-12-13 21:56:45 +01002931 if (chn_strm(chn)->be->mode == PR_MODE_HTTP)
2932 WILL_LJMP(lua_error(L));
2933
Willy Tarreau06d80a92017-10-19 14:32:15 +02002934 ret = ci_getline_nc(chn, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002935 if (ret == 0)
Willy Tarreau9635e032018-10-16 17:52:55 +02002936 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_getline_yield, TICK_ETERNITY, 0));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002937
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002938 if (ret == -1) {
2939 lua_pushnil(L);
2940 return 1;
2941 }
2942
2943 luaL_buffinit(L, &b);
2944 luaL_addlstring(&b, blk1, len1);
2945 len = len1;
2946 if (unlikely(ret == 2)) {
2947 luaL_addlstring(&b, blk2, len2);
2948 len += len2;
2949 }
2950 luaL_pushresult(&b);
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002951 b_rep_blk(&chn->buf, ci_head(chn), ci_head(chn) + len, NULL, 0);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002952 return 1;
2953}
2954
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002955/* Check arguments for the function "hlua_channel_getline_yield". */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002956__LJMP static int hlua_channel_getline(lua_State *L)
2957{
2958 MAY_LJMP(check_args(L, 1, "getline"));
2959 MAY_LJMP(hlua_checkchannel(L, 1));
2960 return MAY_LJMP(hlua_channel_getline_yield(L, 0, 0));
2961}
2962
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002963/* This function takes a string as input, and append it at the
2964 * input side of channel. If the data is too big, but a space
2965 * is probably available after sending some data, the function
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002966 * yields. If the data is bigger than the buffer, or if the
2967 * channel is closed, it returns -1. Otherwise, it returns the
2968 * amount of data written.
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002969 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002970__LJMP static int hlua_channel_append_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002971{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002972 struct channel *chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002973 size_t len;
2974 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
2975 int l = MAY_LJMP(luaL_checkinteger(L, 3));
2976 int ret;
2977 int max;
2978
Christopher Faulet3f829a42018-12-13 21:56:45 +01002979 if (chn_strm(chn)->be->mode == PR_MODE_HTTP)
2980 WILL_LJMP(lua_error(L));
2981
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002982 /* Check if the buffer is available because HAProxy doesn't allocate
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002983 * the request buffer if its not required.
2984 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002985 if (chn->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +01002986 si_rx_buff_blk(chn_prod(chn));
Willy Tarreau9635e032018-10-16 17:52:55 +02002987 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002988 }
2989
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002990 max = channel_recv_limit(chn) - b_data(&chn->buf);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002991 if (max > len - l)
2992 max = len - l;
2993
Willy Tarreau06d80a92017-10-19 14:32:15 +02002994 ret = ci_putblk(chn, str + l, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002995 if (ret == -2 || ret == -3) {
2996 lua_pushinteger(L, -1);
2997 return 1;
2998 }
Willy Tarreaubc18da12015-03-13 14:00:47 +01002999 if (ret == -1) {
3000 chn->flags |= CF_WAKE_WRITE;
Willy Tarreau9635e032018-10-16 17:52:55 +02003001 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
Willy Tarreaubc18da12015-03-13 14:00:47 +01003002 }
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003003 l += ret;
3004 lua_pop(L, 1);
3005 lua_pushinteger(L, l);
3006
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003007 max = channel_recv_limit(chn) - b_data(&chn->buf);
Willy Tarreaua79021a2018-06-15 18:07:57 +02003008 if (max == 0 && co_data(chn) == 0) {
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003009 /* There are no space available, and the output buffer is empty.
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003010 * in this case, we cannot add more data, so we cannot yield,
3011 * we return the amount of copyied data.
3012 */
3013 return 1;
3014 }
3015 if (l < len)
Willy Tarreau9635e032018-10-16 17:52:55 +02003016 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003017 return 1;
3018}
3019
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003020/* Just a wrapper of "hlua_channel_append_yield". It returns the length
3021 * of the written string, or -1 if the channel is closed or if the
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003022 * buffer size is too little for the data.
3023 */
3024__LJMP static int hlua_channel_append(lua_State *L)
3025{
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003026 size_t len;
3027
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003028 MAY_LJMP(check_args(L, 2, "append"));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003029 MAY_LJMP(hlua_checkchannel(L, 1));
3030 MAY_LJMP(luaL_checklstring(L, 2, &len));
3031 MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003032 lua_pushinteger(L, 0);
3033
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003034 return MAY_LJMP(hlua_channel_append_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003035}
3036
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003037/* Just a wrapper of "hlua_channel_append_yield". This wrapper starts
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003038 * his process by cleaning the buffer. The result is a replacement
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003039 * of the current data. It returns the length of the written string,
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003040 * or -1 if the channel is closed or if the buffer size is too
3041 * little for the data.
3042 */
3043__LJMP static int hlua_channel_set(lua_State *L)
3044{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003045 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003046
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003047 MAY_LJMP(check_args(L, 2, "set"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003048 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003049 lua_pushinteger(L, 0);
3050
Christopher Faulet3f829a42018-12-13 21:56:45 +01003051 if (chn_strm(chn)->be->mode == PR_MODE_HTTP)
3052 WILL_LJMP(lua_error(L));
3053
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003054 b_set_data(&chn->buf, co_data(chn));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003055
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003056 return MAY_LJMP(hlua_channel_append_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003057}
3058
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003059/* Append data in the output side of the buffer. This data is immediately
3060 * sent. The function returns the amount of data written. If the buffer
3061 * cannot contain the data, the function yields. The function returns -1
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003062 * if the channel is closed.
3063 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003064__LJMP static int hlua_channel_send_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003065{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003066 struct channel *chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003067 size_t len;
3068 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
3069 int l = MAY_LJMP(luaL_checkinteger(L, 3));
3070 int max;
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003071 struct hlua *hlua = hlua_gethlua(L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003072
Christopher Faulet3f829a42018-12-13 21:56:45 +01003073 if (chn_strm(chn)->be->mode == PR_MODE_HTTP)
3074 WILL_LJMP(lua_error(L));
3075
Willy Tarreau47860ed2015-03-10 14:07:50 +01003076 if (unlikely(channel_output_closed(chn))) {
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003077 lua_pushinteger(L, -1);
3078 return 1;
3079 }
3080
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003081 /* Check if the buffer is available because HAProxy doesn't allocate
Thierry FOURNIER3e3a6082015-03-05 17:06:12 +01003082 * the request buffer if its not required.
3083 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003084 if (chn->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +01003085 si_rx_buff_blk(chn_prod(chn));
Willy Tarreau9635e032018-10-16 17:52:55 +02003086 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIER3e3a6082015-03-05 17:06:12 +01003087 }
3088
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003089 /* The written data will be immediately sent, so we can check
3090 * the available space without taking in account the reserve.
3091 * The reserve is guaranteed for the processing of incoming
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003092 * data, because the buffer will be flushed.
3093 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003094 max = b_room(&chn->buf);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003095
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003096 /* If there is no space available, and the output buffer is empty.
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003097 * in this case, we cannot add more data, so we cannot yield,
3098 * we return the amount of copyied data.
3099 */
Willy Tarreaua79021a2018-06-15 18:07:57 +02003100 if (max == 0 && co_data(chn) == 0)
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003101 return 1;
3102
3103 /* Adjust the real required length. */
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003104 if (max > len - l)
3105 max = len - l;
3106
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003107 /* The buffer available size may be not contiguous. This test
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003108 * detects a non contiguous buffer and realign it.
3109 */
Willy Tarreau3f679992018-06-15 15:06:42 +02003110 if (ci_space_for_replace(chn) < max)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003111 channel_slow_realign(chn, trash.area);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003112
3113 /* Copy input data in the buffer. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003114 max = b_rep_blk(&chn->buf, ci_head(chn), ci_head(chn), str + l, max);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003115
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003116 /* buffer replace considers that the input part is filled.
3117 * so, I must forward these new data in the output part.
3118 */
Willy Tarreaubcbd3932018-06-06 07:13:22 +02003119 c_adv(chn, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003120
3121 l += max;
3122 lua_pop(L, 1);
3123 lua_pushinteger(L, l);
3124
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003125 /* If there is no space available, and the output buffer is empty.
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003126 * in this case, we cannot add more data, so we cannot yield,
3127 * we return the amount of copyied data.
3128 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003129 max = b_room(&chn->buf);
Willy Tarreaua79021a2018-06-15 18:07:57 +02003130 if (max == 0 && co_data(chn) == 0)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003131 return 1;
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003132
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003133 if (l < len) {
3134 /* If we are waiting for space in the response buffer, we
3135 * must set the flag WAKERESWR. This flag required the task
3136 * wake up if any activity is detected on the response buffer.
3137 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01003138 if (chn->flags & CF_ISRESP)
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003139 HLUA_SET_WAKERESWR(hlua);
Thierry FOURNIER53e08ec2015-03-06 00:35:53 +01003140 else
3141 HLUA_SET_WAKEREQWR(hlua);
Willy Tarreau9635e032018-10-16 17:52:55 +02003142 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003143 }
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003144
3145 return 1;
3146}
3147
3148/* Just a wraper of "_hlua_channel_send". This wrapper permits
3149 * yield the LUA process, and resume it without checking the
3150 * input arguments.
3151 */
3152__LJMP static int hlua_channel_send(lua_State *L)
3153{
3154 MAY_LJMP(check_args(L, 2, "send"));
3155 lua_pushinteger(L, 0);
3156
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003157 return MAY_LJMP(hlua_channel_send_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003158}
3159
3160/* This function forward and amount of butes. The data pass from
3161 * the input side of the buffer to the output side, and can be
3162 * forwarded. This function never fails.
3163 *
3164 * The Lua function takes an amount of bytes to be forwarded in
3165 * imput. It returns the number of bytes forwarded.
3166 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003167__LJMP static int hlua_channel_forward_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003168{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003169 struct channel *chn;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003170 int len;
3171 int l;
3172 int max;
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003173 struct hlua *hlua = hlua_gethlua(L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003174
3175 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Christopher Faulet3f829a42018-12-13 21:56:45 +01003176
3177 if (chn_strm(chn)->be->mode == PR_MODE_HTTP)
3178 WILL_LJMP(lua_error(L));
3179
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003180 len = MAY_LJMP(luaL_checkinteger(L, 2));
3181 l = MAY_LJMP(luaL_checkinteger(L, -1));
3182
3183 max = len - l;
Willy Tarreaua79021a2018-06-15 18:07:57 +02003184 if (max > ci_data(chn))
3185 max = ci_data(chn);
Willy Tarreau47860ed2015-03-10 14:07:50 +01003186 channel_forward(chn, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003187 l += max;
3188
3189 lua_pop(L, 1);
3190 lua_pushinteger(L, l);
3191
3192 /* Check if it miss bytes to forward. */
3193 if (l < len) {
3194 /* The the input channel or the output channel are closed, we
3195 * must return the amount of data forwarded.
3196 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01003197 if (channel_input_closed(chn) || channel_output_closed(chn))
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003198 return 1;
3199
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003200 /* If we are waiting for space data in the response buffer, we
3201 * must set the flag WAKERESWR. This flag required the task
3202 * wake up if any activity is detected on the response buffer.
3203 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01003204 if (chn->flags & CF_ISRESP)
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003205 HLUA_SET_WAKERESWR(hlua);
Thierry FOURNIER53e08ec2015-03-06 00:35:53 +01003206 else
3207 HLUA_SET_WAKEREQWR(hlua);
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003208
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003209 /* Otherwise, we can yield waiting for new data in the inpout side. */
Willy Tarreau9635e032018-10-16 17:52:55 +02003210 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_forward_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003211 }
3212
3213 return 1;
3214}
3215
3216/* Just check the input and prepare the stack for the previous
3217 * function "hlua_channel_forward_yield"
3218 */
3219__LJMP static int hlua_channel_forward(lua_State *L)
3220{
3221 MAY_LJMP(check_args(L, 2, "forward"));
3222 MAY_LJMP(hlua_checkchannel(L, 1));
3223 MAY_LJMP(luaL_checkinteger(L, 2));
3224
3225 lua_pushinteger(L, 0);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003226 return MAY_LJMP(hlua_channel_forward_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003227}
3228
3229/* Just returns the number of bytes available in the input
3230 * side of the buffer. This function never fails.
3231 */
3232__LJMP static int hlua_channel_get_in_len(lua_State *L)
3233{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003234 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003235
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003236 MAY_LJMP(check_args(L, 1, "get_in_len"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003237 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Christopher Fauleta3ceac12018-12-14 13:39:09 +01003238 if (IS_HTX_STRM(chn_strm(chn))) {
3239 struct htx *htx = htxbuf(&chn->buf);
3240 lua_pushinteger(L, htx->data - co_data(chn));
3241 }
3242 else
3243 lua_pushinteger(L, ci_data(chn));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003244 return 1;
3245}
3246
Thierry FOURNIER / OZON.IO65192f32016-11-07 15:28:40 +01003247/* Returns true if the channel is full. */
3248__LJMP static int hlua_channel_is_full(lua_State *L)
3249{
3250 struct channel *chn;
Thierry FOURNIER / OZON.IO65192f32016-11-07 15:28:40 +01003251
3252 MAY_LJMP(check_args(L, 1, "is_full"));
3253 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Christopher Faulet0136ebb2020-02-26 11:59:19 +01003254 /* ignore the reserve, we are not on a producer side (ie in an
3255 * applet).
3256 */
3257 lua_pushboolean(L, channel_full(chn, 0));
Thierry FOURNIER / OZON.IO65192f32016-11-07 15:28:40 +01003258 return 1;
3259}
3260
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003261/* Just returns the number of bytes available in the output
3262 * side of the buffer. This function never fails.
3263 */
3264__LJMP static int hlua_channel_get_out_len(lua_State *L)
3265{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003266 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003267
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003268 MAY_LJMP(check_args(L, 1, "get_out_len"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003269 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Willy Tarreaua79021a2018-06-15 18:07:57 +02003270 lua_pushinteger(L, co_data(chn));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003271 return 1;
3272}
3273
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003274/*
3275 *
3276 *
3277 * Class Fetches
3278 *
3279 *
3280 */
3281
3282/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02003283 * a class stream, otherwise it throws an error.
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003284 */
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003285__LJMP static struct hlua_smp *hlua_checkfetches(lua_State *L, int ud)
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003286{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003287 return MAY_LJMP(hlua_checkudata(L, ud, class_fetches_ref));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003288}
3289
3290/* This function creates and push in the stack a fetch object according
3291 * with a current TXN.
3292 */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003293static int hlua_fetches_new(lua_State *L, struct hlua_txn *txn, unsigned int flags)
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003294{
Willy Tarreau7073c472015-04-06 11:15:40 +02003295 struct hlua_smp *hsmp;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003296
3297 /* Check stack size. */
3298 if (!lua_checkstack(L, 3))
3299 return 0;
3300
3301 /* Create the object: obj[0] = userdata.
3302 * Note that the base of the Fetches object is the
3303 * transaction object.
3304 */
3305 lua_newtable(L);
Willy Tarreau7073c472015-04-06 11:15:40 +02003306 hsmp = lua_newuserdata(L, sizeof(*hsmp));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003307 lua_rawseti(L, -2, 0);
3308
Willy Tarreau7073c472015-04-06 11:15:40 +02003309 hsmp->s = txn->s;
3310 hsmp->p = txn->p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01003311 hsmp->dir = txn->dir;
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003312 hsmp->flags = flags;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003313
3314 /* Pop a class sesison metatable and affect it to the userdata. */
3315 lua_rawgeti(L, LUA_REGISTRYINDEX, class_fetches_ref);
3316 lua_setmetatable(L, -2);
3317
3318 return 1;
3319}
3320
3321/* This function is an LUA binding. It is called with each sample-fetch.
3322 * It uses closure argument to store the associated sample-fetch. It
3323 * returns only one argument or throws an error. An error is thrown
3324 * only if an error is encountered during the argument parsing. If
3325 * the "sample-fetch" function fails, nil is returned.
3326 */
3327__LJMP static int hlua_run_sample_fetch(lua_State *L)
3328{
Willy Tarreaub2ccb562015-04-06 11:11:15 +02003329 struct hlua_smp *hsmp;
Willy Tarreau2ec22742015-03-10 14:27:20 +01003330 struct sample_fetch *f;
Frédéric Lécaillef874a832018-06-15 13:56:04 +02003331 struct arg args[ARGM_NBARGS + 1] = {{0}};
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003332 int i;
3333 struct sample smp;
3334
3335 /* Get closure arguments. */
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003336 f = lua_touserdata(L, lua_upvalueindex(1));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003337
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003338 /* Get traditional arguments. */
Willy Tarreaub2ccb562015-04-06 11:11:15 +02003339 hsmp = MAY_LJMP(hlua_checkfetches(L, 1));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003340
Thierry FOURNIERca988662015-12-20 18:43:03 +01003341 /* Check execution authorization. */
3342 if (f->use & SMP_USE_HTTP_ANY &&
3343 !(hsmp->flags & HLUA_F_MAY_USE_HTTP)) {
3344 lua_pushfstring(L, "the sample-fetch '%s' needs an HTTP parser which "
3345 "is not available in Lua services", f->kw);
3346 WILL_LJMP(lua_error(L));
3347 }
3348
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003349 /* Get extra arguments. */
3350 for (i = 0; i < lua_gettop(L) - 1; i++) {
3351 if (i >= ARGM_NBARGS)
3352 break;
3353 hlua_lua2arg(L, i + 2, &args[i]);
3354 }
3355 args[i].type = ARGT_STOP;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003356 args[i].data.str.area = NULL;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003357
3358 /* Check arguments. */
Willy Tarreaub2ccb562015-04-06 11:11:15 +02003359 MAY_LJMP(hlua_lua2arg_check(L, 2, args, f->arg_mask, hsmp->p));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003360
3361 /* Run the special args checker. */
Willy Tarreau2ec22742015-03-10 14:27:20 +01003362 if (f->val_args && !f->val_args(args, NULL)) {
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003363 lua_pushfstring(L, "error in arguments");
3364 WILL_LJMP(lua_error(L));
3365 }
3366
3367 /* Initialise the sample. */
3368 memset(&smp, 0, sizeof(smp));
3369
3370 /* Run the sample fetch process. */
Willy Tarreau1777ea62016-03-10 16:15:46 +01003371 smp_set_owner(&smp, hsmp->p, hsmp->s->sess, hsmp->s, hsmp->dir & SMP_OPT_DIR);
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003372 if (!f->process(args, &smp, f->kw, f->private)) {
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003373 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003374 lua_pushstring(L, "");
3375 else
3376 lua_pushnil(L);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003377 return 1;
3378 }
3379
3380 /* Convert the returned sample in lua value. */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003381 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003382 hlua_smp2lua_str(L, &smp);
3383 else
3384 hlua_smp2lua(L, &smp);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003385 return 1;
3386}
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003387
3388/*
3389 *
3390 *
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003391 * Class Converters
3392 *
3393 *
3394 */
3395
3396/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02003397 * a class stream, otherwise it throws an error.
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003398 */
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003399__LJMP static struct hlua_smp *hlua_checkconverters(lua_State *L, int ud)
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003400{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003401 return MAY_LJMP(hlua_checkudata(L, ud, class_converters_ref));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003402}
3403
3404/* This function creates and push in the stack a Converters object
3405 * according with a current TXN.
3406 */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003407static int hlua_converters_new(lua_State *L, struct hlua_txn *txn, unsigned int flags)
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003408{
Willy Tarreau7073c472015-04-06 11:15:40 +02003409 struct hlua_smp *hsmp;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003410
3411 /* Check stack size. */
3412 if (!lua_checkstack(L, 3))
3413 return 0;
3414
3415 /* Create the object: obj[0] = userdata.
3416 * Note that the base of the Converters object is the
3417 * same than the TXN object.
3418 */
3419 lua_newtable(L);
Willy Tarreau7073c472015-04-06 11:15:40 +02003420 hsmp = lua_newuserdata(L, sizeof(*hsmp));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003421 lua_rawseti(L, -2, 0);
3422
Willy Tarreau7073c472015-04-06 11:15:40 +02003423 hsmp->s = txn->s;
3424 hsmp->p = txn->p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01003425 hsmp->dir = txn->dir;
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003426 hsmp->flags = flags;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003427
Willy Tarreau87b09662015-04-03 00:22:06 +02003428 /* Pop a class stream metatable and affect it to the table. */
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003429 lua_rawgeti(L, LUA_REGISTRYINDEX, class_converters_ref);
3430 lua_setmetatable(L, -2);
3431
3432 return 1;
3433}
3434
3435/* This function is an LUA binding. It is called with each converter.
3436 * It uses closure argument to store the associated converter. It
3437 * returns only one argument or throws an error. An error is thrown
3438 * only if an error is encountered during the argument parsing. If
3439 * the converter function function fails, nil is returned.
3440 */
3441__LJMP static int hlua_run_sample_conv(lua_State *L)
3442{
Willy Tarreauda5f1082015-04-06 11:17:13 +02003443 struct hlua_smp *hsmp;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003444 struct sample_conv *conv;
Frédéric Lécaillef874a832018-06-15 13:56:04 +02003445 struct arg args[ARGM_NBARGS + 1] = {{0}};
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003446 int i;
3447 struct sample smp;
3448
3449 /* Get closure arguments. */
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003450 conv = lua_touserdata(L, lua_upvalueindex(1));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003451
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003452 /* Get traditional arguments. */
Willy Tarreauda5f1082015-04-06 11:17:13 +02003453 hsmp = MAY_LJMP(hlua_checkconverters(L, 1));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003454
3455 /* Get extra arguments. */
3456 for (i = 0; i < lua_gettop(L) - 2; i++) {
3457 if (i >= ARGM_NBARGS)
3458 break;
3459 hlua_lua2arg(L, i + 3, &args[i]);
3460 }
3461 args[i].type = ARGT_STOP;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003462 args[i].data.str.area = NULL;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003463
3464 /* Check arguments. */
Willy Tarreauda5f1082015-04-06 11:17:13 +02003465 MAY_LJMP(hlua_lua2arg_check(L, 3, args, conv->arg_mask, hsmp->p));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003466
3467 /* Run the special args checker. */
3468 if (conv->val_args && !conv->val_args(args, conv, "", 0, NULL)) {
3469 hlua_pusherror(L, "error in arguments");
3470 WILL_LJMP(lua_error(L));
3471 }
3472
3473 /* Initialise the sample. */
Amaury Denoyelleca492f32020-10-29 17:21:20 +01003474 memset(&smp, 0, sizeof(smp));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003475 if (!hlua_lua2smp(L, 2, &smp)) {
3476 hlua_pusherror(L, "error in the input argument");
3477 WILL_LJMP(lua_error(L));
3478 }
3479
Willy Tarreau1777ea62016-03-10 16:15:46 +01003480 smp_set_owner(&smp, hsmp->p, hsmp->s->sess, hsmp->s, hsmp->dir & SMP_OPT_DIR);
3481
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003482 /* Apply expected cast. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003483 if (!sample_casts[smp.data.type][conv->in_type]) {
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003484 hlua_pusherror(L, "invalid input argument: cannot cast '%s' to '%s'",
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003485 smp_to_type[smp.data.type], smp_to_type[conv->in_type]);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003486 WILL_LJMP(lua_error(L));
3487 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003488 if (sample_casts[smp.data.type][conv->in_type] != c_none &&
3489 !sample_casts[smp.data.type][conv->in_type](&smp)) {
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003490 hlua_pusherror(L, "error during the input argument casting");
3491 WILL_LJMP(lua_error(L));
3492 }
3493
3494 /* Run the sample conversion process. */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003495 if (!conv->process(args, &smp, conv->private)) {
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003496 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003497 lua_pushstring(L, "");
3498 else
Willy Tarreaua678b432015-08-28 10:14:59 +02003499 lua_pushnil(L);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003500 return 1;
3501 }
3502
3503 /* Convert the returned sample in lua value. */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003504 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003505 hlua_smp2lua_str(L, &smp);
3506 else
3507 hlua_smp2lua(L, &smp);
Willy Tarreaua678b432015-08-28 10:14:59 +02003508 return 1;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003509}
3510
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003511/*
3512 *
3513 *
3514 * Class AppletTCP
3515 *
3516 *
3517 */
3518
3519/* Returns a struct hlua_txn if the stack entry "ud" is
3520 * a class stream, otherwise it throws an error.
3521 */
3522__LJMP static struct hlua_appctx *hlua_checkapplet_tcp(lua_State *L, int ud)
3523{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003524 return MAY_LJMP(hlua_checkudata(L, ud, class_applet_tcp_ref));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003525}
3526
3527/* This function creates and push in the stack an Applet object
3528 * according with a current TXN.
3529 */
3530static int hlua_applet_tcp_new(lua_State *L, struct appctx *ctx)
3531{
3532 struct hlua_appctx *appctx;
3533 struct stream_interface *si = ctx->owner;
3534 struct stream *s = si_strm(si);
3535 struct proxy *p = s->be;
3536
3537 /* Check stack size. */
3538 if (!lua_checkstack(L, 3))
3539 return 0;
3540
3541 /* Create the object: obj[0] = userdata.
3542 * Note that the base of the Converters object is the
3543 * same than the TXN object.
3544 */
3545 lua_newtable(L);
3546 appctx = lua_newuserdata(L, sizeof(*appctx));
3547 lua_rawseti(L, -2, 0);
3548 appctx->appctx = ctx;
3549 appctx->htxn.s = s;
3550 appctx->htxn.p = p;
3551
3552 /* Create the "f" field that contains a list of fetches. */
3553 lua_pushstring(L, "f");
3554 if (!hlua_fetches_new(L, &appctx->htxn, 0))
3555 return 0;
3556 lua_settable(L, -3);
3557
3558 /* Create the "sf" field that contains a list of stringsafe fetches. */
3559 lua_pushstring(L, "sf");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003560 if (!hlua_fetches_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003561 return 0;
3562 lua_settable(L, -3);
3563
3564 /* Create the "c" field that contains a list of converters. */
3565 lua_pushstring(L, "c");
3566 if (!hlua_converters_new(L, &appctx->htxn, 0))
3567 return 0;
3568 lua_settable(L, -3);
3569
3570 /* Create the "sc" field that contains a list of stringsafe converters. */
3571 lua_pushstring(L, "sc");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003572 if (!hlua_converters_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003573 return 0;
3574 lua_settable(L, -3);
3575
3576 /* Pop a class stream metatable and affect it to the table. */
3577 lua_rawgeti(L, LUA_REGISTRYINDEX, class_applet_tcp_ref);
3578 lua_setmetatable(L, -2);
3579
3580 return 1;
3581}
3582
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003583__LJMP static int hlua_applet_tcp_set_var(lua_State *L)
3584{
3585 struct hlua_appctx *appctx;
3586 struct stream *s;
3587 const char *name;
3588 size_t len;
3589 struct sample smp;
3590
3591 MAY_LJMP(check_args(L, 3, "set_var"));
3592
3593 /* It is useles to retrieve the stream, but this function
3594 * runs only in a stream context.
3595 */
3596 appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3597 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3598 s = appctx->htxn.s;
3599
3600 /* Converts the third argument in a sample. */
Amaury Denoyelleca492f32020-10-29 17:21:20 +01003601 memset(&smp, 0, sizeof(smp));
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003602 hlua_lua2smp(L, 3, &smp);
3603
3604 /* Store the sample in a variable. */
3605 smp_set_owner(&smp, s->be, s->sess, s, 0);
3606 vars_set_by_name(name, len, &smp);
3607 return 0;
3608}
3609
3610__LJMP static int hlua_applet_tcp_unset_var(lua_State *L)
3611{
3612 struct hlua_appctx *appctx;
3613 struct stream *s;
3614 const char *name;
3615 size_t len;
3616 struct sample smp;
3617
3618 MAY_LJMP(check_args(L, 2, "unset_var"));
3619
3620 /* It is useles to retrieve the stream, but this function
3621 * runs only in a stream context.
3622 */
3623 appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3624 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3625 s = appctx->htxn.s;
3626
3627 /* Unset the variable. */
3628 smp_set_owner(&smp, s->be, s->sess, s, 0);
3629 vars_unset_by_name(name, len, &smp);
3630 return 0;
3631}
3632
3633__LJMP static int hlua_applet_tcp_get_var(lua_State *L)
3634{
3635 struct hlua_appctx *appctx;
3636 struct stream *s;
3637 const char *name;
3638 size_t len;
3639 struct sample smp;
3640
3641 MAY_LJMP(check_args(L, 2, "get_var"));
3642
3643 /* It is useles to retrieve the stream, but this function
3644 * runs only in a stream context.
3645 */
3646 appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3647 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3648 s = appctx->htxn.s;
3649
3650 smp_set_owner(&smp, s->be, s->sess, s, 0);
3651 if (!vars_get_by_name(name, len, &smp)) {
3652 lua_pushnil(L);
3653 return 1;
3654 }
3655
3656 return hlua_smp2lua(L, &smp);
3657}
3658
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003659__LJMP static int hlua_applet_tcp_set_priv(lua_State *L)
3660{
3661 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3662 struct stream *s = appctx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01003663 struct hlua *hlua;
3664
3665 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01003666 if (!s->hlua)
3667 return 0;
3668 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003669
3670 MAY_LJMP(check_args(L, 2, "set_priv"));
3671
3672 /* Remove previous value. */
Thierry FOURNIERe068b602017-04-26 13:27:05 +02003673 luaL_unref(L, LUA_REGISTRYINDEX, hlua->Mref);
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003674
3675 /* Get and store new value. */
3676 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
3677 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
3678
3679 return 0;
3680}
3681
3682__LJMP static int hlua_applet_tcp_get_priv(lua_State *L)
3683{
3684 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3685 struct stream *s = appctx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01003686 struct hlua *hlua;
3687
3688 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01003689 if (!s->hlua) {
3690 lua_pushnil(L);
3691 return 1;
3692 }
3693 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003694
3695 /* Push configuration index in the stack. */
3696 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
3697
3698 return 1;
3699}
3700
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003701/* If expected data not yet available, it returns a yield. This function
3702 * consumes the data in the buffer. It returns a string containing the
3703 * data. This string can be empty.
3704 */
3705__LJMP static int hlua_applet_tcp_getline_yield(lua_State *L, int status, lua_KContext ctx)
3706{
3707 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3708 struct stream_interface *si = appctx->appctx->owner;
3709 int ret;
Willy Tarreau206ba832018-06-14 15:27:31 +02003710 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003711 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02003712 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003713 size_t len2;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003714
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003715 /* Read the maximum amount of data available. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003716 ret = co_getline_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003717
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003718 /* Data not yet available. return yield. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003719 if (ret == 0) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01003720 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003721 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_getline_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003722 }
3723
3724 /* End of data: commit the total strings and return. */
3725 if (ret < 0) {
3726 luaL_pushresult(&appctx->b);
3727 return 1;
3728 }
3729
3730 /* Ensure that the block 2 length is usable. */
3731 if (ret == 1)
3732 len2 = 0;
3733
3734 /* dont check the max length read and dont check. */
3735 luaL_addlstring(&appctx->b, blk1, len1);
3736 luaL_addlstring(&appctx->b, blk2, len2);
3737
3738 /* Consume input channel output buffer data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003739 co_skip(si_oc(si), len1 + len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003740 luaL_pushresult(&appctx->b);
3741 return 1;
3742}
3743
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003744/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003745__LJMP static int hlua_applet_tcp_getline(lua_State *L)
3746{
3747 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3748
3749 /* Initialise the string catenation. */
3750 luaL_buffinit(L, &appctx->b);
3751
3752 return MAY_LJMP(hlua_applet_tcp_getline_yield(L, 0, 0));
3753}
3754
3755/* If expected data not yet available, it returns a yield. This function
3756 * consumes the data in the buffer. It returns a string containing the
3757 * data. This string can be empty.
3758 */
3759__LJMP static int hlua_applet_tcp_recv_yield(lua_State *L, int status, lua_KContext ctx)
3760{
3761 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3762 struct stream_interface *si = appctx->appctx->owner;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003763 size_t len = MAY_LJMP(luaL_checkinteger(L, 2));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003764 int ret;
Willy Tarreau206ba832018-06-14 15:27:31 +02003765 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003766 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02003767 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003768 size_t len2;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003769
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003770 /* Read the maximum amount of data available. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003771 ret = co_getblk_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003772
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003773 /* Data not yet available. return yield. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003774 if (ret == 0) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01003775 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003776 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003777 }
3778
3779 /* End of data: commit the total strings and return. */
3780 if (ret < 0) {
3781 luaL_pushresult(&appctx->b);
3782 return 1;
3783 }
3784
3785 /* Ensure that the block 2 length is usable. */
3786 if (ret == 1)
3787 len2 = 0;
3788
3789 if (len == -1) {
3790
3791 /* If len == -1, catenate all the data avalaile and
3792 * yield because we want to get all the data until
3793 * the end of data stream.
3794 */
3795 luaL_addlstring(&appctx->b, blk1, len1);
3796 luaL_addlstring(&appctx->b, blk2, len2);
Willy Tarreau06d80a92017-10-19 14:32:15 +02003797 co_skip(si_oc(si), len1 + len2);
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01003798 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003799 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003800
3801 } else {
3802
3803 /* Copy the fisrt block caping to the length required. */
3804 if (len1 > len)
3805 len1 = len;
3806 luaL_addlstring(&appctx->b, blk1, len1);
3807 len -= len1;
3808
3809 /* Copy the second block. */
3810 if (len2 > len)
3811 len2 = len;
3812 luaL_addlstring(&appctx->b, blk2, len2);
3813 len -= len2;
3814
3815 /* Consume input channel output buffer data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003816 co_skip(si_oc(si), len1 + len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003817
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003818 /* If there is no other data available, yield waiting for new data. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003819 if (len > 0) {
3820 lua_pushinteger(L, len);
3821 lua_replace(L, 2);
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01003822 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003823 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003824 }
3825
3826 /* return the result. */
3827 luaL_pushresult(&appctx->b);
3828 return 1;
3829 }
3830
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003831 /* we never execute this */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003832 hlua_pusherror(L, "Lua: internal error");
3833 WILL_LJMP(lua_error(L));
3834 return 0;
3835}
3836
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003837/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003838__LJMP static int hlua_applet_tcp_recv(lua_State *L)
3839{
3840 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3841 int len = -1;
3842
3843 if (lua_gettop(L) > 2)
3844 WILL_LJMP(luaL_error(L, "The 'recv' function requires between 1 and 2 arguments."));
3845 if (lua_gettop(L) >= 2) {
3846 len = MAY_LJMP(luaL_checkinteger(L, 2));
3847 lua_pop(L, 1);
3848 }
3849
3850 /* Confirm or set the required length */
3851 lua_pushinteger(L, len);
3852
3853 /* Initialise the string catenation. */
3854 luaL_buffinit(L, &appctx->b);
3855
3856 return MAY_LJMP(hlua_applet_tcp_recv_yield(L, 0, 0));
3857}
3858
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003859/* Append data in the output side of the buffer. This data is immediately
3860 * sent. The function returns the amount of data written. If the buffer
3861 * cannot contain the data, the function yields. The function returns -1
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003862 * if the channel is closed.
3863 */
3864__LJMP static int hlua_applet_tcp_send_yield(lua_State *L, int status, lua_KContext ctx)
3865{
3866 size_t len;
3867 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3868 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
3869 int l = MAY_LJMP(luaL_checkinteger(L, 3));
3870 struct stream_interface *si = appctx->appctx->owner;
3871 struct channel *chn = si_ic(si);
3872 int max;
3873
3874 /* Get the max amount of data which can write as input in the channel. */
3875 max = channel_recv_max(chn);
3876 if (max > (len - l))
3877 max = len - l;
3878
3879 /* Copy data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003880 ci_putblk(chn, str + l, max);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003881
3882 /* update counters. */
3883 l += max;
3884 lua_pop(L, 1);
3885 lua_pushinteger(L, l);
3886
3887 /* If some data is not send, declares the situation to the
3888 * applet, and returns a yield.
3889 */
3890 if (l < len) {
Willy Tarreaudb398432018-11-15 11:08:52 +01003891 si_rx_room_blk(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003892 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003893 }
3894
3895 return 1;
3896}
3897
3898/* Just a wraper of "hlua_applet_tcp_send_yield". This wrapper permits
3899 * yield the LUA process, and resume it without checking the
3900 * input arguments.
3901 */
3902__LJMP static int hlua_applet_tcp_send(lua_State *L)
3903{
3904 MAY_LJMP(check_args(L, 2, "send"));
3905 lua_pushinteger(L, 0);
3906
3907 return MAY_LJMP(hlua_applet_tcp_send_yield(L, 0, 0));
3908}
3909
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003910/*
3911 *
3912 *
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003913 * Class AppletHTTP
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003914 *
3915 *
3916 */
3917
3918/* Returns a struct hlua_txn if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02003919 * a class stream, otherwise it throws an error.
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003920 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003921__LJMP static struct hlua_appctx *hlua_checkapplet_http(lua_State *L, int ud)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003922{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003923 return MAY_LJMP(hlua_checkudata(L, ud, class_applet_http_ref));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003924}
3925
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003926/* This function creates and push in the stack an Applet object
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003927 * according with a current TXN.
3928 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003929static int hlua_applet_http_new(lua_State *L, struct appctx *ctx)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003930{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003931 struct hlua_appctx *appctx;
Thierry FOURNIER841475e2015-12-11 17:10:09 +01003932 struct hlua_txn htxn;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003933 struct stream_interface *si = ctx->owner;
3934 struct stream *s = si_strm(si);
3935 struct proxy *px = s->be;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003936
3937 /* Check stack size. */
3938 if (!lua_checkstack(L, 3))
3939 return 0;
3940
3941 /* Create the object: obj[0] = userdata.
3942 * Note that the base of the Converters object is the
3943 * same than the TXN object.
3944 */
3945 lua_newtable(L);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003946 appctx = lua_newuserdata(L, sizeof(*appctx));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003947 lua_rawseti(L, -2, 0);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003948 appctx->appctx = ctx;
3949 appctx->appctx->ctx.hlua_apphttp.status = 200; /* Default status code returned. */
Robin H. Johnson52f5db22017-01-01 13:10:52 -08003950 appctx->appctx->ctx.hlua_apphttp.reason = NULL; /* Use default reason based on status */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003951 appctx->htxn.s = s;
3952 appctx->htxn.p = px;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003953
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003954 /* Create the "f" field that contains a list of fetches. */
3955 lua_pushstring(L, "f");
3956 if (!hlua_fetches_new(L, &appctx->htxn, 0))
3957 return 0;
3958 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003959
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003960 /* Create the "sf" field that contains a list of stringsafe fetches. */
3961 lua_pushstring(L, "sf");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003962 if (!hlua_fetches_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003963 return 0;
3964 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003965
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003966 /* Create the "c" field that contains a list of converters. */
3967 lua_pushstring(L, "c");
3968 if (!hlua_converters_new(L, &appctx->htxn, 0))
3969 return 0;
3970 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003971
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003972 /* Create the "sc" field that contains a list of stringsafe converters. */
3973 lua_pushstring(L, "sc");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003974 if (!hlua_converters_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003975 return 0;
3976 lua_settable(L, -3);
Willy Tarreaueee5b512015-04-03 23:46:31 +02003977
Christopher Faulet9c832fc2018-12-14 13:34:05 +01003978 if (IS_HTX_STRM(s)) {
3979 /* HTX version */
3980 struct htx *htx = htxbuf(&s->req.buf);
Christopher Faulet29f17582019-05-23 11:03:26 +02003981 struct htx_blk *blk;
3982 struct htx_sl *sl;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01003983 struct ist path;
3984 unsigned long long len = 0;
3985 int32_t pos;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003986
Christopher Faulet29f17582019-05-23 11:03:26 +02003987 blk = htx_get_first_blk(htx);
Christopher Faulet43a686d2019-11-18 15:50:25 +01003988 BUG_ON(!blk || htx_get_blk_type(blk) != HTX_BLK_REQ_SL);
Christopher Faulet29f17582019-05-23 11:03:26 +02003989 sl = htx_get_blk_ptr(htx, blk);
3990
Christopher Faulet9c832fc2018-12-14 13:34:05 +01003991 /* Stores the request method. */
3992 lua_pushstring(L, "method");
3993 lua_pushlstring(L, HTX_SL_REQ_MPTR(sl), HTX_SL_REQ_MLEN(sl));
3994 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003995
Christopher Faulet9c832fc2018-12-14 13:34:05 +01003996 /* Stores the http version. */
3997 lua_pushstring(L, "version");
3998 lua_pushlstring(L, HTX_SL_REQ_VPTR(sl), HTX_SL_REQ_VLEN(sl));
3999 lua_settable(L, -3);
Thierry FOURNIER841475e2015-12-11 17:10:09 +01004000
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004001 /* creates an array of headers. hlua_http_get_headers() crates and push
4002 * the array on the top of the stack.
4003 */
4004 lua_pushstring(L, "headers");
4005 htxn.s = s;
4006 htxn.p = px;
4007 htxn.dir = SMP_OPT_DIR_REQ;
4008 if (!hlua_http_get_headers(L, &htxn, &htxn.s->txn->req))
4009 return 0;
4010 lua_settable(L, -3);
4011
4012 path = http_get_path(htx_sl_req_uri(sl));
4013 if (path.ptr) {
4014 char *p, *q, *end;
4015
4016 p = path.ptr;
4017 end = path.ptr + path.len;
4018 q = p;
4019 while (q < end && *q != '?')
4020 q++;
4021
4022 /* Stores the request path. */
4023 lua_pushstring(L, "path");
4024 lua_pushlstring(L, p, q - p);
4025 lua_settable(L, -3);
4026
4027 /* Stores the query string. */
4028 lua_pushstring(L, "qs");
4029 if (*q == '?')
4030 q++;
4031 lua_pushlstring(L, q, end - q);
4032 lua_settable(L, -3);
4033 }
4034
Christopher Fauleta3f15502019-05-13 15:27:23 +02004035 for (pos = htx_get_first(htx); pos != -1; pos = htx_get_next(htx, pos)) {
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004036 struct htx_blk *blk = htx_get_blk(htx, pos);
4037 enum htx_blk_type type = htx_get_blk_type(blk);
4038
Christopher Faulet54b5e212019-06-04 10:08:28 +02004039 if (type == HTX_BLK_EOM || type == HTX_BLK_TLR || type == HTX_BLK_EOT)
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004040 break;
4041 if (type == HTX_BLK_DATA)
4042 len += htx_get_blksz(blk);
4043 }
4044 if (htx->extra != ULLONG_MAX)
4045 len += htx->extra;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004046
Thierry FOURNIER7d388632017-02-22 02:06:16 +01004047 /* Stores the request path. */
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004048 lua_pushstring(L, "length");
4049 lua_pushinteger(L, len);
4050 lua_settable(L, -3);
4051 }
4052 else {
4053 /* Legacy HTTP version */
4054 struct http_txn *txn = s->txn;
4055 const char *path;
4056 const char *end;
4057 const char *p;
4058
4059 /* Stores the request method. */
4060 lua_pushstring(L, "method");
4061 lua_pushlstring(L, ci_head(txn->req.chn), txn->req.sl.rq.m_l);
Thierry FOURNIER7d388632017-02-22 02:06:16 +01004062 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004063
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004064 /* Stores the http version. */
4065 lua_pushstring(L, "version");
4066 lua_pushlstring(L, ci_head(txn->req.chn) + txn->req.sl.rq.v, txn->req.sl.rq.v_l);
Thierry FOURNIER7d388632017-02-22 02:06:16 +01004067 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01004068
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004069 /* creates an array of headers. hlua_http_get_headers() crates and push
4070 * the array on the top of the stack.
4071 */
4072 lua_pushstring(L, "headers");
4073 htxn.s = s;
4074 htxn.p = px;
4075 htxn.dir = SMP_OPT_DIR_REQ;
4076 if (!hlua_http_get_headers(L, &htxn, &htxn.s->txn->req))
4077 return 0;
4078 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01004079
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004080 /* Get path and qs */
4081 path = http_txn_get_path(txn);
4082 if (path) {
4083 end = ci_head(txn->req.chn) + txn->req.sl.rq.u + txn->req.sl.rq.u_l;
4084 p = path;
4085 while (p < end && *p != '?')
4086 p++;
4087
4088 /* Stores the request path. */
4089 lua_pushstring(L, "path");
4090 lua_pushlstring(L, path, p - path);
4091 lua_settable(L, -3);
4092
4093 /* Stores the query string. */
4094 lua_pushstring(L, "qs");
4095 if (*p == '?')
4096 p++;
4097 lua_pushlstring(L, p, end - p);
4098 lua_settable(L, -3);
4099 }
4100
4101 /* Stores the request path. */
4102 lua_pushstring(L, "length");
4103 lua_pushinteger(L, txn->req.body_len);
4104 lua_settable(L, -3);
4105 }
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01004106
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004107 /* Create an empty array of HTTP request headers. */
4108 lua_pushstring(L, "response");
4109 lua_newtable(L);
4110 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01004111
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004112 /* Pop a class stream metatable and affect it to the table. */
4113 lua_rawgeti(L, LUA_REGISTRYINDEX, class_applet_http_ref);
4114 lua_setmetatable(L, -2);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004115
4116 return 1;
4117}
4118
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004119__LJMP static int hlua_applet_http_set_var(lua_State *L)
4120{
4121 struct hlua_appctx *appctx;
4122 struct stream *s;
4123 const char *name;
4124 size_t len;
4125 struct sample smp;
4126
4127 MAY_LJMP(check_args(L, 3, "set_var"));
4128
4129 /* It is useles to retrieve the stream, but this function
4130 * runs only in a stream context.
4131 */
4132 appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4133 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
4134 s = appctx->htxn.s;
4135
4136 /* Converts the third argument in a sample. */
Amaury Denoyelleca492f32020-10-29 17:21:20 +01004137 memset(&smp, 0, sizeof(smp));
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004138 hlua_lua2smp(L, 3, &smp);
4139
4140 /* Store the sample in a variable. */
4141 smp_set_owner(&smp, s->be, s->sess, s, 0);
4142 vars_set_by_name(name, len, &smp);
4143 return 0;
4144}
4145
4146__LJMP static int hlua_applet_http_unset_var(lua_State *L)
4147{
4148 struct hlua_appctx *appctx;
4149 struct stream *s;
4150 const char *name;
4151 size_t len;
4152 struct sample smp;
4153
4154 MAY_LJMP(check_args(L, 2, "unset_var"));
4155
4156 /* It is useles to retrieve the stream, but this function
4157 * runs only in a stream context.
4158 */
4159 appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4160 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
4161 s = appctx->htxn.s;
4162
4163 /* Unset the variable. */
4164 smp_set_owner(&smp, s->be, s->sess, s, 0);
4165 vars_unset_by_name(name, len, &smp);
4166 return 0;
4167}
4168
4169__LJMP static int hlua_applet_http_get_var(lua_State *L)
4170{
4171 struct hlua_appctx *appctx;
4172 struct stream *s;
4173 const char *name;
4174 size_t len;
4175 struct sample smp;
4176
4177 MAY_LJMP(check_args(L, 2, "get_var"));
4178
4179 /* It is useles to retrieve the stream, but this function
4180 * runs only in a stream context.
4181 */
4182 appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4183 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
4184 s = appctx->htxn.s;
4185
4186 smp_set_owner(&smp, s->be, s->sess, s, 0);
4187 if (!vars_get_by_name(name, len, &smp)) {
4188 lua_pushnil(L);
4189 return 1;
4190 }
4191
4192 return hlua_smp2lua(L, &smp);
4193}
4194
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01004195__LJMP static int hlua_applet_http_set_priv(lua_State *L)
4196{
4197 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4198 struct stream *s = appctx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01004199 struct hlua *hlua;
4200
4201 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01004202 if (!s->hlua)
4203 return 0;
4204 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01004205
4206 MAY_LJMP(check_args(L, 2, "set_priv"));
4207
4208 /* Remove previous value. */
Thierry FOURNIERe068b602017-04-26 13:27:05 +02004209 luaL_unref(L, LUA_REGISTRYINDEX, hlua->Mref);
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01004210
4211 /* Get and store new value. */
4212 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
4213 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
4214
4215 return 0;
4216}
4217
4218__LJMP static int hlua_applet_http_get_priv(lua_State *L)
4219{
4220 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4221 struct stream *s = appctx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01004222 struct hlua *hlua;
4223
4224 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01004225 if (!s->hlua) {
4226 lua_pushnil(L);
4227 return 1;
4228 }
4229 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01004230
4231 /* Push configuration index in the stack. */
4232 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
4233
4234 return 1;
4235}
4236
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004237/* If expected data not yet available, it returns a yield. This function
4238 * consumes the data in the buffer. It returns a string containing the
4239 * data. This string can be empty.
4240 */
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004241__LJMP static int hlua_applet_htx_getline_yield(lua_State *L, int status, lua_KContext ctx)
4242{
4243 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4244 struct stream_interface *si = appctx->appctx->owner;
4245 struct channel *req = si_oc(si);
4246 struct htx *htx;
4247 struct htx_blk *blk;
4248 size_t count;
4249 int stop = 0;
4250
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004251 htx = htx_from_buf(&req->buf);
4252 count = co_data(req);
Christopher Fauleta3f15502019-05-13 15:27:23 +02004253 blk = htx_get_first_blk(htx);
Christopher Fauletcc26b132018-12-18 21:20:57 +01004254
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004255 while (count && !stop && blk) {
4256 enum htx_blk_type type = htx_get_blk_type(blk);
4257 uint32_t sz = htx_get_blksz(blk);
4258 struct ist v;
4259 uint32_t vlen;
4260 char *nl;
4261
Christopher Faulete461e342018-12-18 16:43:35 +01004262 if (type == HTX_BLK_EOM) {
4263 stop = 1;
4264 break;
4265 }
4266
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004267 vlen = sz;
4268 if (vlen > count) {
4269 if (type != HTX_BLK_DATA)
4270 break;
4271 vlen = count;
4272 }
4273
4274 switch (type) {
4275 case HTX_BLK_UNUSED:
4276 break;
4277
4278 case HTX_BLK_DATA:
4279 v = htx_get_blk_value(htx, blk);
4280 v.len = vlen;
4281 nl = istchr(v, '\n');
4282 if (nl != NULL) {
4283 stop = 1;
4284 vlen = nl - v.ptr + 1;
4285 }
4286 luaL_addlstring(&appctx->b, v.ptr, vlen);
4287 break;
4288
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004289 case HTX_BLK_TLR:
4290 case HTX_BLK_EOM:
4291 stop = 1;
4292 break;
4293
4294 default:
4295 break;
4296 }
4297
4298 co_set_data(req, co_data(req) - vlen);
4299 count -= vlen;
4300 if (sz == vlen)
4301 blk = htx_remove_blk(htx, blk);
4302 else {
4303 htx_cut_data_blk(htx, blk, vlen);
4304 break;
4305 }
4306 }
4307
Christopher Faulet0ae79d02019-02-27 21:36:59 +01004308 htx_to_buf(htx, &req->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004309 if (!stop) {
4310 si_cant_get(si);
4311 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_htx_getline_yield, TICK_ETERNITY, 0));
4312 }
4313
4314 /* return the result. */
4315 luaL_pushresult(&appctx->b);
4316 return 1;
4317}
4318
4319
4320/* If expected data not yet available, it returns a yield. This function
4321 * consumes the data in the buffer. It returns a string containing the
4322 * data. This string can be empty.
4323 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004324__LJMP static int hlua_applet_http_getline_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004325{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004326 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4327 struct stream_interface *si = appctx->appctx->owner;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004328 int ret;
Willy Tarreau206ba832018-06-14 15:27:31 +02004329 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02004330 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02004331 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02004332 size_t len2;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004333
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004334 /* Check for the end of the data. */
4335 if (appctx->appctx->ctx.hlua_apphttp.left_bytes <= 0) {
4336 luaL_pushresult(&appctx->b);
4337 return 1;
4338 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004339
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004340 /* Read the maximum amount of data available. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02004341 ret = co_getline_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004342
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004343 /* Data not yet available. return yield. */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004344 if (ret == 0) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01004345 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02004346 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_getline_yield, TICK_ETERNITY, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004347 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004348
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004349 /* End of data: commit the total strings and return. */
4350 if (ret < 0) {
4351 luaL_pushresult(&appctx->b);
4352 return 1;
4353 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004354
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004355 /* Ensure that the block 2 length is usable. */
4356 if (ret == 1)
4357 len2 = 0;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004358
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004359 /* Copy the fisrt block caping to the length required. */
4360 if (len1 > appctx->appctx->ctx.hlua_apphttp.left_bytes)
4361 len1 = appctx->appctx->ctx.hlua_apphttp.left_bytes;
4362 luaL_addlstring(&appctx->b, blk1, len1);
4363 appctx->appctx->ctx.hlua_apphttp.left_bytes -= len1;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004364
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004365 /* Copy the second block. */
4366 if (len2 > appctx->appctx->ctx.hlua_apphttp.left_bytes)
4367 len2 = appctx->appctx->ctx.hlua_apphttp.left_bytes;
4368 luaL_addlstring(&appctx->b, blk2, len2);
4369 appctx->appctx->ctx.hlua_apphttp.left_bytes -= len2;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004370
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004371 /* Consume input channel output buffer data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02004372 co_skip(si_oc(si), len1 + len2);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004373 luaL_pushresult(&appctx->b);
4374 return 1;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004375}
4376
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004377/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004378__LJMP static int hlua_applet_http_getline(lua_State *L)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004379{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004380 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004381
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004382 /* Initialise the string catenation. */
4383 luaL_buffinit(L, &appctx->b);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004384
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004385 if (IS_HTX_STRM(si_strm(appctx->appctx->owner)))
4386 return MAY_LJMP(hlua_applet_htx_getline_yield(L, 0, 0));
4387 else
4388 return MAY_LJMP(hlua_applet_http_getline_yield(L, 0, 0));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004389}
4390
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004391/* If expected data not yet available, it returns a yield. This function
4392 * consumes the data in the buffer. It returns a string containing the
4393 * data. This string can be empty.
4394 */
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004395__LJMP static int hlua_applet_htx_recv_yield(lua_State *L, int status, lua_KContext ctx)
4396{
4397 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4398 struct stream_interface *si = appctx->appctx->owner;
4399 struct channel *req = si_oc(si);
4400 struct htx *htx;
4401 struct htx_blk *blk;
4402 size_t count;
4403 int len;
4404
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004405 htx = htx_from_buf(&req->buf);
4406 len = MAY_LJMP(luaL_checkinteger(L, 2));
4407 count = co_data(req);
Christopher Faulet29f17582019-05-23 11:03:26 +02004408 blk = htx_get_head_blk(htx);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004409 while (count && len && blk) {
4410 enum htx_blk_type type = htx_get_blk_type(blk);
4411 uint32_t sz = htx_get_blksz(blk);
4412 struct ist v;
4413 uint32_t vlen;
4414
Christopher Faulete461e342018-12-18 16:43:35 +01004415 if (type == HTX_BLK_EOM) {
4416 len = 0;
4417 break;
4418 }
4419
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004420 vlen = sz;
4421 if (len > 0 && vlen > len)
4422 vlen = len;
4423 if (vlen > count) {
4424 if (type != HTX_BLK_DATA)
4425 break;
4426 vlen = count;
4427 }
4428
4429 switch (type) {
4430 case HTX_BLK_UNUSED:
4431 break;
4432
4433 case HTX_BLK_DATA:
4434 v = htx_get_blk_value(htx, blk);
4435 luaL_addlstring(&appctx->b, v.ptr, vlen);
4436 break;
4437
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004438 case HTX_BLK_TLR:
4439 case HTX_BLK_EOM:
4440 len = 0;
4441 break;
4442
4443 default:
4444 break;
4445 }
4446
4447 co_set_data(req, co_data(req) - vlen);
4448 count -= vlen;
4449 if (len > 0)
4450 len -= vlen;
4451 if (sz == vlen)
4452 blk = htx_remove_blk(htx, blk);
4453 else {
4454 htx_cut_data_blk(htx, blk, vlen);
4455 break;
4456 }
4457 }
4458
Christopher Faulet0ae79d02019-02-27 21:36:59 +01004459 htx_to_buf(htx, &req->buf);
4460
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004461 /* If we are no other data available, yield waiting for new data. */
4462 if (len) {
4463 if (len > 0) {
4464 lua_pushinteger(L, len);
4465 lua_replace(L, 2);
4466 }
4467 si_cant_get(si);
4468 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_htx_recv_yield, TICK_ETERNITY, 0));
4469 }
4470
4471 /* return the result. */
4472 luaL_pushresult(&appctx->b);
4473 return 1;
4474}
4475
4476/* If expected data not yet available, it returns a yield. This function
4477 * consumes the data in the buffer. It returns a string containing the
4478 * data. This string can be empty.
4479 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004480__LJMP static int hlua_applet_http_recv_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004481{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004482 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4483 struct stream_interface *si = appctx->appctx->owner;
4484 int len = MAY_LJMP(luaL_checkinteger(L, 2));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004485 int ret;
Willy Tarreau206ba832018-06-14 15:27:31 +02004486 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02004487 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02004488 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02004489 size_t len2;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004490
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004491 /* Read the maximum amount of data available. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02004492 ret = co_getblk_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004493
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004494 /* Data not yet available. return yield. */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004495 if (ret == 0) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01004496 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02004497 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004498 }
4499
4500 /* End of data: commit the total strings and return. */
4501 if (ret < 0) {
4502 luaL_pushresult(&appctx->b);
4503 return 1;
4504 }
4505
4506 /* Ensure that the block 2 length is usable. */
4507 if (ret == 1)
4508 len2 = 0;
4509
4510 /* Copy the fisrt block caping to the length required. */
4511 if (len1 > len)
4512 len1 = len;
4513 luaL_addlstring(&appctx->b, blk1, len1);
4514 len -= len1;
4515
4516 /* Copy the second block. */
4517 if (len2 > len)
4518 len2 = len;
4519 luaL_addlstring(&appctx->b, blk2, len2);
4520 len -= len2;
4521
4522 /* Consume input channel output buffer data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02004523 co_skip(si_oc(si), len1 + len2);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004524 if (appctx->appctx->ctx.hlua_apphttp.left_bytes != -1)
4525 appctx->appctx->ctx.hlua_apphttp.left_bytes -= len;
4526
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004527 /* If we are no other data available, yield waiting for new data. */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004528 if (len > 0) {
4529 lua_pushinteger(L, len);
4530 lua_replace(L, 2);
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01004531 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02004532 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004533 }
4534
4535 /* return the result. */
4536 luaL_pushresult(&appctx->b);
4537 return 1;
4538}
4539
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004540/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004541__LJMP static int hlua_applet_http_recv(lua_State *L)
4542{
4543 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4544 int len = -1;
4545
4546 /* Check arguments. */
4547 if (lua_gettop(L) > 2)
4548 WILL_LJMP(luaL_error(L, "The 'recv' function requires between 1 and 2 arguments."));
4549 if (lua_gettop(L) >= 2) {
4550 len = MAY_LJMP(luaL_checkinteger(L, 2));
4551 lua_pop(L, 1);
4552 }
4553
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004554 if (IS_HTX_STRM(si_strm(appctx->appctx->owner))) {
4555 /* HTX version */
4556 lua_pushinteger(L, len);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004557
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004558 /* Initialise the string catenation. */
4559 luaL_buffinit(L, &appctx->b);
4560
4561 return MAY_LJMP(hlua_applet_htx_recv_yield(L, 0, 0));
4562 }
4563 else {
4564 /* Legacy HTTP version */
4565 /* Check the required length */
4566 if (len == -1 || len > appctx->appctx->ctx.hlua_apphttp.left_bytes)
4567 len = appctx->appctx->ctx.hlua_apphttp.left_bytes;
4568 lua_pushinteger(L, len);
4569
4570 /* Initialise the string catenation. */
4571 luaL_buffinit(L, &appctx->b);
4572
4573 return MAY_LJMP(hlua_applet_http_recv_yield(L, 0, 0));
4574 }
4575}
4576
4577/* Append data in the output side of the buffer. This data is immediately
4578 * sent. The function returns the amount of data written. If the buffer
4579 * cannot contain the data, the function yields. The function returns -1
4580 * if the channel is closed.
4581 */
4582__LJMP static int hlua_applet_htx_send_yield(lua_State *L, int status, lua_KContext ctx)
4583{
4584 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4585 struct stream_interface *si = appctx->appctx->owner;
4586 struct channel *res = si_ic(si);
4587 struct htx *htx = htx_from_buf(&res->buf);
4588 const char *data;
4589 size_t len;
4590 int l = MAY_LJMP(luaL_checkinteger(L, 3));
4591 int max;
4592
Christopher Faulet4e963012019-07-03 11:39:30 +02004593 max = htx_get_max_blksz(htx, channel_htx_recv_max(res, htx));
Christopher Faulet4b0e9b22019-01-09 12:16:58 +01004594 if (!max)
4595 goto snd_yield;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004596
4597 data = MAY_LJMP(luaL_checklstring(L, 2, &len));
4598
4599 /* Get the max amount of data which can write as input in the channel. */
4600 if (max > (len - l))
4601 max = len - l;
4602
4603 /* Copy data. */
Willy Tarreau0a7ef022019-05-28 10:30:11 +02004604 max = htx_add_data(htx, ist2(data + l, max));
Christopher Fauletf6cce3f2019-02-27 21:20:09 +01004605 channel_add_input(res, max);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004606
4607 /* update counters. */
4608 l += max;
4609 lua_pop(L, 1);
4610 lua_pushinteger(L, l);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004611
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004612 /* If some data is not send, declares the situation to the
4613 * applet, and returns a yield.
4614 */
4615 if (l < len) {
Christopher Faulet4b0e9b22019-01-09 12:16:58 +01004616 snd_yield:
Christopher Faulet0ae79d02019-02-27 21:36:59 +01004617 htx_to_buf(htx, &res->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004618 si_rx_room_blk(si);
4619 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_htx_send_yield, TICK_ETERNITY, 0));
4620 }
4621
Christopher Faulet0ae79d02019-02-27 21:36:59 +01004622 htx_to_buf(htx, &res->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004623 return 1;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004624}
4625
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004626/* Append data in the output side of the buffer. This data is immediately
4627 * sent. The function returns the amount of data written. If the buffer
4628 * cannot contain the data, the function yields. The function returns -1
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004629 * if the channel is closed.
4630 */
4631__LJMP static int hlua_applet_http_send_yield(lua_State *L, int status, lua_KContext ctx)
4632{
4633 size_t len;
4634 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4635 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
4636 int l = MAY_LJMP(luaL_checkinteger(L, 3));
4637 struct stream_interface *si = appctx->appctx->owner;
4638 struct channel *chn = si_ic(si);
4639 int max;
4640
4641 /* Get the max amount of data which can write as input in the channel. */
4642 max = channel_recv_max(chn);
4643 if (max > (len - l))
4644 max = len - l;
4645
4646 /* Copy data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02004647 ci_putblk(chn, str + l, max);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004648
4649 /* update counters. */
4650 l += max;
4651 lua_pop(L, 1);
4652 lua_pushinteger(L, l);
4653
4654 /* If some data is not send, declares the situation to the
4655 * applet, and returns a yield.
4656 */
4657 if (l < len) {
Willy Tarreaudb398432018-11-15 11:08:52 +01004658 si_rx_room_blk(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02004659 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004660 }
4661
4662 return 1;
4663}
4664
4665/* Just a wraper of "hlua_applet_send_yield". This wrapper permits
4666 * yield the LUA process, and resume it without checking the
4667 * input arguments.
4668 */
4669__LJMP static int hlua_applet_http_send(lua_State *L)
4670{
4671 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004672
4673 /* We want to send some data. Headers must be sent. */
4674 if (!(appctx->appctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT)) {
4675 hlua_pusherror(L, "Lua: 'send' you must call start_response() before sending data.");
4676 WILL_LJMP(lua_error(L));
4677 }
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004678
4679 if (IS_HTX_STRM(si_strm(appctx->appctx->owner))) {
4680 /* HTX version */
4681 /* This interger is used for followinf the amount of data sent. */
4682 lua_pushinteger(L, 0);
4683
4684 return MAY_LJMP(hlua_applet_htx_send_yield(L, 0, 0));
4685 }
4686 else {
4687 /* Legacy HTTP version */
4688 size_t len;
4689 char hex[10];
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004690
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004691 MAY_LJMP(luaL_checklstring(L, 2, &len));
4692
4693 /* If transfer encoding chunked is selected, we surround the data
4694 * by chunk data.
4695 */
4696 if (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_CHUNKED) {
4697 snprintf(hex, 9, "%x", (unsigned int)len);
4698 lua_pushfstring(L, "%s\r\n", hex);
4699 lua_insert(L, 2); /* swap the last 2 entries. */
4700 lua_pushstring(L, "\r\n");
4701 lua_concat(L, 3);
4702 }
4703
4704 /* This interger is used for followinf the amount of data sent. */
4705 lua_pushinteger(L, 0);
4706
4707 return MAY_LJMP(hlua_applet_http_send_yield(L, 0, 0));
4708 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004709}
4710
4711__LJMP static int hlua_applet_http_addheader(lua_State *L)
4712{
4713 const char *name;
4714 int ret;
4715
4716 MAY_LJMP(hlua_checkapplet_http(L, 1));
4717 name = MAY_LJMP(luaL_checkstring(L, 2));
4718 MAY_LJMP(luaL_checkstring(L, 3));
4719
4720 /* Push in the stack the "response" entry. */
4721 ret = lua_getfield(L, 1, "response");
4722 if (ret != LUA_TTABLE) {
4723 hlua_pusherror(L, "Lua: 'add_header' internal error: AppletHTTP['response'] "
4724 "is expected as an array. %s found", lua_typename(L, ret));
4725 WILL_LJMP(lua_error(L));
4726 }
4727
4728 /* check if the header is already registered if it is not
4729 * the case, register it.
4730 */
4731 ret = lua_getfield(L, -1, name);
4732 if (ret == LUA_TNIL) {
4733
4734 /* Entry not found. */
4735 lua_pop(L, 1); /* remove the nil. The "response" table is the top of the stack. */
4736
4737 /* Insert the new header name in the array in the top of the stack.
4738 * It left the new array in the top of the stack.
4739 */
4740 lua_newtable(L);
4741 lua_pushvalue(L, 2);
4742 lua_pushvalue(L, -2);
4743 lua_settable(L, -4);
4744
4745 } else if (ret != LUA_TTABLE) {
4746
4747 /* corruption error. */
4748 hlua_pusherror(L, "Lua: 'add_header' internal error: AppletHTTP['response']['%s'] "
4749 "is expected as an array. %s found", name, lua_typename(L, ret));
4750 WILL_LJMP(lua_error(L));
4751 }
4752
4753 /* Now the top od thestack is an array of values. We push
4754 * the header value as new entry.
4755 */
4756 lua_pushvalue(L, 3);
4757 ret = lua_rawlen(L, -2);
4758 lua_rawseti(L, -2, ret + 1);
4759 lua_pushboolean(L, 1);
4760 return 1;
4761}
4762
4763__LJMP static int hlua_applet_http_status(lua_State *L)
4764{
4765 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4766 int status = MAY_LJMP(luaL_checkinteger(L, 2));
Robin H. Johnson52f5db22017-01-01 13:10:52 -08004767 const char *reason = MAY_LJMP(luaL_optlstring(L, 3, NULL, NULL));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004768
4769 if (status < 100 || status > 599) {
4770 lua_pushboolean(L, 0);
4771 return 1;
4772 }
4773
4774 appctx->appctx->ctx.hlua_apphttp.status = status;
Robin H. Johnson52f5db22017-01-01 13:10:52 -08004775 appctx->appctx->ctx.hlua_apphttp.reason = reason;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004776 lua_pushboolean(L, 1);
4777 return 1;
4778}
4779
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004780
4781__LJMP static int hlua_applet_htx_send_response(lua_State *L)
4782{
4783 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4784 struct stream_interface *si = appctx->appctx->owner;
4785 struct channel *res = si_ic(si);
4786 struct htx *htx;
4787 struct htx_sl *sl;
4788 struct h1m h1m;
4789 const char *status, *reason;
4790 const char *name, *value;
4791 size_t nlen, vlen;
4792 unsigned int flags;
4793
4794 /* Send the message at once. */
4795 htx = htx_from_buf(&res->buf);
4796 h1m_init_res(&h1m);
4797
4798 /* Use the same http version than the request. */
4799 status = ultoa_r(appctx->appctx->ctx.hlua_apphttp.status, trash.area, trash.size);
4800 reason = appctx->appctx->ctx.hlua_apphttp.reason;
4801 if (reason == NULL)
4802 reason = http_get_reason(appctx->appctx->ctx.hlua_apphttp.status);
4803 if (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_HTTP11) {
4804 flags = (HTX_SL_F_IS_RESP|HTX_SL_F_VER_11);
4805 sl = htx_add_stline(htx, HTX_BLK_RES_SL, flags, ist("HTTP/1.1"), ist(status), ist(reason));
4806 }
4807 else {
4808 flags = HTX_SL_F_IS_RESP;
4809 sl = htx_add_stline(htx, HTX_BLK_RES_SL, flags, ist("HTTP/1.0"), ist(status), ist(reason));
4810 }
4811 if (!sl) {
4812 hlua_pusherror(L, "Lua applet http '%s': Failed to create response.\n",
4813 appctx->appctx->rule->arg.hlua_rule->fcn.name);
4814 WILL_LJMP(lua_error(L));
4815 }
4816 sl->info.res.status = appctx->appctx->ctx.hlua_apphttp.status;
4817
4818 /* Get the array associated to the field "response" in the object AppletHTTP. */
4819 lua_pushvalue(L, 0);
4820 if (lua_getfield(L, 1, "response") != LUA_TTABLE) {
4821 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response'] missing.\n",
4822 appctx->appctx->rule->arg.hlua_rule->fcn.name);
4823 WILL_LJMP(lua_error(L));
4824 }
4825
4826 /* Browse the list of headers. */
4827 lua_pushnil(L);
4828 while(lua_next(L, -2) != 0) {
4829 /* We expect a string as -2. */
4830 if (lua_type(L, -2) != LUA_TSTRING) {
4831 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response'][] element must be a string. got %s.\n",
4832 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4833 lua_typename(L, lua_type(L, -2)));
4834 WILL_LJMP(lua_error(L));
4835 }
4836 name = lua_tolstring(L, -2, &nlen);
4837
4838 /* We expect an array as -1. */
4839 if (lua_type(L, -1) != LUA_TTABLE) {
4840 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'] element must be an table. got %s.\n",
4841 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4842 name,
4843 lua_typename(L, lua_type(L, -1)));
4844 WILL_LJMP(lua_error(L));
4845 }
4846
4847 /* Browse the table who is on the top of the stack. */
4848 lua_pushnil(L);
4849 while(lua_next(L, -2) != 0) {
4850 int id;
4851
4852 /* We expect a number as -2. */
4853 if (lua_type(L, -2) != LUA_TNUMBER) {
4854 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'][] element must be a number. got %s.\n",
4855 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4856 name,
4857 lua_typename(L, lua_type(L, -2)));
4858 WILL_LJMP(lua_error(L));
4859 }
4860 id = lua_tointeger(L, -2);
4861
4862 /* We expect a string as -2. */
4863 if (lua_type(L, -1) != LUA_TSTRING) {
4864 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'][%d] element must be a string. got %s.\n",
4865 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4866 name, id,
4867 lua_typename(L, lua_type(L, -1)));
4868 WILL_LJMP(lua_error(L));
4869 }
4870 value = lua_tolstring(L, -1, &vlen);
4871
4872 /* Simple Protocol checks. */
4873 if (isteqi(ist2(name, nlen), ist("transfer-encoding")))
4874 h1_parse_xfer_enc_header(&h1m, ist2(name, nlen));
4875 else if (isteqi(ist2(name, nlen), ist("content-length"))) {
4876 struct ist v = ist2(value, vlen);
4877 int ret;
4878
4879 ret = h1_parse_cont_len_header(&h1m, &v);
4880 if (ret < 0) {
4881 hlua_pusherror(L, "Lua applet http '%s': Invalid '%s' header.\n",
4882 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4883 name);
4884 WILL_LJMP(lua_error(L));
4885 }
4886 else if (ret == 0)
4887 goto next; /* Skip it */
4888 }
4889
4890 /* Add a new header */
4891 if (!htx_add_header(htx, ist2(name, nlen), ist2(value, vlen))) {
4892 hlua_pusherror(L, "Lua applet http '%s': Failed to add header '%s' in the response.\n",
4893 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4894 name);
4895 WILL_LJMP(lua_error(L));
4896 }
4897 next:
4898 /* Remove the array from the stack, and get next element with a remaining string. */
4899 lua_pop(L, 1);
4900 }
4901
4902 /* Remove the array from the stack, and get next element with a remaining string. */
4903 lua_pop(L, 1);
4904 }
4905
4906 if (h1m.flags & H1_MF_CHNK)
4907 h1m.flags &= ~H1_MF_CLEN;
4908 if (h1m.flags & (H1_MF_CLEN|H1_MF_CHNK))
4909 h1m.flags |= H1_MF_XFER_LEN;
4910
4911 /* Uset HTX start-line flags */
4912 if (h1m.flags & H1_MF_XFER_ENC)
4913 flags |= HTX_SL_F_XFER_ENC;
4914 if (h1m.flags & H1_MF_XFER_LEN) {
4915 flags |= HTX_SL_F_XFER_LEN;
4916 if (h1m.flags & H1_MF_CHNK)
4917 flags |= HTX_SL_F_CHNK;
4918 else if (h1m.flags & H1_MF_CLEN)
4919 flags |= HTX_SL_F_CLEN;
4920 if (h1m.body_len == 0)
4921 flags |= HTX_SL_F_BODYLESS;
4922 }
4923 sl->flags |= flags;
4924
4925 /* If we dont have a content-length set, and the HTTP version is 1.1
4926 * and the status code implies the presence of a message body, we must
4927 * announce a transfer encoding chunked. This is required by haproxy
4928 * for the keepalive compliance. If the applet annouces a transfer-encoding
4929 * chunked itslef, don't do anything.
4930 */
4931 if ((flags & (HTX_SL_F_VER_11|HTX_SL_F_XFER_LEN)) == HTX_SL_F_VER_11 &&
4932 appctx->appctx->ctx.hlua_apphttp.status >= 200 &&
4933 appctx->appctx->ctx.hlua_apphttp.status != 204 &&
4934 appctx->appctx->ctx.hlua_apphttp.status != 304) {
4935 /* Add a new header */
4936 sl->flags |= (HTX_SL_F_XFER_ENC|H1_MF_CHNK|H1_MF_XFER_LEN);
4937 if (!htx_add_header(htx, ist("transfer-encoding"), ist("chunked"))) {
4938 hlua_pusherror(L, "Lua applet http '%s': Failed to add header 'transfer-encoding' in the response.\n",
4939 appctx->appctx->rule->arg.hlua_rule->fcn.name);
4940 WILL_LJMP(lua_error(L));
4941 }
4942 }
4943
4944 /* Finalize headers. */
4945 if (!htx_add_endof(htx, HTX_BLK_EOH)) {
4946 hlua_pusherror(L, "Lua applet http '%s': Failed create the response.\n",
4947 appctx->appctx->rule->arg.hlua_rule->fcn.name);
4948 WILL_LJMP(lua_error(L));
4949 }
4950
4951 if (htx_used_space(htx) > b_size(&res->buf) - global.tune.maxrewrite) {
4952 b_reset(&res->buf);
4953 hlua_pusherror(L, "Lua: 'start_response': response header block too big");
4954 WILL_LJMP(lua_error(L));
4955 }
4956
4957 htx_to_buf(htx, &res->buf);
Christopher Fauletf6cce3f2019-02-27 21:20:09 +01004958 channel_add_input(res, htx->data);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004959
4960 /* Headers sent, set the flag. */
4961 appctx->appctx->ctx.hlua_apphttp.flags |= APPLET_HDR_SENT;
4962 return 0;
4963
4964}
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004965/* We will build the status line and the headers of the HTTP response.
4966 * We will try send at once if its not possible, we give back the hand
4967 * waiting for more room.
4968 */
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004969__LJMP static int hlua_applet_htx_start_response_yield(lua_State *L, int status, lua_KContext ctx)
4970{
4971 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4972 struct stream_interface *si = appctx->appctx->owner;
4973 struct channel *res = si_ic(si);
4974
4975 if (co_data(res)) {
4976 si_rx_room_blk(si);
4977 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_htx_start_response_yield, TICK_ETERNITY, 0));
4978 }
4979 return MAY_LJMP(hlua_applet_htx_send_response(L));
4980}
4981
4982
4983__LJMP static int hlua_applet_htx_start_response(lua_State *L)
4984{
4985 return MAY_LJMP(hlua_applet_htx_start_response_yield(L, 0, 0));
4986}
4987
4988/* We will build the status line and the headers of the HTTP response.
4989 * We will try send at once if its not possible, we give back the hand
4990 * waiting for more room.
4991 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004992__LJMP static int hlua_applet_http_start_response_yield(lua_State *L, int status, lua_KContext ctx)
4993{
4994 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4995 struct stream_interface *si = appctx->appctx->owner;
4996 struct channel *chn = si_ic(si);
4997 int ret;
4998 size_t len;
4999 const char *msg;
5000
5001 /* Get the message as the first argument on the stack. */
5002 msg = MAY_LJMP(luaL_checklstring(L, 2, &len));
5003
5004 /* Send the message at once. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02005005 ret = ci_putblk(chn, msg, len);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005006
5007 /* if ret == -2 or -3 the channel closed or the message si too
5008 * big for the buffers.
5009 */
5010 if (ret == -2 || ret == -3) {
5011 hlua_pusherror(L, "Lua: 'start_response': response header block too big");
5012 WILL_LJMP(lua_error(L));
5013 }
5014
5015 /* If ret is -1, we dont have room in the buffer, so we yield. */
5016 if (ret == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01005017 si_rx_room_blk(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02005018 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_start_response_yield, TICK_ETERNITY, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005019 }
5020
5021 /* Headers sent, set the flag. */
5022 appctx->appctx->ctx.hlua_apphttp.flags |= APPLET_HDR_SENT;
5023 return 0;
5024}
5025
5026__LJMP static int hlua_applet_http_start_response(lua_State *L)
5027{
Christopher Faulet9c832fc2018-12-14 13:34:05 +01005028 struct buffer *tmp;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005029 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005030 const char *name;
Willy Tarreaua3294632017-08-23 11:24:47 +02005031 size_t name_len;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005032 const char *value;
Willy Tarreaua3294632017-08-23 11:24:47 +02005033 size_t value_len;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005034 int id;
Willy Tarreauc9f4ea02017-08-23 09:32:06 +02005035 long long hdr_contentlength = -1;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005036 int hdr_chunked = 0;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01005037 const char *reason;
5038
5039 if (IS_HTX_STRM(si_strm(appctx->appctx->owner)))
5040 return MAY_LJMP(hlua_applet_htx_start_response(L));
Robin H. Johnson52f5db22017-01-01 13:10:52 -08005041
Christopher Faulet9c832fc2018-12-14 13:34:05 +01005042 reason = appctx->appctx->ctx.hlua_apphttp.reason;
Robin H. Johnson52f5db22017-01-01 13:10:52 -08005043 if (reason == NULL)
Willy Tarreau04f1e2d2018-09-10 18:04:24 +02005044 reason = http_get_reason(appctx->appctx->ctx.hlua_apphttp.status);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005045
Christopher Faulet9c832fc2018-12-14 13:34:05 +01005046 tmp = get_trash_chunk();
5047
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005048 /* Use the same http version than the request. */
5049 chunk_appendf(tmp, "HTTP/1.%c %d %s\r\n",
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +01005050 appctx->appctx->ctx.hlua_apphttp.flags & APPLET_HTTP11 ? '1' : '0',
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005051 appctx->appctx->ctx.hlua_apphttp.status,
Robin H. Johnson52f5db22017-01-01 13:10:52 -08005052 reason);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005053
5054 /* Get the array associated to the field "response" in the object AppletHTTP. */
5055 lua_pushvalue(L, 0);
5056 if (lua_getfield(L, 1, "response") != LUA_TTABLE) {
5057 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response'] missing.\n",
5058 appctx->appctx->rule->arg.hlua_rule->fcn.name);
5059 WILL_LJMP(lua_error(L));
5060 }
5061
5062 /* Browse the list of headers. */
5063 lua_pushnil(L);
5064 while(lua_next(L, -2) != 0) {
5065
5066 /* We expect a string as -2. */
5067 if (lua_type(L, -2) != LUA_TSTRING) {
5068 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response'][] element must be a string. got %s.\n",
5069 appctx->appctx->rule->arg.hlua_rule->fcn.name,
5070 lua_typename(L, lua_type(L, -2)));
5071 WILL_LJMP(lua_error(L));
5072 }
Willy Tarreaua3294632017-08-23 11:24:47 +02005073 name = lua_tolstring(L, -2, &name_len);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005074
5075 /* We expect an array as -1. */
5076 if (lua_type(L, -1) != LUA_TTABLE) {
5077 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'] element must be an table. got %s.\n",
5078 appctx->appctx->rule->arg.hlua_rule->fcn.name,
5079 name,
5080 lua_typename(L, lua_type(L, -1)));
5081 WILL_LJMP(lua_error(L));
5082 }
5083
5084 /* Browse the table who is on the top of the stack. */
5085 lua_pushnil(L);
5086 while(lua_next(L, -2) != 0) {
5087
5088 /* We expect a number as -2. */
5089 if (lua_type(L, -2) != LUA_TNUMBER) {
5090 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'][] element must be a number. got %s.\n",
5091 appctx->appctx->rule->arg.hlua_rule->fcn.name,
5092 name,
5093 lua_typename(L, lua_type(L, -2)));
5094 WILL_LJMP(lua_error(L));
5095 }
5096 id = lua_tointeger(L, -2);
5097
5098 /* We expect a string as -2. */
5099 if (lua_type(L, -1) != LUA_TSTRING) {
5100 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'][%d] element must be a string. got %s.\n",
5101 appctx->appctx->rule->arg.hlua_rule->fcn.name,
5102 name, id,
5103 lua_typename(L, lua_type(L, -1)));
5104 WILL_LJMP(lua_error(L));
5105 }
Willy Tarreaua3294632017-08-23 11:24:47 +02005106 value = lua_tolstring(L, -1, &value_len);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005107
5108 /* Catenate a new header. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005109 if (tmp->data + name_len + 2 + value_len + 2 < tmp->size) {
5110 memcpy(tmp->area + tmp->data, name, name_len);
5111 tmp->data += name_len;
5112 tmp->area[tmp->data++] = ':';
5113 tmp->area[tmp->data++] = ' ';
Willy Tarreaua3294632017-08-23 11:24:47 +02005114
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005115 memcpy(tmp->area + tmp->data, value,
5116 value_len);
5117 tmp->data += value_len;
5118 tmp->area[tmp->data++] = '\r';
5119 tmp->area[tmp->data++] = '\n';
Willy Tarreaua3294632017-08-23 11:24:47 +02005120 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005121
5122 /* Protocol checks. */
5123
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005124 /* Copy the header content length. The length conversion
Willy Tarreauc9f4ea02017-08-23 09:32:06 +02005125 * is done without control. If it contains a bad value,
5126 * the content-length remains negative so that we can
5127 * switch to either chunked encoding or close.
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005128 */
Willy Tarreaua3294632017-08-23 11:24:47 +02005129 if (name_len == 14 && strcasecmp("content-length", name) == 0)
Willy Tarreauc9f4ea02017-08-23 09:32:06 +02005130 strl2llrc(value, strlen(value), &hdr_contentlength);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005131
5132 /* Check if the client annouces a transfer-encoding chunked it self. */
Willy Tarreaua3294632017-08-23 11:24:47 +02005133 if (name_len == 17 && value_len == 7 &&
5134 strcasecmp("transfer-encoding", name) == 0 &&
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005135 strcasecmp("chunked", value) == 0)
5136 hdr_chunked = 1;
5137
5138 /* Remove the array from the stack, and get next element with a remaining string. */
5139 lua_pop(L, 1);
5140 }
5141
5142 /* Remove the array from the stack, and get next element with a remaining string. */
5143 lua_pop(L, 1);
5144 }
5145
Willy Tarreau06c75fe2017-08-23 09:10:38 +02005146 /* If we dont have a content-length set, and the HTTP version is 1.1
5147 * and the status code implies the presence of a message body, we must
5148 * announce a transfer encoding chunked. This is required by haproxy
5149 * for the keepalive compliance. If the applet annouces a transfer-encoding
5150 * chunked itslef, don't do anything.
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005151 */
Willy Tarreauc9f4ea02017-08-23 09:32:06 +02005152 if (hdr_contentlength < 0 && hdr_chunked == 0 &&
Willy Tarreau06c75fe2017-08-23 09:10:38 +02005153 (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_HTTP11) &&
5154 appctx->appctx->ctx.hlua_apphttp.status >= 200 &&
5155 appctx->appctx->ctx.hlua_apphttp.status != 204 &&
5156 appctx->appctx->ctx.hlua_apphttp.status != 304) {
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005157 chunk_appendf(tmp, "Transfer-encoding: chunked\r\n");
5158 appctx->appctx->ctx.hlua_apphttp.flags |= APPLET_CHUNKED;
5159 }
5160
5161 /* Finalize headers. */
5162 chunk_appendf(tmp, "\r\n");
5163
5164 /* Remove the last entry and the array of headers */
5165 lua_pop(L, 2);
5166
5167 /* Push the headers block. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005168 lua_pushlstring(L, tmp->area, tmp->data);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005169
5170 return MAY_LJMP(hlua_applet_http_start_response_yield(L, 0, 0));
5171}
5172
5173/*
5174 *
5175 *
5176 * Class HTTP
5177 *
5178 *
5179 */
5180
5181/* Returns a struct hlua_txn if the stack entry "ud" is
5182 * a class stream, otherwise it throws an error.
5183 */
5184__LJMP static struct hlua_txn *hlua_checkhttp(lua_State *L, int ud)
5185{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02005186 return MAY_LJMP(hlua_checkudata(L, ud, class_http_ref));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005187}
5188
5189/* This function creates and push in the stack a HTTP object
5190 * according with a current TXN.
5191 */
5192static int hlua_http_new(lua_State *L, struct hlua_txn *txn)
5193{
5194 struct hlua_txn *htxn;
5195
5196 /* Check stack size. */
5197 if (!lua_checkstack(L, 3))
5198 return 0;
5199
5200 /* Create the object: obj[0] = userdata.
5201 * Note that the base of the Converters object is the
5202 * same than the TXN object.
5203 */
5204 lua_newtable(L);
5205 htxn = lua_newuserdata(L, sizeof(*htxn));
5206 lua_rawseti(L, -2, 0);
5207
5208 htxn->s = txn->s;
5209 htxn->p = txn->p;
Christopher Faulet256b69a2019-05-23 11:14:21 +02005210 htxn->dir = txn->dir;
5211 htxn->flags = txn->flags;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005212
5213 /* Pop a class stream metatable and affect it to the table. */
5214 lua_rawgeti(L, LUA_REGISTRYINDEX, class_http_ref);
5215 lua_setmetatable(L, -2);
5216
5217 return 1;
5218}
5219
5220/* This function creates ans returns an array of HTTP headers.
5221 * This function does not fails. It is used as wrapper with the
5222 * 2 following functions.
5223 */
5224__LJMP static int hlua_http_get_headers(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg)
5225{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005226 /* Create the table. */
5227 lua_newtable(L);
5228
5229 if (!htxn->s->txn)
5230 return 1;
5231
Christopher Faulet724a12c2018-12-13 22:12:15 +01005232 if (IS_HTX_STRM(htxn->s)) {
5233 /* HTX version */
5234 struct htx *htx = htxbuf(&msg->chn->buf);
5235 int32_t pos;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005236
Christopher Fauleta3f15502019-05-13 15:27:23 +02005237 for (pos = htx_get_first(htx); pos != -1; pos = htx_get_next(htx, pos)) {
Christopher Faulet724a12c2018-12-13 22:12:15 +01005238 struct htx_blk *blk = htx_get_blk(htx, pos);
5239 enum htx_blk_type type = htx_get_blk_type(blk);
5240 struct ist n, v;
5241 int len;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005242
Christopher Faulet724a12c2018-12-13 22:12:15 +01005243 if (type == HTX_BLK_HDR) {
5244 n = htx_get_blk_name(htx,blk);
5245 v = htx_get_blk_value(htx, blk);
5246 }
5247 else if (type == HTX_BLK_EOH)
5248 break;
5249 else
5250 continue;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005251
Christopher Faulet724a12c2018-12-13 22:12:15 +01005252 /* Check for existing entry:
5253 * assume that the table is on the top of the stack, and
5254 * push the key in the stack, the function lua_gettable()
5255 * perform the lookup.
5256 */
5257 lua_pushlstring(L, n.ptr, n.len);
5258 lua_gettable(L, -2);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005259
Christopher Faulet724a12c2018-12-13 22:12:15 +01005260 switch (lua_type(L, -1)) {
5261 case LUA_TNIL:
5262 /* Table not found, create it. */
5263 lua_pop(L, 1); /* remove the nil value. */
5264 lua_pushlstring(L, n.ptr, n.len); /* push the header name as key. */
5265 lua_newtable(L); /* create and push empty table. */
5266 lua_pushlstring(L, v.ptr, v.len); /* push header value. */
5267 lua_rawseti(L, -2, 0); /* index header value (pop it). */
5268 lua_rawset(L, -3); /* index new table with header name (pop the values). */
5269 break;
5270
5271 case LUA_TTABLE:
5272 /* Entry found: push the value in the table. */
5273 len = lua_rawlen(L, -1);
5274 lua_pushlstring(L, v.ptr, v.len); /* push header value. */
5275 lua_rawseti(L, -2, len+1); /* index header value (pop it). */
5276 lua_pop(L, 1); /* remove the table (it is stored in the main table). */
5277 break;
5278
5279 default:
5280 /* Other cases are errors. */
5281 hlua_pusherror(L, "internal error during the parsing of headers.");
5282 WILL_LJMP(lua_error(L));
5283 }
5284 }
5285 }
5286 else {
5287 /* Legacy HTTP version */
5288 const char *cur_ptr, *cur_next, *p;
5289 int old_idx, cur_idx;
5290 struct hdr_idx_elem *cur_hdr;
5291 const char *hn, *hv;
5292 int hnl, hvl;
5293 const char *in;
5294 char *out;
5295 int len;
5296
5297 /* Build array of headers. */
5298 old_idx = 0;
5299 cur_next = ci_head(msg->chn) + hdr_idx_first_pos(&htxn->s->txn->hdr_idx);
5300
5301 while (1) {
5302 cur_idx = htxn->s->txn->hdr_idx.v[old_idx].next;
5303 if (!cur_idx)
5304 break;
5305 old_idx = cur_idx;
5306
5307 cur_hdr = &htxn->s->txn->hdr_idx.v[cur_idx];
5308 cur_ptr = cur_next;
5309 cur_next = cur_ptr + cur_hdr->len + cur_hdr->cr + 1;
5310
5311 /* Now we have one full header at cur_ptr of len cur_hdr->len,
5312 * and the next header starts at cur_next. We'll check
5313 * this header in the list as well as against the default
5314 * rule.
5315 */
5316
5317 /* look for ': *'. */
5318 hn = cur_ptr;
5319 for (p = cur_ptr; p < cur_ptr + cur_hdr->len && *p != ':'; p++);
5320 if (p >= cur_ptr+cur_hdr->len)
5321 continue;
5322 hnl = p - hn;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005323 p++;
Christopher Faulet724a12c2018-12-13 22:12:15 +01005324 while (p < cur_ptr+cur_hdr->len && ( *p == ' ' || *p == '\t' ))
5325 p++;
5326 if (p >= cur_ptr+cur_hdr->len)
5327 continue;
5328 hv = p;
5329 hvl = cur_ptr+cur_hdr->len-p;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005330
Christopher Faulet724a12c2018-12-13 22:12:15 +01005331 /* Lowercase the key. Don't check the size of trash, it have
5332 * the size of one buffer and the input data contains in one
5333 * buffer.
5334 */
5335 out = trash.area;
5336 for (in=hn; in<hn+hnl; in++, out++)
5337 *out = tolower(*in);
5338 *out = '\0';
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005339
Christopher Faulet724a12c2018-12-13 22:12:15 +01005340 /* Check for existing entry:
5341 * assume that the table is on the top of the stack, and
5342 * push the key in the stack, the function lua_gettable()
5343 * perform the lookup.
5344 */
5345 lua_pushlstring(L, trash.area, hnl);
5346 lua_gettable(L, -2);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005347
Christopher Faulet724a12c2018-12-13 22:12:15 +01005348 switch (lua_type(L, -1)) {
5349 case LUA_TNIL:
5350 /* Table not found, create it. */
5351 lua_pop(L, 1); /* remove the nil value. */
5352 lua_pushlstring(L, trash.area, hnl); /* push the header name as key. */
5353 lua_newtable(L); /* create and push empty table. */
5354 lua_pushlstring(L, hv, hvl); /* push header value. */
5355 lua_rawseti(L, -2, 0); /* index header value (pop it). */
5356 lua_rawset(L, -3); /* index new table with header name (pop the values). */
5357 break;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005358
Christopher Faulet724a12c2018-12-13 22:12:15 +01005359 case LUA_TTABLE:
5360 /* Entry found: push the value in the table. */
5361 len = lua_rawlen(L, -1);
5362 lua_pushlstring(L, hv, hvl); /* push header value. */
5363 lua_rawseti(L, -2, len+1); /* index header value (pop it). */
5364 lua_pop(L, 1); /* remove the table (it is stored in the main table). */
5365 break;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005366
Christopher Faulet724a12c2018-12-13 22:12:15 +01005367 default:
5368 /* Other cases are errors. */
5369 hlua_pusherror(L, "internal error during the parsing of headers.");
5370 WILL_LJMP(lua_error(L));
5371 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005372 }
5373 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005374 return 1;
5375}
5376
5377__LJMP static int hlua_http_req_get_headers(lua_State *L)
5378{
5379 struct hlua_txn *htxn;
5380
5381 MAY_LJMP(check_args(L, 1, "req_get_headers"));
5382 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5383
Christopher Faulet2351ca22019-07-26 16:31:34 +02005384 if (htxn->dir != SMP_OPT_DIR_REQ || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005385 WILL_LJMP(lua_error(L));
5386
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005387 return hlua_http_get_headers(L, htxn, &htxn->s->txn->req);
5388}
5389
5390__LJMP static int hlua_http_res_get_headers(lua_State *L)
5391{
5392 struct hlua_txn *htxn;
5393
5394 MAY_LJMP(check_args(L, 1, "res_get_headers"));
5395 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5396
Christopher Faulet2351ca22019-07-26 16:31:34 +02005397 if (htxn->dir != SMP_OPT_DIR_RES || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005398 WILL_LJMP(lua_error(L));
5399
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005400 return hlua_http_get_headers(L, htxn, &htxn->s->txn->rsp);
5401}
5402
5403/* This function replace full header, or just a value in
5404 * the request or in the response. It is a wrapper fir the
5405 * 4 following functions.
5406 */
5407__LJMP static inline int hlua_http_rep_hdr(lua_State *L, struct hlua_txn *htxn,
5408 struct http_msg *msg, int action)
5409{
5410 size_t name_len;
5411 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
5412 const char *reg = MAY_LJMP(luaL_checkstring(L, 3));
5413 const char *value = MAY_LJMP(luaL_checkstring(L, 4));
Dragan Dosen26743032019-04-30 15:54:36 +02005414 struct my_regex *re;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005415
Dragan Dosen26743032019-04-30 15:54:36 +02005416 if (!(re = regex_comp(reg, 1, 1, NULL)))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005417 WILL_LJMP(luaL_argerror(L, 3, "invalid regex"));
5418
Christopher Faulet5a8549e2019-06-17 13:36:06 +02005419 if (IS_HTX_STRM(htxn->s)) {
5420 struct htx *htx = htxbuf(&msg->chn->buf);
5421
5422 htx_transform_header_str(htxn->s, msg->chn, htx, ist2(name, name_len), value, re, action);
5423 }
5424 else
5425 http_transform_header_str(htxn->s, msg, name, name_len, value, re, action);
Dragan Dosen26743032019-04-30 15:54:36 +02005426 regex_free(re);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005427 return 0;
5428}
5429
5430__LJMP static int hlua_http_req_rep_hdr(lua_State *L)
5431{
5432 struct hlua_txn *htxn;
5433
5434 MAY_LJMP(check_args(L, 4, "req_rep_hdr"));
5435 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5436
Christopher Faulet2351ca22019-07-26 16:31:34 +02005437 if (htxn->dir != SMP_OPT_DIR_REQ || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005438 WILL_LJMP(lua_error(L));
5439
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005440 return MAY_LJMP(hlua_http_rep_hdr(L, htxn, &htxn->s->txn->req, ACT_HTTP_REPLACE_HDR));
5441}
5442
5443__LJMP static int hlua_http_res_rep_hdr(lua_State *L)
5444{
5445 struct hlua_txn *htxn;
5446
5447 MAY_LJMP(check_args(L, 4, "res_rep_hdr"));
5448 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5449
Christopher Faulet2351ca22019-07-26 16:31:34 +02005450 if (htxn->dir != SMP_OPT_DIR_RES || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005451 WILL_LJMP(lua_error(L));
5452
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005453 return MAY_LJMP(hlua_http_rep_hdr(L, htxn, &htxn->s->txn->rsp, ACT_HTTP_REPLACE_HDR));
5454}
5455
5456__LJMP static int hlua_http_req_rep_val(lua_State *L)
5457{
5458 struct hlua_txn *htxn;
5459
5460 MAY_LJMP(check_args(L, 4, "req_rep_hdr"));
5461 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5462
Christopher Faulet2351ca22019-07-26 16:31:34 +02005463 if (htxn->dir != SMP_OPT_DIR_REQ || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005464 WILL_LJMP(lua_error(L));
5465
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005466 return MAY_LJMP(hlua_http_rep_hdr(L, htxn, &htxn->s->txn->req, ACT_HTTP_REPLACE_VAL));
5467}
5468
5469__LJMP static int hlua_http_res_rep_val(lua_State *L)
5470{
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005471 struct hlua_txn *htxn;
5472
5473 MAY_LJMP(check_args(L, 4, "res_rep_val"));
5474 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5475
Christopher Faulet2351ca22019-07-26 16:31:34 +02005476 if (htxn->dir != SMP_OPT_DIR_RES || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005477 WILL_LJMP(lua_error(L));
5478
Thierry FOURNIER0ea5c7f2015-08-05 19:05:19 +02005479 return MAY_LJMP(hlua_http_rep_hdr(L, htxn, &htxn->s->txn->rsp, ACT_HTTP_REPLACE_VAL));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005480}
5481
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08005482/* This function deletes all the occurrences of an header.
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005483 * It is a wrapper for the 2 following functions.
5484 */
5485__LJMP static inline int hlua_http_del_hdr(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg)
5486{
5487 size_t len;
5488 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005489
Christopher Faulet724a12c2018-12-13 22:12:15 +01005490 if (IS_HTX_STRM(htxn->s)) {
5491 /* HTX version */
5492 struct htx *htx = htxbuf(&msg->chn->buf);
5493 struct http_hdr_ctx ctx;
5494
5495 ctx.blk = NULL;
5496 while (http_find_header(htx, ist2(name, len), &ctx, 1))
5497 http_remove_header(htx, &ctx);
5498 }
5499 else {
5500 /* Legacy HTTP version */
5501 struct hdr_ctx ctx;
5502 struct http_txn *txn = htxn->s->txn;
5503
5504 ctx.idx = 0;
5505 while (http_find_header2(name, len, ci_head(msg->chn), &txn->hdr_idx, &ctx))
5506 http_remove_header2(msg, &txn->hdr_idx, &ctx);
5507 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005508 return 0;
5509}
5510
5511__LJMP static int hlua_http_req_del_hdr(lua_State *L)
5512{
5513 struct hlua_txn *htxn;
5514
5515 MAY_LJMP(check_args(L, 2, "req_del_hdr"));
5516 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5517
Christopher Faulet2351ca22019-07-26 16:31:34 +02005518 if (htxn->dir != SMP_OPT_DIR_REQ || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005519 WILL_LJMP(lua_error(L));
5520
Willy Tarreaueee5b512015-04-03 23:46:31 +02005521 return hlua_http_del_hdr(L, htxn, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005522}
5523
5524__LJMP static int hlua_http_res_del_hdr(lua_State *L)
5525{
5526 struct hlua_txn *htxn;
5527
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005528 MAY_LJMP(check_args(L, 2, "res_del_hdr"));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005529 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5530
Christopher Faulet2351ca22019-07-26 16:31:34 +02005531 if (htxn->dir != SMP_OPT_DIR_RES || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005532 WILL_LJMP(lua_error(L));
5533
Willy Tarreaueee5b512015-04-03 23:46:31 +02005534 return hlua_http_del_hdr(L, htxn, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005535}
5536
5537/* This function adds an header. It is a wrapper used by
5538 * the 2 following functions.
5539 */
5540__LJMP static inline int hlua_http_add_hdr(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg)
5541{
5542 size_t name_len;
5543 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
5544 size_t value_len;
5545 const char *value = MAY_LJMP(luaL_checklstring(L, 3, &value_len));
5546 char *p;
5547
Christopher Faulet724a12c2018-12-13 22:12:15 +01005548 if (IS_HTX_STRM(htxn->s)) {
5549 /* HTX version */
5550 struct htx *htx = htxbuf(&msg->chn->buf);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005551
Christopher Faulet724a12c2018-12-13 22:12:15 +01005552 lua_pushboolean(L, http_add_header(htx, ist2(name, name_len),
5553 ist2(value, value_len)));
5554 }
5555 else {
5556 /* Legacy HTTP version */
5557 /* Check length. */
5558 trash.data = value_len + name_len + 2;
5559 if (trash.data > trash.size)
5560 return 0;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005561
Christopher Faulet724a12c2018-12-13 22:12:15 +01005562 /* Creates the header string. */
5563 p = trash.area;
5564 memcpy(p, name, name_len);
5565 p += name_len;
5566 *p = ':';
5567 p++;
5568 *p = ' ';
5569 p++;
5570 memcpy(p, value, value_len);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005571
Christopher Faulet724a12c2018-12-13 22:12:15 +01005572 lua_pushboolean(L, http_header_add_tail2(msg, &htxn->s->txn->hdr_idx,
5573 trash.area, trash.data) != 0);
5574 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005575 return 0;
5576}
5577
5578__LJMP static int hlua_http_req_add_hdr(lua_State *L)
5579{
5580 struct hlua_txn *htxn;
5581
5582 MAY_LJMP(check_args(L, 3, "req_add_hdr"));
5583 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5584
Christopher Faulet2351ca22019-07-26 16:31:34 +02005585 if (htxn->dir != SMP_OPT_DIR_REQ || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005586 WILL_LJMP(lua_error(L));
5587
Willy Tarreaueee5b512015-04-03 23:46:31 +02005588 return hlua_http_add_hdr(L, htxn, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005589}
5590
5591__LJMP static int hlua_http_res_add_hdr(lua_State *L)
5592{
5593 struct hlua_txn *htxn;
5594
5595 MAY_LJMP(check_args(L, 3, "res_add_hdr"));
5596 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5597
Christopher Faulet2351ca22019-07-26 16:31:34 +02005598 if (htxn->dir != SMP_OPT_DIR_RES || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005599 WILL_LJMP(lua_error(L));
5600
Willy Tarreaueee5b512015-04-03 23:46:31 +02005601 return hlua_http_add_hdr(L, htxn, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005602}
5603
5604static int hlua_http_req_set_hdr(lua_State *L)
5605{
5606 struct hlua_txn *htxn;
5607
5608 MAY_LJMP(check_args(L, 3, "req_set_hdr"));
5609 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5610
Christopher Faulet2351ca22019-07-26 16:31:34 +02005611 if (htxn->dir != SMP_OPT_DIR_REQ || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005612 WILL_LJMP(lua_error(L));
5613
Willy Tarreaueee5b512015-04-03 23:46:31 +02005614 hlua_http_del_hdr(L, htxn, &htxn->s->txn->req);
5615 return hlua_http_add_hdr(L, htxn, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005616}
5617
5618static int hlua_http_res_set_hdr(lua_State *L)
5619{
5620 struct hlua_txn *htxn;
5621
5622 MAY_LJMP(check_args(L, 3, "res_set_hdr"));
5623 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5624
Christopher Faulet2351ca22019-07-26 16:31:34 +02005625 if (htxn->dir != SMP_OPT_DIR_RES || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005626 WILL_LJMP(lua_error(L));
5627
Willy Tarreaueee5b512015-04-03 23:46:31 +02005628 hlua_http_del_hdr(L, htxn, &htxn->s->txn->rsp);
5629 return hlua_http_add_hdr(L, htxn, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005630}
5631
5632/* This function set the method. */
5633static int hlua_http_req_set_meth(lua_State *L)
5634{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02005635 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005636 size_t name_len;
5637 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005638
Christopher Faulet2351ca22019-07-26 16:31:34 +02005639 if (htxn->dir != SMP_OPT_DIR_REQ || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005640 WILL_LJMP(lua_error(L));
5641
Willy Tarreau987e3fb2015-04-04 01:09:08 +02005642 lua_pushboolean(L, http_replace_req_line(0, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005643 return 1;
5644}
5645
5646/* This function set the method. */
5647static int hlua_http_req_set_path(lua_State *L)
5648{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02005649 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005650 size_t name_len;
5651 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER / OZON.IOb84ae922016-08-02 23:44:58 +02005652
Christopher Faulet2351ca22019-07-26 16:31:34 +02005653 if (htxn->dir != SMP_OPT_DIR_REQ || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005654 WILL_LJMP(lua_error(L));
5655
Willy Tarreau987e3fb2015-04-04 01:09:08 +02005656 lua_pushboolean(L, http_replace_req_line(1, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005657 return 1;
5658}
5659
5660/* This function set the query-string. */
5661static int hlua_http_req_set_query(lua_State *L)
5662{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02005663 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005664 size_t name_len;
5665 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005666
Christopher Faulet2351ca22019-07-26 16:31:34 +02005667 if (htxn->dir != SMP_OPT_DIR_REQ || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005668 WILL_LJMP(lua_error(L));
5669
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005670 /* Check length. */
5671 if (name_len > trash.size - 1) {
5672 lua_pushboolean(L, 0);
5673 return 1;
5674 }
5675
5676 /* Add the mark question as prefix. */
5677 chunk_reset(&trash);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005678 trash.area[trash.data++] = '?';
5679 memcpy(trash.area + trash.data, name, name_len);
5680 trash.data += name_len;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005681
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005682 lua_pushboolean(L,
5683 http_replace_req_line(2, trash.area, trash.data, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005684 return 1;
5685}
5686
5687/* This function set the uri. */
5688static int hlua_http_req_set_uri(lua_State *L)
5689{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02005690 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005691 size_t name_len;
5692 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005693
Christopher Faulet2351ca22019-07-26 16:31:34 +02005694 if (htxn->dir != SMP_OPT_DIR_REQ || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005695 WILL_LJMP(lua_error(L));
5696
Willy Tarreau987e3fb2015-04-04 01:09:08 +02005697 lua_pushboolean(L, http_replace_req_line(3, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005698 return 1;
5699}
5700
Robin H. Johnson52f5db22017-01-01 13:10:52 -08005701/* This function set the response code & optionally reason. */
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02005702static int hlua_http_res_set_status(lua_State *L)
5703{
5704 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5705 unsigned int code = MAY_LJMP(luaL_checkinteger(L, 2));
Robin H. Johnson52f5db22017-01-01 13:10:52 -08005706 const char *reason = MAY_LJMP(luaL_optlstring(L, 3, NULL, NULL));
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02005707
Christopher Faulet2351ca22019-07-26 16:31:34 +02005708 if (htxn->dir != SMP_OPT_DIR_RES || !(htxn->flags & HLUA_TXN_HTTP_RDY))
Christopher Fauletdc2ee272019-07-26 16:17:01 +02005709 WILL_LJMP(lua_error(L));
5710
Robin H. Johnson52f5db22017-01-01 13:10:52 -08005711 http_set_status(code, reason, htxn->s);
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02005712 return 0;
5713}
5714
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005715/*
5716 *
5717 *
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005718 * Class TXN
5719 *
5720 *
5721 */
5722
5723/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02005724 * a class stream, otherwise it throws an error.
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005725 */
5726__LJMP static struct hlua_txn *hlua_checktxn(lua_State *L, int ud)
5727{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02005728 return MAY_LJMP(hlua_checkudata(L, ud, class_txn_ref));
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005729}
5730
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005731__LJMP static int hlua_set_var(lua_State *L)
5732{
5733 struct hlua_txn *htxn;
5734 const char *name;
5735 size_t len;
5736 struct sample smp;
5737
5738 MAY_LJMP(check_args(L, 3, "set_var"));
5739
5740 /* It is useles to retrieve the stream, but this function
5741 * runs only in a stream context.
5742 */
5743 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5744 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
5745
5746 /* Converts the third argument in a sample. */
Amaury Denoyelleca492f32020-10-29 17:21:20 +01005747 memset(&smp, 0, sizeof(smp));
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005748 hlua_lua2smp(L, 3, &smp);
5749
5750 /* Store the sample in a variable. */
Willy Tarreau7560dd42016-03-10 16:28:58 +01005751 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
Willy Tarreau6204cd92016-03-10 16:33:04 +01005752 vars_set_by_name(name, len, &smp);
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005753 return 0;
5754}
5755
Christopher Faulet85d79c92016-11-09 16:54:56 +01005756__LJMP static int hlua_unset_var(lua_State *L)
5757{
5758 struct hlua_txn *htxn;
5759 const char *name;
5760 size_t len;
5761 struct sample smp;
5762
5763 MAY_LJMP(check_args(L, 2, "unset_var"));
5764
5765 /* It is useles to retrieve the stream, but this function
5766 * runs only in a stream context.
5767 */
5768 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5769 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
5770
5771 /* Unset the variable. */
5772 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
5773 vars_unset_by_name(name, len, &smp);
5774 return 0;
5775}
5776
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005777__LJMP static int hlua_get_var(lua_State *L)
5778{
5779 struct hlua_txn *htxn;
5780 const char *name;
5781 size_t len;
5782 struct sample smp;
5783
5784 MAY_LJMP(check_args(L, 2, "get_var"));
5785
5786 /* It is useles to retrieve the stream, but this function
5787 * runs only in a stream context.
5788 */
5789 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5790 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
5791
Willy Tarreau7560dd42016-03-10 16:28:58 +01005792 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
Willy Tarreau6204cd92016-03-10 16:33:04 +01005793 if (!vars_get_by_name(name, len, &smp)) {
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005794 lua_pushnil(L);
5795 return 1;
5796 }
5797
5798 return hlua_smp2lua(L, &smp);
5799}
5800
Willy Tarreau59551662015-03-10 14:23:13 +01005801__LJMP static int hlua_set_priv(lua_State *L)
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005802{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005803 struct hlua *hlua;
5804
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005805 MAY_LJMP(check_args(L, 2, "set_priv"));
5806
Willy Tarreau87b09662015-04-03 00:22:06 +02005807 /* It is useles to retrieve the stream, but this function
5808 * runs only in a stream context.
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005809 */
5810 MAY_LJMP(hlua_checktxn(L, 1));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005811 hlua = hlua_gethlua(L);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005812
5813 /* Remove previous value. */
Thierry FOURNIERe068b602017-04-26 13:27:05 +02005814 luaL_unref(L, LUA_REGISTRYINDEX, hlua->Mref);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005815
5816 /* Get and store new value. */
5817 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
5818 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
5819
5820 return 0;
5821}
5822
Willy Tarreau59551662015-03-10 14:23:13 +01005823__LJMP static int hlua_get_priv(lua_State *L)
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005824{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005825 struct hlua *hlua;
5826
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005827 MAY_LJMP(check_args(L, 1, "get_priv"));
5828
Willy Tarreau87b09662015-04-03 00:22:06 +02005829 /* It is useles to retrieve the stream, but this function
5830 * runs only in a stream context.
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005831 */
5832 MAY_LJMP(hlua_checktxn(L, 1));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005833 hlua = hlua_gethlua(L);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005834
5835 /* Push configuration index in the stack. */
5836 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
5837
5838 return 1;
5839}
5840
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005841/* Create stack entry containing a class TXN. This function
5842 * return 0 if the stack does not contains free slots,
5843 * otherwise it returns 1.
5844 */
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005845static int hlua_txn_new(lua_State *L, struct stream *s, struct proxy *p, int dir, int flags)
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005846{
Willy Tarreaude491382015-04-06 11:04:28 +02005847 struct hlua_txn *htxn;
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005848
5849 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01005850 if (!lua_checkstack(L, 3))
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005851 return 0;
5852
5853 /* NOTE: The allocation never fails. The failure
5854 * throw an error, and the function never returns.
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08005855 * if the throw is not available, the process is aborted.
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005856 */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01005857 /* Create the object: obj[0] = userdata. */
5858 lua_newtable(L);
Willy Tarreaude491382015-04-06 11:04:28 +02005859 htxn = lua_newuserdata(L, sizeof(*htxn));
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01005860 lua_rawseti(L, -2, 0);
5861
Willy Tarreaude491382015-04-06 11:04:28 +02005862 htxn->s = s;
5863 htxn->p = p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01005864 htxn->dir = dir;
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005865 htxn->flags = flags;
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005866
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01005867 /* Create the "f" field that contains a list of fetches. */
5868 lua_pushstring(L, "f");
Thierry FOURNIERca988662015-12-20 18:43:03 +01005869 if (!hlua_fetches_new(L, htxn, HLUA_F_MAY_USE_HTTP))
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01005870 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005871 lua_rawset(L, -3);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01005872
5873 /* Create the "sf" field that contains a list of stringsafe fetches. */
5874 lua_pushstring(L, "sf");
Thierry FOURNIERca988662015-12-20 18:43:03 +01005875 if (!hlua_fetches_new(L, htxn, HLUA_F_MAY_USE_HTTP | HLUA_F_AS_STRING))
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01005876 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005877 lua_rawset(L, -3);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01005878
Thierry FOURNIER594afe72015-03-10 23:58:30 +01005879 /* Create the "c" field that contains a list of converters. */
5880 lua_pushstring(L, "c");
Willy Tarreaude491382015-04-06 11:04:28 +02005881 if (!hlua_converters_new(L, htxn, 0))
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01005882 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005883 lua_rawset(L, -3);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01005884
5885 /* Create the "sc" field that contains a list of stringsafe converters. */
5886 lua_pushstring(L, "sc");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01005887 if (!hlua_converters_new(L, htxn, HLUA_F_AS_STRING))
Thierry FOURNIER594afe72015-03-10 23:58:30 +01005888 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005889 lua_rawset(L, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01005890
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005891 /* Create the "req" field that contains the request channel object. */
5892 lua_pushstring(L, "req");
Willy Tarreau2a71af42015-03-10 13:51:50 +01005893 if (!hlua_channel_new(L, &s->req))
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005894 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005895 lua_rawset(L, -3);
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005896
5897 /* Create the "res" field that contains the response channel object. */
5898 lua_pushstring(L, "res");
Willy Tarreau2a71af42015-03-10 13:51:50 +01005899 if (!hlua_channel_new(L, &s->res))
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005900 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005901 lua_rawset(L, -3);
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005902
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005903 /* Creates the HTTP object is the current proxy allows http. */
5904 lua_pushstring(L, "http");
5905 if (p->mode == PR_MODE_HTTP) {
Willy Tarreaude491382015-04-06 11:04:28 +02005906 if (!hlua_http_new(L, htxn))
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005907 return 0;
5908 }
5909 else
5910 lua_pushnil(L);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005911 lua_rawset(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005912
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005913 /* Pop a class sesison metatable and affect it to the userdata. */
5914 lua_rawgeti(L, LUA_REGISTRYINDEX, class_txn_ref);
5915 lua_setmetatable(L, -2);
5916
5917 return 1;
5918}
5919
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01005920__LJMP static int hlua_txn_deflog(lua_State *L)
5921{
5922 const char *msg;
5923 struct hlua_txn *htxn;
5924
5925 MAY_LJMP(check_args(L, 2, "deflog"));
5926 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5927 msg = MAY_LJMP(luaL_checkstring(L, 2));
5928
5929 hlua_sendlog(htxn->s->be, htxn->s->logs.level, msg);
5930 return 0;
5931}
5932
5933__LJMP static int hlua_txn_log(lua_State *L)
5934{
5935 int level;
5936 const char *msg;
5937 struct hlua_txn *htxn;
5938
5939 MAY_LJMP(check_args(L, 3, "log"));
5940 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5941 level = MAY_LJMP(luaL_checkinteger(L, 2));
5942 msg = MAY_LJMP(luaL_checkstring(L, 3));
5943
5944 if (level < 0 || level >= NB_LOG_LEVELS)
5945 WILL_LJMP(luaL_argerror(L, 1, "Invalid loglevel."));
5946
5947 hlua_sendlog(htxn->s->be, level, msg);
5948 return 0;
5949}
5950
5951__LJMP static int hlua_txn_log_debug(lua_State *L)
5952{
5953 const char *msg;
5954 struct hlua_txn *htxn;
5955
5956 MAY_LJMP(check_args(L, 2, "Debug"));
5957 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5958 msg = MAY_LJMP(luaL_checkstring(L, 2));
5959 hlua_sendlog(htxn->s->be, LOG_DEBUG, msg);
5960 return 0;
5961}
5962
5963__LJMP static int hlua_txn_log_info(lua_State *L)
5964{
5965 const char *msg;
5966 struct hlua_txn *htxn;
5967
5968 MAY_LJMP(check_args(L, 2, "Info"));
5969 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5970 msg = MAY_LJMP(luaL_checkstring(L, 2));
5971 hlua_sendlog(htxn->s->be, LOG_INFO, msg);
5972 return 0;
5973}
5974
5975__LJMP static int hlua_txn_log_warning(lua_State *L)
5976{
5977 const char *msg;
5978 struct hlua_txn *htxn;
5979
5980 MAY_LJMP(check_args(L, 2, "Warning"));
5981 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5982 msg = MAY_LJMP(luaL_checkstring(L, 2));
5983 hlua_sendlog(htxn->s->be, LOG_WARNING, msg);
5984 return 0;
5985}
5986
5987__LJMP static int hlua_txn_log_alert(lua_State *L)
5988{
5989 const char *msg;
5990 struct hlua_txn *htxn;
5991
5992 MAY_LJMP(check_args(L, 2, "Alert"));
5993 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5994 msg = MAY_LJMP(luaL_checkstring(L, 2));
5995 hlua_sendlog(htxn->s->be, LOG_ALERT, msg);
5996 return 0;
5997}
5998
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005999__LJMP static int hlua_txn_set_loglevel(lua_State *L)
6000{
6001 struct hlua_txn *htxn;
6002 int ll;
6003
6004 MAY_LJMP(check_args(L, 2, "set_loglevel"));
6005 htxn = MAY_LJMP(hlua_checktxn(L, 1));
6006 ll = MAY_LJMP(luaL_checkinteger(L, 2));
6007
6008 if (ll < 0 || ll > 7)
6009 WILL_LJMP(luaL_argerror(L, 2, "Bad log level. It must be between 0 and 7"));
6010
6011 htxn->s->logs.level = ll;
6012 return 0;
6013}
6014
6015__LJMP static int hlua_txn_set_tos(lua_State *L)
6016{
6017 struct hlua_txn *htxn;
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01006018 int tos;
6019
6020 MAY_LJMP(check_args(L, 2, "set_tos"));
6021 htxn = MAY_LJMP(hlua_checktxn(L, 1));
6022 tos = MAY_LJMP(luaL_checkinteger(L, 2));
6023
Willy Tarreau1a18b542018-12-11 16:37:42 +01006024 conn_set_tos(objt_conn(htxn->s->sess->origin), tos);
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01006025 return 0;
6026}
6027
6028__LJMP static int hlua_txn_set_mark(lua_State *L)
6029{
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01006030 struct hlua_txn *htxn;
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01006031 int mark;
6032
6033 MAY_LJMP(check_args(L, 2, "set_mark"));
6034 htxn = MAY_LJMP(hlua_checktxn(L, 1));
6035 mark = MAY_LJMP(luaL_checkinteger(L, 2));
6036
Lukas Tribusb59291a2019-08-11 18:03:45 +02006037 conn_set_mark(objt_conn(htxn->s->sess->origin), mark);
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01006038 return 0;
6039}
6040
Patrick Hemmer268a7072018-05-11 12:52:31 -04006041__LJMP static int hlua_txn_set_priority_class(lua_State *L)
6042{
6043 struct hlua_txn *htxn;
6044
6045 MAY_LJMP(check_args(L, 2, "set_priority_class"));
6046 htxn = MAY_LJMP(hlua_checktxn(L, 1));
6047 htxn->s->priority_class = queue_limit_class(MAY_LJMP(luaL_checkinteger(L, 2)));
6048 return 0;
6049}
6050
6051__LJMP static int hlua_txn_set_priority_offset(lua_State *L)
6052{
6053 struct hlua_txn *htxn;
6054
6055 MAY_LJMP(check_args(L, 2, "set_priority_offset"));
6056 htxn = MAY_LJMP(hlua_checktxn(L, 1));
6057 htxn->s->priority_offset = queue_limit_offset(MAY_LJMP(luaL_checkinteger(L, 2)));
6058 return 0;
6059}
6060
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01006061/* This function is an Lua binding that send pending data
6062 * to the client, and close the stream interface.
6063 */
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02006064__LJMP static int hlua_txn_done(lua_State *L)
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01006065{
Willy Tarreaub2ccb562015-04-06 11:11:15 +02006066 struct hlua_txn *htxn;
Thierry FOURNIER9bd52d42016-07-14 11:45:33 +02006067 struct hlua *hlua;
Willy Tarreau81389672015-03-10 12:03:52 +01006068 struct channel *ic, *oc;
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01006069
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006070 MAY_LJMP(check_args(L, 1, "close"));
Willy Tarreaub2ccb562015-04-06 11:11:15 +02006071 htxn = MAY_LJMP(hlua_checktxn(L, 1));
Thierry FOURNIER9bd52d42016-07-14 11:45:33 +02006072 hlua = hlua_gethlua(L);
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01006073
Thierry FOURNIERab00df62016-07-14 11:42:37 +02006074 /* If the flags NOTERM is set, we cannot terminate the http
6075 * session, so we just end the execution of the current
6076 * lua code.
6077 */
6078 if (htxn->flags & HLUA_TXN_NOTERM) {
6079 WILL_LJMP(hlua_done(L));
6080 return 0;
6081 }
6082
Willy Tarreaub2ccb562015-04-06 11:11:15 +02006083 ic = &htxn->s->req;
6084 oc = &htxn->s->res;
Willy Tarreau81389672015-03-10 12:03:52 +01006085
Christopher Faulet72c69272019-07-26 16:40:24 +02006086 if (IS_HTX_STRM(htxn->s)) {
6087 htxn->s->txn->status = 0;
6088 http_reply_and_close(htxn->s, 0, NULL);
6089 ic->analysers &= AN_REQ_FLT_END;
6090 oc->analysers &= AN_RES_FLT_END;
6091 }
Christopher Fauletb58fb792019-07-16 10:52:40 +02006092 else {
6093 if (htxn->s->txn) {
6094 /* HTTP mode, let's stay in sync with the stream */
6095 b_del(&ic->buf, htxn->s->txn->req.sov);
6096 htxn->s->txn->req.next -= htxn->s->txn->req.sov;
6097 htxn->s->txn->req.sov = 0;
6098
6099 ic->analysers &= AN_REQ_HTTP_XFER_BODY;
6100 oc->analysers = AN_RES_HTTP_XFER_BODY;
6101 htxn->s->txn->req.msg_state = HTTP_MSG_CLOSED;
6102 htxn->s->txn->rsp.msg_state = HTTP_MSG_DONE;
Willy Tarreau630ef452015-08-28 10:06:15 +02006103
Willy Tarreau630ef452015-08-28 10:06:15 +02006104 /* Note that if we want to support keep-alive, we need
6105 * to bypass the close/shutr_now calls below, but that
6106 * may only be done if the HTTP request was already
6107 * processed and the connection header is known (ie
6108 * not during TCP rules).
6109 */
Christopher Fauletb58fb792019-07-16 10:52:40 +02006110 }
Willy Tarreau630ef452015-08-28 10:06:15 +02006111
Christopher Fauletb58fb792019-07-16 10:52:40 +02006112 channel_auto_read(ic);
6113 channel_abort(ic);
6114 channel_auto_close(ic);
6115 channel_erase(ic);
Thierry FOURNIER10ec2142015-08-24 17:23:45 +02006116
Christopher Fauletb58fb792019-07-16 10:52:40 +02006117 oc->wex = tick_add_ifset(now_ms, oc->wto);
6118 channel_auto_read(oc);
6119 channel_auto_close(oc);
6120 channel_shutr_now(oc);
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01006121
Christopher Fauletb58fb792019-07-16 10:52:40 +02006122 ic->analysers = 0;
6123 }
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02006124
Christopher Faulet72c69272019-07-26 16:40:24 +02006125 if (!(htxn->s->flags & SF_ERR_MASK)) // this is not really an error but it is
6126 htxn->s->flags |= SF_ERR_LOCAL; // to mark that it comes from the proxy
6127
Thierry FOURNIER9bd52d42016-07-14 11:45:33 +02006128 hlua->flags |= HLUA_STOP;
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02006129 WILL_LJMP(hlua_done(L));
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01006130 return 0;
6131}
6132
6133__LJMP static int hlua_log(lua_State *L)
6134{
6135 int level;
6136 const char *msg;
6137
6138 MAY_LJMP(check_args(L, 2, "log"));
6139 level = MAY_LJMP(luaL_checkinteger(L, 1));
6140 msg = MAY_LJMP(luaL_checkstring(L, 2));
6141
6142 if (level < 0 || level >= NB_LOG_LEVELS)
6143 WILL_LJMP(luaL_argerror(L, 1, "Invalid loglevel."));
6144
6145 hlua_sendlog(NULL, level, msg);
6146 return 0;
6147}
6148
6149__LJMP static int hlua_log_debug(lua_State *L)
6150{
6151 const char *msg;
6152
6153 MAY_LJMP(check_args(L, 1, "debug"));
6154 msg = MAY_LJMP(luaL_checkstring(L, 1));
6155 hlua_sendlog(NULL, LOG_DEBUG, msg);
6156 return 0;
6157}
6158
6159__LJMP static int hlua_log_info(lua_State *L)
6160{
6161 const char *msg;
6162
6163 MAY_LJMP(check_args(L, 1, "info"));
6164 msg = MAY_LJMP(luaL_checkstring(L, 1));
6165 hlua_sendlog(NULL, LOG_INFO, msg);
6166 return 0;
6167}
6168
6169__LJMP static int hlua_log_warning(lua_State *L)
6170{
6171 const char *msg;
6172
6173 MAY_LJMP(check_args(L, 1, "warning"));
6174 msg = MAY_LJMP(luaL_checkstring(L, 1));
6175 hlua_sendlog(NULL, LOG_WARNING, msg);
6176 return 0;
6177}
6178
6179__LJMP static int hlua_log_alert(lua_State *L)
6180{
6181 const char *msg;
6182
6183 MAY_LJMP(check_args(L, 1, "alert"));
6184 msg = MAY_LJMP(luaL_checkstring(L, 1));
6185 hlua_sendlog(NULL, LOG_ALERT, msg);
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01006186 return 0;
6187}
6188
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01006189__LJMP static int hlua_sleep_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006190{
6191 int wakeup_ms = lua_tointeger(L, -1);
6192 if (now_ms < wakeup_ms)
Willy Tarreau9635e032018-10-16 17:52:55 +02006193 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006194 return 0;
6195}
6196
6197__LJMP static int hlua_sleep(lua_State *L)
6198{
6199 unsigned int delay;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006200 unsigned int wakeup_ms;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006201
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006202 MAY_LJMP(check_args(L, 1, "sleep"));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006203
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01006204 delay = MAY_LJMP(luaL_checkinteger(L, 1)) * 1000;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006205 wakeup_ms = tick_add(now_ms, delay);
6206 lua_pushinteger(L, wakeup_ms);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006207
Willy Tarreau9635e032018-10-16 17:52:55 +02006208 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006209 return 0;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006210}
6211
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006212__LJMP static int hlua_msleep(lua_State *L)
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006213{
6214 unsigned int delay;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006215 unsigned int wakeup_ms;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006216
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006217 MAY_LJMP(check_args(L, 1, "msleep"));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006218
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01006219 delay = MAY_LJMP(luaL_checkinteger(L, 1));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006220 wakeup_ms = tick_add(now_ms, delay);
6221 lua_pushinteger(L, wakeup_ms);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006222
Willy Tarreau9635e032018-10-16 17:52:55 +02006223 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006224 return 0;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006225}
6226
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01006227/* This functionis an LUA binding. it permits to give back
6228 * the hand at the HAProxy scheduler. It is used when the
6229 * LUA processing consumes a lot of time.
6230 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01006231__LJMP static int hlua_yield_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006232{
6233 return 0;
6234}
6235
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01006236__LJMP static int hlua_yield(lua_State *L)
6237{
Willy Tarreau9635e032018-10-16 17:52:55 +02006238 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_yield_yield, TICK_ETERNITY, HLUA_CTRLYIELD));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006239 return 0;
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01006240}
6241
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006242/* This function change the nice of the currently executed
6243 * task. It is used set low or high priority at the current
6244 * task.
6245 */
Willy Tarreau59551662015-03-10 14:23:13 +01006246__LJMP static int hlua_set_nice(lua_State *L)
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006247{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006248 struct hlua *hlua;
6249 int nice;
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006250
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006251 MAY_LJMP(check_args(L, 1, "set_nice"));
6252 hlua = hlua_gethlua(L);
6253 nice = MAY_LJMP(luaL_checkinteger(L, 1));
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006254
6255 /* If he task is not set, I'm in a start mode. */
6256 if (!hlua || !hlua->task)
6257 return 0;
6258
6259 if (nice < -1024)
6260 nice = -1024;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006261 else if (nice > 1024)
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006262 nice = 1024;
6263
6264 hlua->task->nice = nice;
6265 return 0;
6266}
6267
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08006268/* This function is used as a callback of a task. It is called by the
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006269 * HAProxy task subsystem when the task is awaked. The LUA runtime can
6270 * return an E_AGAIN signal, the emmiter of this signal must set a
6271 * signal to wake the task.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006272 *
6273 * Task wrapper are longjmp safe because the only one Lua code
6274 * executed is the safe hlua_ctx_resume();
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006275 */
Willy Tarreau83a5ff42019-08-21 14:14:50 +02006276struct task *hlua_process_task(struct task *task, void *context, unsigned short state)
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006277{
Olivier Houchard9f6af332018-05-25 14:04:04 +02006278 struct hlua *hlua = context;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006279 enum hlua_exec status;
6280
Christopher Faulet5bc99722018-04-25 10:34:45 +02006281 if (task->thread_mask == MAX_THREADS_MASK)
6282 task_set_affinity(task, tid_bit);
6283
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006284 /* If it is the first call to the task, we must initialize the
6285 * execution timeouts.
6286 */
6287 if (!HLUA_IS_RUNNING(hlua))
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02006288 hlua->max_time = hlua_timeout_task;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006289
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006290 /* Execute the Lua code. */
6291 status = hlua_ctx_resume(hlua, 1);
6292
6293 switch (status) {
6294 /* finished or yield */
6295 case HLUA_E_OK:
6296 hlua_ctx_destroy(hlua);
Olivier Houchard3f795f72019-04-17 22:51:06 +02006297 task_destroy(task);
Tim Duesterhuscd235c62018-04-24 13:56:01 +02006298 task = NULL;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006299 break;
6300
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01006301 case HLUA_E_AGAIN: /* co process or timeout wake me later. */
Thierry FOURNIERcb146882017-12-10 17:10:57 +01006302 notification_gc(&hlua->com);
PiBa-NLfe971b32018-05-02 22:27:14 +02006303 task->expire = hlua->wake_time;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006304 break;
6305
6306 /* finished with error. */
6307 case HLUA_E_ERRMSG:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006308 SEND_ERR(NULL, "Lua task: %s.\n", lua_tostring(hlua->T, -1));
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006309 hlua_ctx_destroy(hlua);
Olivier Houchard3f795f72019-04-17 22:51:06 +02006310 task_destroy(task);
Emeric Brun253e53e2017-10-17 18:58:40 +02006311 task = NULL;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006312 break;
6313
6314 case HLUA_E_ERR:
6315 default:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006316 SEND_ERR(NULL, "Lua task: unknown error.\n");
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006317 hlua_ctx_destroy(hlua);
Olivier Houchard3f795f72019-04-17 22:51:06 +02006318 task_destroy(task);
Emeric Brun253e53e2017-10-17 18:58:40 +02006319 task = NULL;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006320 break;
6321 }
Emeric Brun253e53e2017-10-17 18:58:40 +02006322 return task;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006323}
6324
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006325/* This function is an LUA binding that register LUA function to be
6326 * executed after the HAProxy configuration parsing and before the
6327 * HAProxy scheduler starts. This function expect only one LUA
6328 * argument that is a function. This function returns nothing, but
6329 * throws if an error is encountered.
6330 */
6331__LJMP static int hlua_register_init(lua_State *L)
6332{
6333 struct hlua_init_function *init;
6334 int ref;
6335
6336 MAY_LJMP(check_args(L, 1, "register_init"));
6337
6338 ref = MAY_LJMP(hlua_checkfunction(L, 1));
6339
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006340 init = calloc(1, sizeof(*init));
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006341 if (!init)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006342 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006343
6344 init->function_ref = ref;
6345 LIST_ADDQ(&hlua_init_functions, &init->l);
6346 return 0;
6347}
6348
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006349/* This functio is an LUA binding. It permits to register a task
6350 * executed in parallel of the main HAroxy activity. The task is
6351 * created and it is set in the HAProxy scheduler. It can be called
6352 * from the "init" section, "post init" or during the runtime.
6353 *
6354 * Lua prototype:
6355 *
6356 * <none> core.register_task(<function>)
6357 */
6358static int hlua_register_task(lua_State *L)
6359{
6360 struct hlua *hlua;
6361 struct task *task;
6362 int ref;
6363
6364 MAY_LJMP(check_args(L, 1, "register_task"));
6365
6366 ref = MAY_LJMP(hlua_checkfunction(L, 1));
6367
Willy Tarreaubafbe012017-11-24 17:34:44 +01006368 hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006369 if (!hlua)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006370 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006371
Emeric Brunc60def82017-09-27 14:59:38 +02006372 task = task_new(MAX_THREADS_MASK);
Willy Tarreaue09101e2018-10-16 17:37:12 +02006373 if (!task)
6374 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
6375
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006376 task->context = hlua;
6377 task->process = hlua_process_task;
6378
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01006379 if (!hlua_ctx_init(hlua, task, 1))
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006380 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006381
6382 /* Restore the function in the stack. */
6383 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ref);
6384 hlua->nargs = 0;
6385
6386 /* Schedule task. */
6387 task_schedule(task, now_ms);
6388
6389 return 0;
6390}
6391
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006392/* Wrapper called by HAProxy to execute an LUA converter. This wrapper
6393 * doesn't allow "yield" functions because the HAProxy engine cannot
6394 * resume converters.
6395 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006396static int hlua_sample_conv_wrapper(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006397{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02006398 struct hlua_function *fcn = private;
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006399 struct stream *stream = smp->strm;
Thierry Fournierfd107a22016-02-19 19:57:23 +01006400 const char *error;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006401
Willy Tarreaube508f12016-03-10 11:47:01 +01006402 if (!stream)
6403 return 0;
6404
Willy Tarreau87b09662015-04-03 00:22:06 +02006405 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006406 * Lua context can be not initialized. This behavior
6407 * permits to save performances because a systematic
6408 * Lua initialization cause 5% performances loss.
6409 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006410 if (!stream->hlua) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01006411 stream->hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006412 if (!stream->hlua) {
6413 SEND_ERR(stream->be, "Lua converter '%s': can't initialize Lua context.\n", fcn->name);
6414 return 0;
6415 }
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01006416 if (!hlua_ctx_init(stream->hlua, stream->task, 0)) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006417 SEND_ERR(stream->be, "Lua converter '%s': can't initialize Lua context.\n", fcn->name);
6418 return 0;
6419 }
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006420 }
6421
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006422 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006423 if (!HLUA_IS_RUNNING(stream->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006424
6425 /* The following Lua calls can fail. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006426 if (!SET_SAFE_LJMP(stream->hlua->T)) {
6427 if (lua_type(stream->hlua->T, -1) == LUA_TSTRING)
6428 error = lua_tostring(stream->hlua->T, -1);
Thierry Fournierfd107a22016-02-19 19:57:23 +01006429 else
6430 error = "critical error";
6431 SEND_ERR(stream->be, "Lua converter '%s': %s.\n", fcn->name, error);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006432 return 0;
6433 }
6434
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006435 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006436 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006437 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006438 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006439 return 0;
6440 }
6441
6442 /* Restore the function in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006443 lua_rawgeti(stream->hlua->T, LUA_REGISTRYINDEX, fcn->function_ref);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006444
6445 /* convert input sample and pust-it in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006446 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006447 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006448 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006449 return 0;
6450 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006451 hlua_smp2lua(stream->hlua->T, smp);
6452 stream->hlua->nargs = 1;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006453
6454 /* push keywords in the stack. */
6455 if (arg_p) {
6456 for (; arg_p->type != ARGT_STOP; arg_p++) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006457 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006458 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006459 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006460 return 0;
6461 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006462 hlua_arg2lua(stream->hlua->T, arg_p);
6463 stream->hlua->nargs++;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006464 }
6465 }
6466
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006467 /* We must initialize the execution timeouts. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006468 stream->hlua->max_time = hlua_timeout_session;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006469
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006470 /* At this point the execution is safe. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006471 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006472 }
6473
6474 /* Execute the function. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006475 switch (hlua_ctx_resume(stream->hlua, 0)) {
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006476 /* finished. */
6477 case HLUA_E_OK:
Thierry FOURNIERfd80df12017-05-12 16:32:20 +02006478 /* If the stack is empty, the function fails. */
6479 if (lua_gettop(stream->hlua->T) <= 0)
6480 return 0;
6481
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006482 /* Convert the returned value in sample. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006483 hlua_lua2smp(stream->hlua->T, -1, smp);
6484 lua_pop(stream->hlua->T, 1);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006485 return 1;
6486
6487 /* yield. */
6488 case HLUA_E_AGAIN:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006489 SEND_ERR(stream->be, "Lua converter '%s': cannot use yielded functions.\n", fcn->name);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006490 return 0;
6491
6492 /* finished with error. */
6493 case HLUA_E_ERRMSG:
6494 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006495 SEND_ERR(stream->be, "Lua converter '%s': %s.\n",
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006496 fcn->name, lua_tostring(stream->hlua->T, -1));
6497 lua_pop(stream->hlua->T, 1);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006498 return 0;
6499
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006500 case HLUA_E_ETMOUT:
6501 SEND_ERR(stream->be, "Lua converter '%s': execution timeout.\n", fcn->name);
6502 return 0;
6503
6504 case HLUA_E_NOMEM:
6505 SEND_ERR(stream->be, "Lua converter '%s': out of memory error.\n", fcn->name);
6506 return 0;
6507
6508 case HLUA_E_YIELD:
6509 SEND_ERR(stream->be, "Lua converter '%s': yield functions like core.tcp() or core.sleep() are not allowed.\n", fcn->name);
6510 return 0;
6511
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006512 case HLUA_E_ERR:
6513 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006514 SEND_ERR(stream->be, "Lua converter '%s' returns an unknown error.\n", fcn->name);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006515
6516 default:
6517 return 0;
6518 }
6519}
6520
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006521/* Wrapper called by HAProxy to execute a sample-fetch. this wrapper
6522 * doesn't allow "yield" functions because the HAProxy engine cannot
Willy Tarreaube508f12016-03-10 11:47:01 +01006523 * resume sample-fetches. This function will be called by the sample
6524 * fetch engine to call lua-based fetch operations.
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006525 */
Thierry FOURNIER0786d052015-05-11 15:42:45 +02006526static int hlua_sample_fetch_wrapper(const struct arg *arg_p, struct sample *smp,
6527 const char *kw, void *private)
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006528{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02006529 struct hlua_function *fcn = private;
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006530 struct stream *stream = smp->strm;
Thierry Fournierfd107a22016-02-19 19:57:23 +01006531 const char *error;
Willy Tarreau83061a82018-07-13 11:56:34 +02006532 const struct buffer msg = { };
Christopher Fauletff96b8b2019-07-26 15:09:53 +02006533 unsigned int hflags = HLUA_TXN_NOTERM;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006534
Willy Tarreaube508f12016-03-10 11:47:01 +01006535 if (!stream)
6536 return 0;
Christopher Fauletafd8f102018-11-08 11:34:21 +01006537
Willy Tarreau87b09662015-04-03 00:22:06 +02006538 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006539 * Lua context can be not initialized. This behavior
6540 * permits to save performances because a systematic
6541 * Lua initialization cause 5% performances loss.
6542 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006543 if (!stream->hlua) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01006544 stream->hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006545 if (!stream->hlua) {
6546 SEND_ERR(stream->be, "Lua sample-fetch '%s': can't initialize Lua context.\n", fcn->name);
6547 return 0;
6548 }
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01006549 if (!hlua_ctx_init(stream->hlua, stream->task, 0)) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006550 SEND_ERR(stream->be, "Lua sample-fetch '%s': can't initialize Lua context.\n", fcn->name);
6551 return 0;
6552 }
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006553 }
6554
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006555 consistency_set(stream, smp->opt, &stream->hlua->cons);
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01006556
Christopher Fauletff96b8b2019-07-26 15:09:53 +02006557 if (stream->be->mode == PR_MODE_HTTP) {
6558 if ((smp->opt & SMP_OPT_DIR) == SMP_OPT_DIR_REQ)
6559 hflags |= ((stream->txn->req.msg_state < HTTP_MSG_BODY) ? 0 : HLUA_TXN_HTTP_RDY);
6560 else
6561 hflags |= ((stream->txn->rsp.msg_state < HTTP_MSG_BODY) ? 0 : HLUA_TXN_HTTP_RDY);
6562 }
6563
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006564 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006565 if (!HLUA_IS_RUNNING(stream->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006566
6567 /* The following Lua calls can fail. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006568 if (!SET_SAFE_LJMP(stream->hlua->T)) {
6569 if (lua_type(stream->hlua->T, -1) == LUA_TSTRING)
6570 error = lua_tostring(stream->hlua->T, -1);
Thierry Fournierfd107a22016-02-19 19:57:23 +01006571 else
6572 error = "critical error";
6573 SEND_ERR(smp->px, "Lua sample-fetch '%s': %s.\n", fcn->name, error);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006574 return 0;
6575 }
6576
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006577 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006578 if (!lua_checkstack(stream->hlua->T, 2)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006579 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006580 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006581 return 0;
6582 }
6583
6584 /* Restore the function in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006585 lua_rawgeti(stream->hlua->T, LUA_REGISTRYINDEX, fcn->function_ref);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006586
6587 /* push arguments in the stack. */
Christopher Fauletff96b8b2019-07-26 15:09:53 +02006588 if (!hlua_txn_new(stream->hlua->T, stream, smp->px, smp->opt & SMP_OPT_DIR, hflags)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006589 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006590 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006591 return 0;
6592 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006593 stream->hlua->nargs = 1;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006594
6595 /* push keywords in the stack. */
6596 for (; arg_p && arg_p->type != ARGT_STOP; arg_p++) {
6597 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006598 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006599 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006600 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006601 return 0;
6602 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006603 hlua_arg2lua(stream->hlua->T, arg_p);
6604 stream->hlua->nargs++;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006605 }
6606
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006607 /* We must initialize the execution timeouts. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006608 stream->hlua->max_time = hlua_timeout_session;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006609
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006610 /* At this point the execution is safe. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006611 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006612 }
6613
6614 /* Execute the function. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006615 switch (hlua_ctx_resume(stream->hlua, 0)) {
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006616 /* finished. */
6617 case HLUA_E_OK:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006618 if (!consistency_check(stream, smp->opt, &stream->hlua->cons)) {
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006619 si_retnclose(&stream->si[0], &msg);
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02006620 return 0;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01006621 }
Thierry FOURNIERfd80df12017-05-12 16:32:20 +02006622 /* If the stack is empty, the function fails. */
6623 if (lua_gettop(stream->hlua->T) <= 0)
6624 return 0;
6625
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006626 /* Convert the returned value in sample. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006627 hlua_lua2smp(stream->hlua->T, -1, smp);
6628 lua_pop(stream->hlua->T, 1);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006629
6630 /* Set the end of execution flag. */
6631 smp->flags &= ~SMP_F_MAY_CHANGE;
6632 return 1;
6633
6634 /* yield. */
6635 case HLUA_E_AGAIN:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006636 if (!consistency_check(stream, smp->opt, &stream->hlua->cons))
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006637 si_retnclose(&stream->si[0], &msg);
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006638 SEND_ERR(smp->px, "Lua sample-fetch '%s': cannot use yielded functions.\n", fcn->name);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006639 return 0;
6640
6641 /* finished with error. */
6642 case HLUA_E_ERRMSG:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006643 if (!consistency_check(stream, smp->opt, &stream->hlua->cons))
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006644 si_retnclose(&stream->si[0], &msg);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006645 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006646 SEND_ERR(smp->px, "Lua sample-fetch '%s': %s.\n",
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006647 fcn->name, lua_tostring(stream->hlua->T, -1));
6648 lua_pop(stream->hlua->T, 1);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006649 return 0;
6650
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006651 case HLUA_E_ETMOUT:
6652 if (!consistency_check(stream, smp->opt, &stream->hlua->cons))
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006653 si_retnclose(&stream->si[0], &msg);
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006654 SEND_ERR(smp->px, "Lua sample-fetch '%s': execution timeout.\n", fcn->name);
6655 return 0;
6656
6657 case HLUA_E_NOMEM:
6658 if (!consistency_check(stream, smp->opt, &stream->hlua->cons))
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006659 si_retnclose(&stream->si[0], &msg);
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006660 SEND_ERR(smp->px, "Lua sample-fetch '%s': out of memory error.\n", fcn->name);
6661 return 0;
6662
6663 case HLUA_E_YIELD:
6664 if (!consistency_check(stream, smp->opt, &stream->hlua->cons))
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006665 si_retnclose(&stream->si[0], &msg);
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006666 SEND_ERR(smp->px, "Lua sample-fetch '%s': yield not allowed.\n", fcn->name);
6667 return 0;
6668
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006669 case HLUA_E_ERR:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006670 if (!consistency_check(stream, smp->opt, &stream->hlua->cons))
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006671 si_retnclose(&stream->si[0], &msg);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006672 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006673 SEND_ERR(smp->px, "Lua sample-fetch '%s' returns an unknown error.\n", fcn->name);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006674
6675 default:
6676 return 0;
6677 }
6678}
6679
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006680/* This function is an LUA binding used for registering
6681 * "sample-conv" functions. It expects a converter name used
6682 * in the haproxy configuration file, and an LUA function.
6683 */
6684__LJMP static int hlua_register_converters(lua_State *L)
6685{
6686 struct sample_conv_kw_list *sck;
6687 const char *name;
6688 int ref;
6689 int len;
6690 struct hlua_function *fcn;
Thierry Fourniera9230f82020-11-28 20:41:07 +01006691 struct sample_conv *sc;
6692 struct buffer *trash;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006693
6694 MAY_LJMP(check_args(L, 2, "register_converters"));
6695
6696 /* First argument : converter name. */
6697 name = MAY_LJMP(luaL_checkstring(L, 1));
6698
6699 /* Second argument : lua function. */
6700 ref = MAY_LJMP(hlua_checkfunction(L, 2));
6701
Thierry Fourniera9230f82020-11-28 20:41:07 +01006702 /* Check if the converter is already registered */
6703 trash = get_trash_chunk();
6704 chunk_printf(trash, "lua.%s", name);
6705 sc = find_sample_conv(trash->area, trash->data);
6706 if (sc != NULL) {
6707 ha_warning("Trying to register converter 'lua.%s' more than once. "
6708 "This will become a hard error in version 2.5.\n", name);
6709 }
6710
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006711 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006712 sck = calloc(1, sizeof(*sck) + sizeof(struct sample_conv) * 2);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006713 if (!sck)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006714 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006715 fcn = calloc(1, sizeof(*fcn));
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006716 if (!fcn)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006717 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006718
6719 /* Fill fcn. */
6720 fcn->name = strdup(name);
6721 if (!fcn->name)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006722 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006723 fcn->function_ref = ref;
6724
6725 /* List head */
6726 sck->list.n = sck->list.p = NULL;
6727
6728 /* converter keyword. */
6729 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006730 sck->kw[0].kw = calloc(1, len);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006731 if (!sck->kw[0].kw)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006732 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006733
6734 snprintf((char *)sck->kw[0].kw, len, "lua.%s", name);
6735 sck->kw[0].process = hlua_sample_conv_wrapper;
David Carlier0c437f42016-04-27 16:21:56 +01006736 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 +01006737 sck->kw[0].val_args = NULL;
6738 sck->kw[0].in_type = SMP_T_STR;
6739 sck->kw[0].out_type = SMP_T_STR;
6740 sck->kw[0].private = fcn;
6741
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006742 /* Register this new converter */
6743 sample_register_convs(sck);
6744
6745 return 0;
6746}
6747
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08006748/* This function is an LUA binding used for registering
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006749 * "sample-fetch" functions. It expects a converter name used
6750 * in the haproxy configuration file, and an LUA function.
6751 */
6752__LJMP static int hlua_register_fetches(lua_State *L)
6753{
6754 const char *name;
6755 int ref;
6756 int len;
6757 struct sample_fetch_kw_list *sfk;
6758 struct hlua_function *fcn;
Thierry Fourniera9230f82020-11-28 20:41:07 +01006759 struct sample_fetch *sf;
6760 struct buffer *trash;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006761
6762 MAY_LJMP(check_args(L, 2, "register_fetches"));
6763
6764 /* First argument : sample-fetch name. */
6765 name = MAY_LJMP(luaL_checkstring(L, 1));
6766
6767 /* Second argument : lua function. */
6768 ref = MAY_LJMP(hlua_checkfunction(L, 2));
6769
Thierry Fourniera9230f82020-11-28 20:41:07 +01006770 /* Check if the sample-fetch is already registered */
6771 trash = get_trash_chunk();
6772 chunk_printf(trash, "lua.%s", name);
6773 sf = find_sample_fetch(trash->area, trash->data);
6774 if (sf != NULL) {
6775 ha_warning("Trying to register sample-fetch 'lua.%s' more than once. "
6776 "This will become a hard error in version 2.5.\n", name);
6777 }
6778
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006779 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006780 sfk = calloc(1, sizeof(*sfk) + sizeof(struct sample_fetch) * 2);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006781 if (!sfk)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006782 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006783 fcn = calloc(1, sizeof(*fcn));
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006784 if (!fcn)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006785 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006786
6787 /* Fill fcn. */
6788 fcn->name = strdup(name);
6789 if (!fcn->name)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006790 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006791 fcn->function_ref = ref;
6792
6793 /* List head */
6794 sfk->list.n = sfk->list.p = NULL;
6795
6796 /* sample-fetch keyword. */
6797 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006798 sfk->kw[0].kw = calloc(1, len);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006799 if (!sfk->kw[0].kw)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006800 return luaL_error(L, "Lua out of memory error.");
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006801
6802 snprintf((char *)sfk->kw[0].kw, len, "lua.%s", name);
6803 sfk->kw[0].process = hlua_sample_fetch_wrapper;
David Carlier0c437f42016-04-27 16:21:56 +01006804 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 +01006805 sfk->kw[0].val_args = NULL;
6806 sfk->kw[0].out_type = SMP_T_STR;
6807 sfk->kw[0].use = SMP_USE_HTTP_ANY;
6808 sfk->kw[0].val = 0;
6809 sfk->kw[0].private = fcn;
6810
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006811 /* Register this new fetch. */
6812 sample_register_fetches(sfk);
6813
6814 return 0;
6815}
6816
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006817/* This function is a wrapper to execute each LUA function declared
6818 * as an action wrapper during the initialisation period. This function
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006819 * return ACT_RET_CONT if the processing is finished (with or without
6820 * error) and return ACT_RET_YIELD if the function must be called again
6821 * because the LUA returns a yield.
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006822 */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006823static enum act_return hlua_action(struct act_rule *rule, struct proxy *px,
Willy Tarreau658b85b2015-09-27 10:00:49 +02006824 struct session *sess, struct stream *s, int flags)
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006825{
6826 char **arg;
Christopher Fauletff96b8b2019-07-26 15:09:53 +02006827 unsigned int hflags = 0;
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02006828 int dir;
Thierry Fournierfd107a22016-02-19 19:57:23 +01006829 const char *error;
Willy Tarreau83061a82018-07-13 11:56:34 +02006830 const struct buffer msg = { };
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006831
6832 switch (rule->from) {
Christopher Fauletff96b8b2019-07-26 15:09:53 +02006833 case ACT_F_TCP_REQ_CNT: ; dir = SMP_OPT_DIR_REQ; break;
6834 case ACT_F_TCP_RES_CNT: ; dir = SMP_OPT_DIR_RES; break;
6835 case ACT_F_HTTP_REQ: hflags = HLUA_TXN_HTTP_RDY ; dir = SMP_OPT_DIR_REQ; break;
6836 case ACT_F_HTTP_RES: hflags = HLUA_TXN_HTTP_RDY ; dir = SMP_OPT_DIR_RES; break;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006837 default:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006838 SEND_ERR(px, "Lua: internal error while execute action.\n");
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006839 return ACT_RET_CONT;
6840 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006841
Willy Tarreau87b09662015-04-03 00:22:06 +02006842 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006843 * Lua context can be not initialized. This behavior
6844 * permits to save performances because a systematic
6845 * Lua initialization cause 5% performances loss.
6846 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006847 if (!s->hlua) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01006848 s->hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006849 if (!s->hlua) {
6850 SEND_ERR(px, "Lua action '%s': can't initialize Lua context.\n",
6851 rule->arg.hlua_rule->fcn.name);
6852 return ACT_RET_CONT;
6853 }
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01006854 if (!hlua_ctx_init(s->hlua, s->task, 0)) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006855 SEND_ERR(px, "Lua action '%s': can't initialize Lua context.\n",
6856 rule->arg.hlua_rule->fcn.name);
6857 return ACT_RET_CONT;
6858 }
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006859 }
6860
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006861 consistency_set(s, dir, &s->hlua->cons);
6862
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006863 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006864 if (!HLUA_IS_RUNNING(s->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006865
6866 /* The following Lua calls can fail. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006867 if (!SET_SAFE_LJMP(s->hlua->T)) {
6868 if (lua_type(s->hlua->T, -1) == LUA_TSTRING)
6869 error = lua_tostring(s->hlua->T, -1);
Thierry Fournierfd107a22016-02-19 19:57:23 +01006870 else
6871 error = "critical error";
6872 SEND_ERR(px, "Lua function '%s': %s.\n",
6873 rule->arg.hlua_rule->fcn.name, error);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006874 return ACT_RET_CONT;
6875 }
6876
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006877 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006878 if (!lua_checkstack(s->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006879 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006880 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006881 RESET_SAFE_LJMP(s->hlua->T);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02006882 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006883 }
6884
6885 /* Restore the function in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006886 lua_rawgeti(s->hlua->T, LUA_REGISTRYINDEX, rule->arg.hlua_rule->fcn.function_ref);
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006887
Willy Tarreau87b09662015-04-03 00:22:06 +02006888 /* Create and and push object stream in the stack. */
Christopher Fauletff96b8b2019-07-26 15:09:53 +02006889 if (!hlua_txn_new(s->hlua->T, s, px, dir, hflags)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006890 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006891 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006892 RESET_SAFE_LJMP(s->hlua->T);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02006893 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006894 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006895 s->hlua->nargs = 1;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006896
6897 /* push keywords in the stack. */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006898 for (arg = rule->arg.hlua_rule->args; arg && *arg; arg++) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006899 if (!lua_checkstack(s->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006900 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006901 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006902 RESET_SAFE_LJMP(s->hlua->T);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02006903 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006904 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006905 lua_pushstring(s->hlua->T, *arg);
6906 s->hlua->nargs++;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006907 }
6908
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006909 /* Now the execution is safe. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006910 RESET_SAFE_LJMP(s->hlua->T);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006911
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006912 /* We must initialize the execution timeouts. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006913 s->hlua->max_time = hlua_timeout_session;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006914 }
6915
Christopher Faulet719ddc82020-06-02 18:46:07 +02006916 /* Always reset the analyse expiration timeout for the corresponding
6917 * channel in case the lua script yield, to be sure to not keep an
6918 * expired timeout.
6919 */
6920 if (dir == SMP_OPT_DIR_REQ)
6921 s->req.analyse_exp = TICK_ETERNITY;
6922 else
6923 s->res.analyse_exp = TICK_ETERNITY;
6924
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006925 /* Execute the function. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006926 switch (hlua_ctx_resume(s->hlua, !(flags & ACT_FLAG_FINAL))) {
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006927 /* finished. */
6928 case HLUA_E_OK:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006929 if (!consistency_check(s, dir, &s->hlua->cons)) {
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006930 si_retnclose(&s->si[0], &msg);
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02006931 return ACT_RET_ERR;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01006932 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006933 if (s->hlua->flags & HLUA_STOP)
Christopher Faulet4629d082019-07-04 11:27:15 +02006934 return ACT_RET_DONE;
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02006935 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006936
6937 /* yield. */
6938 case HLUA_E_AGAIN:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01006939 /* Set timeout in the required channel. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006940 if (s->hlua->wake_time != TICK_ETERNITY) {
Christopher Fauletea0b0e22019-08-14 23:19:45 +02006941 if (dir == SMP_OPT_DIR_REQ)
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006942 s->req.analyse_exp = s->hlua->wake_time;
Christopher Fauletff96b8b2019-07-26 15:09:53 +02006943 else
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006944 s->res.analyse_exp = s->hlua->wake_time;
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01006945 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006946 /* Some actions can be wake up when a "write" event
6947 * is detected on a response channel. This is useful
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08006948 * only for actions targeted on the requests.
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006949 */
Christopher Fauletb22f6502019-07-26 14:54:52 +02006950 if (HLUA_IS_WAKERESWR(s->hlua))
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01006951 s->res.flags |= CF_WAKE_WRITE;
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006952 if (HLUA_IS_WAKEREQWR(s->hlua))
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01006953 s->req.flags |= CF_WAKE_WRITE;
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08006954 /* We can quit the function without consistency check
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01006955 * because HAProxy is not able to manipulate data, it
6956 * is only allowed to call me again. */
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02006957 return ACT_RET_YIELD;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006958
6959 /* finished with error. */
6960 case HLUA_E_ERRMSG:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006961 if (!consistency_check(s, dir, &s->hlua->cons)) {
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006962 si_retnclose(&s->si[0], &msg);
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02006963 return ACT_RET_ERR;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01006964 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006965 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006966 SEND_ERR(px, "Lua function '%s': %s.\n",
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006967 rule->arg.hlua_rule->fcn.name, lua_tostring(s->hlua->T, -1));
6968 lua_pop(s->hlua->T, 1);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02006969 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006970
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006971 case HLUA_E_ETMOUT:
6972 if (!consistency_check(s, dir, &s->hlua->cons)) {
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006973 si_retnclose(&s->si[0], &msg);
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006974 return ACT_RET_ERR;
6975 }
6976 SEND_ERR(px, "Lua function '%s': execution timeout.\n", rule->arg.hlua_rule->fcn.name);
6977 return 0;
6978
6979 case HLUA_E_NOMEM:
6980 if (!consistency_check(s, dir, &s->hlua->cons)) {
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006981 si_retnclose(&s->si[0], &msg);
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006982 return ACT_RET_ERR;
6983 }
6984 SEND_ERR(px, "Lua function '%s': out of memory error.\n", rule->arg.hlua_rule->fcn.name);
6985 return 0;
6986
6987 case HLUA_E_YIELD:
6988 if (!consistency_check(s, dir, &s->hlua->cons)) {
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006989 si_retnclose(&s->si[0], &msg);
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006990 return ACT_RET_ERR;
6991 }
6992 SEND_ERR(px, "Lua function '%s': aborting Lua processing on expired timeout.\n",
6993 rule->arg.hlua_rule->fcn.name);
6994 return 0;
6995
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006996 case HLUA_E_ERR:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006997 if (!consistency_check(s, dir, &s->hlua->cons)) {
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006998 si_retnclose(&s->si[0], &msg);
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02006999 return ACT_RET_ERR;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01007000 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007001 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02007002 SEND_ERR(px, "Lua function '%s' return an unknown error.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007003 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007004
7005 default:
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02007006 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007007 }
7008}
7009
Olivier Houchard9f6af332018-05-25 14:04:04 +02007010struct task *hlua_applet_wakeup(struct task *t, void *context, unsigned short state)
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007011{
Olivier Houchard9f6af332018-05-25 14:04:04 +02007012 struct appctx *ctx = context;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007013
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007014 appctx_wakeup(ctx);
Willy Tarreaud9587412017-08-23 16:07:33 +02007015 t->expire = TICK_ETERNITY;
Willy Tarreaud1aa41f2017-07-21 16:41:56 +02007016 return t;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007017}
7018
7019static int hlua_applet_tcp_init(struct appctx *ctx, struct proxy *px, struct stream *strm)
7020{
7021 struct stream_interface *si = ctx->owner;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007022 struct hlua *hlua;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007023 struct task *task;
7024 char **arg;
Thierry Fournierfd107a22016-02-19 19:57:23 +01007025 const char *error;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007026
Willy Tarreaubafbe012017-11-24 17:34:44 +01007027 hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007028 if (!hlua) {
7029 SEND_ERR(px, "Lua applet tcp '%s': out of memory.\n",
7030 ctx->rule->arg.hlua_rule->fcn.name);
7031 return 0;
7032 }
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007033 HLUA_INIT(hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007034 ctx->ctx.hlua_apptcp.hlua = hlua;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007035 ctx->ctx.hlua_apptcp.flags = 0;
7036
7037 /* Create task used by signal to wakeup applets. */
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01007038 task = task_new(tid_bit);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007039 if (!task) {
7040 SEND_ERR(px, "Lua applet tcp '%s': out of memory.\n",
7041 ctx->rule->arg.hlua_rule->fcn.name);
7042 return 0;
7043 }
7044 task->nice = 0;
7045 task->context = ctx;
7046 task->process = hlua_applet_wakeup;
7047 ctx->ctx.hlua_apptcp.task = task;
7048
7049 /* In the execution wrappers linked with a stream, the
7050 * Lua context can be not initialized. This behavior
7051 * permits to save performances because a systematic
7052 * Lua initialization cause 5% performances loss.
7053 */
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01007054 if (!hlua_ctx_init(hlua, task, 0)) {
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007055 SEND_ERR(px, "Lua applet tcp '%s': can't initialize Lua context.\n",
7056 ctx->rule->arg.hlua_rule->fcn.name);
7057 return 0;
7058 }
7059
7060 /* Set timeout according with the applet configuration. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02007061 hlua->max_time = ctx->applet->timeout;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007062
7063 /* The following Lua calls can fail. */
7064 if (!SET_SAFE_LJMP(hlua->T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01007065 if (lua_type(hlua->T, -1) == LUA_TSTRING)
7066 error = lua_tostring(hlua->T, -1);
7067 else
7068 error = "critical error";
7069 SEND_ERR(px, "Lua applet tcp '%s': %s.\n",
7070 ctx->rule->arg.hlua_rule->fcn.name, error);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007071 return 0;
7072 }
7073
7074 /* Check stack available size. */
7075 if (!lua_checkstack(hlua->T, 1)) {
7076 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
7077 ctx->rule->arg.hlua_rule->fcn.name);
7078 RESET_SAFE_LJMP(hlua->T);
7079 return 0;
7080 }
7081
7082 /* Restore the function in the stack. */
7083 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ctx->rule->arg.hlua_rule->fcn.function_ref);
7084
7085 /* Create and and push object stream in the stack. */
7086 if (!hlua_applet_tcp_new(hlua->T, ctx)) {
7087 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
7088 ctx->rule->arg.hlua_rule->fcn.name);
7089 RESET_SAFE_LJMP(hlua->T);
7090 return 0;
7091 }
7092 hlua->nargs = 1;
7093
7094 /* push keywords in the stack. */
7095 for (arg = ctx->rule->arg.hlua_rule->args; arg && *arg; arg++) {
7096 if (!lua_checkstack(hlua->T, 1)) {
7097 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
7098 ctx->rule->arg.hlua_rule->fcn.name);
7099 RESET_SAFE_LJMP(hlua->T);
7100 return 0;
7101 }
7102 lua_pushstring(hlua->T, *arg);
7103 hlua->nargs++;
7104 }
7105
7106 RESET_SAFE_LJMP(hlua->T);
7107
7108 /* Wakeup the applet ASAP. */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01007109 si_cant_get(si);
Willy Tarreau3367d412018-11-15 10:57:41 +01007110 si_rx_endp_more(si);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007111
7112 return 1;
7113}
7114
Willy Tarreau83a5ff42019-08-21 14:14:50 +02007115void hlua_applet_tcp_fct(struct appctx *ctx)
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007116{
7117 struct stream_interface *si = ctx->owner;
7118 struct stream *strm = si_strm(si);
7119 struct channel *res = si_ic(si);
7120 struct act_rule *rule = ctx->rule;
7121 struct proxy *px = strm->be;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007122 struct hlua *hlua = ctx->ctx.hlua_apptcp.hlua;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007123
7124 /* The applet execution is already done. */
Olivier Houchard594c8c52018-08-28 14:41:31 +02007125 if (ctx->ctx.hlua_apptcp.flags & APPLET_DONE) {
7126 /* eat the whole request */
7127 co_skip(si_oc(si), co_data(si_oc(si)));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007128 return;
Olivier Houchard594c8c52018-08-28 14:41:31 +02007129 }
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007130
7131 /* If the stream is disconnect or closed, ldo nothing. */
7132 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
7133 return;
7134
7135 /* Execute the function. */
7136 switch (hlua_ctx_resume(hlua, 1)) {
7137 /* finished. */
7138 case HLUA_E_OK:
7139 ctx->ctx.hlua_apptcp.flags |= APPLET_DONE;
7140
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007141 /* eat the whole request */
Willy Tarreaua79021a2018-06-15 18:07:57 +02007142 co_skip(si_oc(si), co_data(si_oc(si)));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007143 res->flags |= CF_READ_NULL;
7144 si_shutr(si);
7145 return;
7146
7147 /* yield. */
7148 case HLUA_E_AGAIN:
Thierry Fournier0164f202016-02-20 17:47:43 +01007149 if (hlua->wake_time != TICK_ETERNITY)
7150 task_schedule(ctx->ctx.hlua_apptcp.task, hlua->wake_time);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007151 return;
7152
7153 /* finished with error. */
7154 case HLUA_E_ERRMSG:
7155 /* Display log. */
7156 SEND_ERR(px, "Lua applet tcp '%s': %s.\n",
7157 rule->arg.hlua_rule->fcn.name, lua_tostring(hlua->T, -1));
7158 lua_pop(hlua->T, 1);
7159 goto error;
7160
Thierry Fournierd5b073c2018-05-21 19:42:47 +02007161 case HLUA_E_ETMOUT:
7162 SEND_ERR(px, "Lua applet tcp '%s': execution timeout.\n",
7163 rule->arg.hlua_rule->fcn.name);
7164 goto error;
7165
7166 case HLUA_E_NOMEM:
7167 SEND_ERR(px, "Lua applet tcp '%s': out of memory error.\n",
7168 rule->arg.hlua_rule->fcn.name);
7169 goto error;
7170
7171 case HLUA_E_YIELD: /* unexpected */
7172 SEND_ERR(px, "Lua applet tcp '%s': yield not allowed.\n",
7173 rule->arg.hlua_rule->fcn.name);
7174 goto error;
7175
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007176 case HLUA_E_ERR:
7177 /* Display log. */
7178 SEND_ERR(px, "Lua applet tcp '%s' return an unknown error.\n",
7179 rule->arg.hlua_rule->fcn.name);
7180 goto error;
7181
7182 default:
7183 goto error;
7184 }
7185
7186error:
7187
7188 /* For all other cases, just close the stream. */
7189 si_shutw(si);
7190 si_shutr(si);
7191 ctx->ctx.hlua_apptcp.flags |= APPLET_DONE;
7192}
7193
7194static void hlua_applet_tcp_release(struct appctx *ctx)
7195{
Olivier Houchard3f795f72019-04-17 22:51:06 +02007196 task_destroy(ctx->ctx.hlua_apptcp.task);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007197 ctx->ctx.hlua_apptcp.task = NULL;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007198 hlua_ctx_destroy(ctx->ctx.hlua_apptcp.hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007199 ctx->ctx.hlua_apptcp.hlua = NULL;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007200}
7201
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007202/* The function returns 1 if the initialisation is complete, 0 if
7203 * an errors occurs and -1 if more data are required for initializing
7204 * the applet.
7205 */
7206static int hlua_applet_http_init(struct appctx *ctx, struct proxy *px, struct stream *strm)
7207{
7208 struct stream_interface *si = ctx->owner;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007209 struct http_txn *txn;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007210 struct hlua *hlua;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007211 char **arg;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007212 struct task *task;
Thierry Fournierfd107a22016-02-19 19:57:23 +01007213 const char *error;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007214
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007215 txn = strm->txn;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007216
Willy Tarreau0078bfc2015-10-07 20:20:28 +02007217 /* We want two things in HTTP mode :
7218 * - enforce server-close mode if we were in keep-alive, so that the
7219 * applet is released after each response ;
7220 * - enable request body transfer to the applet in order to resync
7221 * with the response body.
7222 */
7223 if ((txn->flags & TX_CON_WANT_MSK) == TX_CON_WANT_KAL)
7224 txn->flags = (txn->flags & ~TX_CON_WANT_MSK) | TX_CON_WANT_SCL;
Willy Tarreau0078bfc2015-10-07 20:20:28 +02007225
Willy Tarreaubafbe012017-11-24 17:34:44 +01007226 hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007227 if (!hlua) {
7228 SEND_ERR(px, "Lua applet http '%s': out of memory.\n",
7229 ctx->rule->arg.hlua_rule->fcn.name);
7230 return 0;
7231 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007232 HLUA_INIT(hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007233 ctx->ctx.hlua_apphttp.hlua = hlua;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007234 ctx->ctx.hlua_apphttp.left_bytes = -1;
7235 ctx->ctx.hlua_apphttp.flags = 0;
7236
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +01007237 if (txn->req.flags & HTTP_MSGF_VER_11)
7238 ctx->ctx.hlua_apphttp.flags |= APPLET_HTTP11;
7239
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007240 /* Create task used by signal to wakeup applets. */
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01007241 task = task_new(tid_bit);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007242 if (!task) {
7243 SEND_ERR(px, "Lua applet http '%s': out of memory.\n",
7244 ctx->rule->arg.hlua_rule->fcn.name);
7245 return 0;
7246 }
7247 task->nice = 0;
7248 task->context = ctx;
7249 task->process = hlua_applet_wakeup;
7250 ctx->ctx.hlua_apphttp.task = task;
7251
7252 /* In the execution wrappers linked with a stream, the
7253 * Lua context can be not initialized. This behavior
7254 * permits to save performances because a systematic
7255 * Lua initialization cause 5% performances loss.
7256 */
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01007257 if (!hlua_ctx_init(hlua, task, 0)) {
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007258 SEND_ERR(px, "Lua applet http '%s': can't initialize Lua context.\n",
7259 ctx->rule->arg.hlua_rule->fcn.name);
7260 return 0;
7261 }
7262
7263 /* Set timeout according with the applet configuration. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02007264 hlua->max_time = ctx->applet->timeout;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007265
7266 /* The following Lua calls can fail. */
7267 if (!SET_SAFE_LJMP(hlua->T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01007268 if (lua_type(hlua->T, -1) == LUA_TSTRING)
7269 error = lua_tostring(hlua->T, -1);
7270 else
7271 error = "critical error";
7272 SEND_ERR(px, "Lua applet http '%s': %s.\n",
7273 ctx->rule->arg.hlua_rule->fcn.name, error);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007274 return 0;
7275 }
7276
7277 /* Check stack available size. */
7278 if (!lua_checkstack(hlua->T, 1)) {
7279 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
7280 ctx->rule->arg.hlua_rule->fcn.name);
7281 RESET_SAFE_LJMP(hlua->T);
7282 return 0;
7283 }
7284
7285 /* Restore the function in the stack. */
7286 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ctx->rule->arg.hlua_rule->fcn.function_ref);
7287
7288 /* Create and and push object stream in the stack. */
7289 if (!hlua_applet_http_new(hlua->T, ctx)) {
7290 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
7291 ctx->rule->arg.hlua_rule->fcn.name);
7292 RESET_SAFE_LJMP(hlua->T);
7293 return 0;
7294 }
7295 hlua->nargs = 1;
7296
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007297 /* push keywords in the stack. */
7298 for (arg = ctx->rule->arg.hlua_rule->args; arg && *arg; arg++) {
7299 if (!lua_checkstack(hlua->T, 1)) {
7300 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
7301 ctx->rule->arg.hlua_rule->fcn.name);
7302 RESET_SAFE_LJMP(hlua->T);
7303 return 0;
7304 }
7305 lua_pushstring(hlua->T, *arg);
7306 hlua->nargs++;
7307 }
7308
7309 RESET_SAFE_LJMP(hlua->T);
7310
7311 /* Wakeup the applet when data is ready for read. */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01007312 si_cant_get(si);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007313
7314 return 1;
7315}
7316
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007317static void hlua_applet_htx_fct(struct appctx *ctx)
7318{
7319 struct stream_interface *si = ctx->owner;
7320 struct stream *strm = si_strm(si);
7321 struct channel *req = si_oc(si);
7322 struct channel *res = si_ic(si);
7323 struct act_rule *rule = ctx->rule;
7324 struct proxy *px = strm->be;
7325 struct hlua *hlua = ctx->ctx.hlua_apphttp.hlua;
7326 struct htx *req_htx, *res_htx;
7327
7328 res_htx = htx_from_buf(&res->buf);
7329
7330 /* If the stream is disconnect or closed, ldo nothing. */
7331 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
7332 goto out;
7333
7334 /* Check if the input buffer is avalaible. */
7335 if (!b_size(&res->buf)) {
7336 si_rx_room_blk(si);
7337 goto out;
7338 }
7339 /* check that the output is not closed */
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007340 if (res->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_SHUTR))
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007341 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
7342
7343 /* Set the currently running flag. */
7344 if (!HLUA_IS_RUNNING(hlua) &&
7345 !(ctx->ctx.hlua_apphttp.flags & APPLET_DONE)) {
7346 struct htx_blk *blk;
7347 size_t count = co_data(req);
7348
7349 if (!count) {
7350 si_cant_get(si);
7351 goto out;
7352 }
7353
7354 /* We need to flush the request header. This left the body for
7355 * the Lua.
7356 */
7357 req_htx = htx_from_buf(&req->buf);
Christopher Fauleta3f15502019-05-13 15:27:23 +02007358 blk = htx_get_first_blk(req_htx);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007359 while (count && blk) {
7360 enum htx_blk_type type = htx_get_blk_type(blk);
7361 uint32_t sz = htx_get_blksz(blk);
7362
7363 if (sz > count) {
7364 si_cant_get(si);
Christopher Faulet0ae79d02019-02-27 21:36:59 +01007365 htx_to_buf(req_htx, &req->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007366 goto out;
7367 }
7368
7369 count -= sz;
7370 co_set_data(req, co_data(req) - sz);
7371 blk = htx_remove_blk(req_htx, blk);
7372
7373 if (type == HTX_BLK_EOH)
7374 break;
7375 }
Christopher Faulet0ae79d02019-02-27 21:36:59 +01007376 htx_to_buf(req_htx, &req->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007377 }
7378
7379 /* Executes The applet if it is not done. */
7380 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_DONE)) {
7381
7382 /* Execute the function. */
7383 switch (hlua_ctx_resume(hlua, 1)) {
7384 /* finished. */
7385 case HLUA_E_OK:
7386 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
7387 break;
7388
7389 /* yield. */
7390 case HLUA_E_AGAIN:
7391 if (hlua->wake_time != TICK_ETERNITY)
7392 task_schedule(ctx->ctx.hlua_apphttp.task, hlua->wake_time);
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007393 goto out;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007394
7395 /* finished with error. */
7396 case HLUA_E_ERRMSG:
7397 /* Display log. */
7398 SEND_ERR(px, "Lua applet http '%s': %s.\n",
7399 rule->arg.hlua_rule->fcn.name, lua_tostring(hlua->T, -1));
7400 lua_pop(hlua->T, 1);
7401 goto error;
7402
7403 case HLUA_E_ETMOUT:
7404 SEND_ERR(px, "Lua applet http '%s': execution timeout.\n",
7405 rule->arg.hlua_rule->fcn.name);
7406 goto error;
7407
7408 case HLUA_E_NOMEM:
7409 SEND_ERR(px, "Lua applet http '%s': out of memory error.\n",
7410 rule->arg.hlua_rule->fcn.name);
7411 goto error;
7412
7413 case HLUA_E_YIELD: /* unexpected */
7414 SEND_ERR(px, "Lua applet http '%s': yield not allowed.\n",
7415 rule->arg.hlua_rule->fcn.name);
7416 goto error;
7417
7418 case HLUA_E_ERR:
7419 /* Display log. */
7420 SEND_ERR(px, "Lua applet http '%s' return an unknown error.\n",
7421 rule->arg.hlua_rule->fcn.name);
7422 goto error;
7423
7424 default:
7425 goto error;
7426 }
7427 }
7428
7429 if (ctx->ctx.hlua_apphttp.flags & APPLET_DONE) {
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007430 if (ctx->ctx.hlua_apphttp.flags & APPLET_RSP_SENT)
7431 goto done;
7432
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007433 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT))
7434 goto error;
7435
Christopher Faulet54b5e212019-06-04 10:08:28 +02007436 /* Don't add TLR because mux-h1 will take care of it */
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007437 if (!htx_add_endof(res_htx, HTX_BLK_EOM)) {
7438 si_rx_room_blk(si);
7439 goto out;
7440 }
Christopher Fauletf6cce3f2019-02-27 21:20:09 +01007441 channel_add_input(res, 1);
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007442 strm->txn->status = ctx->ctx.hlua_apphttp.status;
7443 ctx->ctx.hlua_apphttp.flags |= APPLET_RSP_SENT;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007444 }
7445
7446 done:
7447 if (ctx->ctx.hlua_apphttp.flags & APPLET_DONE) {
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007448 if (!(res->flags & CF_SHUTR)) {
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007449 res->flags |= CF_READ_NULL;
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007450 si_shutr(si);
7451 }
7452
7453 /* eat the whole request */
7454 if (co_data(req)) {
7455 req_htx = htx_from_buf(&req->buf);
7456 co_htx_skip(req, req_htx, co_data(req));
7457 htx_to_buf(req_htx, &req->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007458 }
7459 }
7460
7461 out:
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007462 htx_to_buf(res_htx, &res->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007463 return;
7464
7465 error:
7466
7467 /* If we are in HTTP mode, and we are not send any
7468 * data, return a 500 server error in best effort:
7469 * if there is no room available in the buffer,
7470 * just close the connection.
7471 */
7472 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT)) {
7473 struct buffer *err = &htx_err_chunks[HTTP_ERR_500];
7474
7475 channel_erase(res);
7476 res->buf.data = b_data(err);
7477 memcpy(res->buf.area, b_head(err), b_data(err));
7478 res_htx = htx_from_buf(&res->buf);
Christopher Fauletf6cce3f2019-02-27 21:20:09 +01007479 channel_add_input(res, res_htx->data);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007480 }
7481 if (!(strm->flags & SF_ERR_MASK))
7482 strm->flags |= SF_ERR_RESOURCE;
7483 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
7484 goto done;
7485}
7486
Willy Tarreau83a5ff42019-08-21 14:14:50 +02007487void hlua_applet_http_fct(struct appctx *ctx)
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007488{
7489 struct stream_interface *si = ctx->owner;
7490 struct stream *strm = si_strm(si);
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007491 struct channel *req = si_oc(si);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007492 struct channel *res = si_ic(si);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007493 struct act_rule *rule = ctx->rule;
7494 struct proxy *px = strm->be;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007495 struct hlua *hlua = ctx->ctx.hlua_apphttp.hlua;
Willy Tarreau206ba832018-06-14 15:27:31 +02007496 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02007497 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02007498 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02007499 size_t len2;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007500 int ret;
7501
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007502 if (IS_HTX_STRM(strm))
7503 return hlua_applet_htx_fct(ctx);
7504
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007505 /* If the stream is disconnect or closed, ldo nothing. */
7506 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007507 goto out;
7508
7509 /* Check if the input buffer is avalaible. */
7510 if (!b_size(&res->buf)) {
7511 si_rx_room_blk(si);
7512 goto out;
7513 }
7514 /* check that the output is not closed */
7515 if (res->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_SHUTR))
7516 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007517
7518 /* Set the currently running flag. */
7519 if (!HLUA_IS_RUNNING(hlua) &&
7520 !(ctx->ctx.hlua_apphttp.flags & APPLET_DONE)) {
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007521 /* Store the max amount of bytes that we can read. */
7522 ctx->ctx.hlua_apphttp.left_bytes = strm->txn->req.body_len;
7523
7524 /* We need to flush the request header. This left the body
7525 * for the Lua.
7526 */
7527
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08007528 /* Read the maximum amount of data available. */
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007529 ret = co_getblk_nc(req, &blk1, &len1, &blk2, &len2);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007530 if (ret == -1)
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007531 goto out;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007532
7533 /* No data available, ask for more data. */
7534 if (ret == 1)
7535 len2 = 0;
7536 if (ret == 0)
7537 len1 = 0;
Thierry FOURNIER70d318c2018-06-30 10:37:33 +02007538 if (len1 + len2 < strm->txn->req.eoh + strm->txn->req.eol) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01007539 si_cant_get(si);
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007540 goto out;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007541 }
7542
7543 /* skip the requests bytes. */
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007544 co_skip(req, strm->txn->req.eoh + strm->txn->req.eol);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007545 }
7546
7547 /* Executes The applet if it is not done. */
7548 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_DONE)) {
7549
7550 /* Execute the function. */
7551 switch (hlua_ctx_resume(hlua, 1)) {
7552 /* finished. */
7553 case HLUA_E_OK:
7554 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
7555 break;
7556
7557 /* yield. */
7558 case HLUA_E_AGAIN:
Thierry Fournier0164f202016-02-20 17:47:43 +01007559 if (hlua->wake_time != TICK_ETERNITY)
7560 task_schedule(ctx->ctx.hlua_apphttp.task, hlua->wake_time);
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007561 goto out;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007562
7563 /* finished with error. */
7564 case HLUA_E_ERRMSG:
7565 /* Display log. */
7566 SEND_ERR(px, "Lua applet http '%s': %s.\n",
7567 rule->arg.hlua_rule->fcn.name, lua_tostring(hlua->T, -1));
7568 lua_pop(hlua->T, 1);
7569 goto error;
7570
Thierry Fournierd5b073c2018-05-21 19:42:47 +02007571 case HLUA_E_ETMOUT:
7572 SEND_ERR(px, "Lua applet http '%s': execution timeout.\n",
7573 rule->arg.hlua_rule->fcn.name);
7574 goto error;
7575
7576 case HLUA_E_NOMEM:
7577 SEND_ERR(px, "Lua applet http '%s': out of memory error.\n",
7578 rule->arg.hlua_rule->fcn.name);
7579 goto error;
7580
7581 case HLUA_E_YIELD: /* unexpected */
7582 SEND_ERR(px, "Lua applet http '%s': yield not allowed.\n",
7583 rule->arg.hlua_rule->fcn.name);
7584 goto error;
7585
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007586 case HLUA_E_ERR:
7587 /* Display log. */
7588 SEND_ERR(px, "Lua applet http '%s' return an unknown error.\n",
7589 rule->arg.hlua_rule->fcn.name);
7590 goto error;
7591
7592 default:
7593 goto error;
7594 }
7595 }
7596
7597 if (ctx->ctx.hlua_apphttp.flags & APPLET_DONE) {
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007598 if (ctx->ctx.hlua_apphttp.flags & APPLET_RSP_SENT)
7599 goto done;
7600
Christopher Fauletcc26b132018-12-18 21:20:57 +01007601 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT))
7602 goto error;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007603
7604 /* We must send the final chunk. */
7605 if (ctx->ctx.hlua_apphttp.flags & APPLET_CHUNKED &&
7606 !(ctx->ctx.hlua_apphttp.flags & APPLET_LAST_CHK)) {
7607
7608 /* sent last chunk at once. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02007609 ret = ci_putblk(res, "0\r\n\r\n", 5);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007610
7611 /* critical error. */
7612 if (ret == -2 || ret == -3) {
7613 SEND_ERR(px, "Lua applet http '%s'cannont send last chunk.\n",
7614 rule->arg.hlua_rule->fcn.name);
7615 goto error;
7616 }
7617
7618 /* no enough space error. */
7619 if (ret == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01007620 si_rx_room_blk(si);
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007621 goto out;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007622 }
7623
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007624 strm->txn->status = ctx->ctx.hlua_apphttp.status;
7625 ctx->ctx.hlua_apphttp.flags |= (APPLET_LAST_CHK|APPLET_RSP_SENT);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007626 }
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007627 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007628
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007629 done:
7630 if (ctx->ctx.hlua_apphttp.flags & APPLET_DONE) {
7631 if (!(res->flags & CF_SHUTR)) {
7632 res->flags |= CF_READ_NULL;
7633 si_shutr(si);
7634 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007635
7636 /* eat the whole request */
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007637 if (co_data(req))
7638 co_skip(req, co_data(req));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007639 }
7640
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007641 out:
7642 return;
7643
7644 error:
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007645
7646 /* If we are in HTTP mode, and we are not send any
7647 * data, return a 500 server error in best effort:
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08007648 * if there is no room available in the buffer,
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007649 * just close the connection.
7650 */
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007651 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT)) {
7652 channel_erase(res);
7653 ci_putblk(res, error_500, strlen(error_500));
7654 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007655 if (!(strm->flags & SF_ERR_MASK))
7656 strm->flags |= SF_ERR_RESOURCE;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007657 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007658 goto done;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007659}
7660
7661static void hlua_applet_http_release(struct appctx *ctx)
7662{
Olivier Houchard3f795f72019-04-17 22:51:06 +02007663 task_destroy(ctx->ctx.hlua_apphttp.task);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007664 ctx->ctx.hlua_apphttp.task = NULL;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007665 hlua_ctx_destroy(ctx->ctx.hlua_apphttp.hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007666 ctx->ctx.hlua_apphttp.hlua = NULL;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007667}
7668
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007669/* global {tcp|http}-request parser. Return ACT_RET_PRS_OK in
7670 * succes case, else return ACT_RET_PRS_ERR.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02007671 *
7672 * This function can fail with an abort() due to an Lua critical error.
7673 * We are in the configuration parsing process of HAProxy, this abort() is
7674 * tolerated.
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007675 */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007676static enum act_parse_ret action_register_lua(const char **args, int *cur_arg, struct proxy *px,
7677 struct act_rule *rule, char **err)
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007678{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02007679 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007680 int i;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007681
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007682 /* Memory for the rule. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02007683 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007684 if (!rule->arg.hlua_rule) {
7685 memprintf(err, "out of memory error");
Thierry FOURNIERafa80492015-08-19 09:04:15 +02007686 return ACT_RET_PRS_ERR;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007687 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007688
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007689 /* Memory for arguments. */
7690 rule->arg.hlua_rule->args = calloc(fcn->nargs + 1, sizeof(char *));
7691 if (!rule->arg.hlua_rule->args) {
7692 memprintf(err, "out of memory error");
7693 return ACT_RET_PRS_ERR;
7694 }
7695
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007696 /* Reference the Lua function and store the reference. */
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007697 rule->arg.hlua_rule->fcn = *fcn;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007698
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007699 /* Expect some arguments */
7700 for (i = 0; i < fcn->nargs; i++) {
Thierry FOURNIER1725c2e2019-01-06 19:38:49 +01007701 if (*args[*cur_arg] == '\0') {
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007702 memprintf(err, "expect %d arguments", fcn->nargs);
7703 return ACT_RET_PRS_ERR;
7704 }
Thierry FOURNIER1725c2e2019-01-06 19:38:49 +01007705 rule->arg.hlua_rule->args[i] = strdup(args[*cur_arg]);
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007706 if (!rule->arg.hlua_rule->args[i]) {
7707 memprintf(err, "out of memory error");
7708 return ACT_RET_PRS_ERR;
7709 }
7710 (*cur_arg)++;
7711 }
7712 rule->arg.hlua_rule->args[i] = NULL;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007713
Thierry FOURNIER42148732015-09-02 17:17:33 +02007714 rule->action = ACT_CUSTOM;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007715 rule->action_ptr = hlua_action;
Thierry FOURNIERafa80492015-08-19 09:04:15 +02007716 return ACT_RET_PRS_OK;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007717}
7718
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007719static enum act_parse_ret action_register_service_http(const char **args, int *cur_arg, struct proxy *px,
7720 struct act_rule *rule, char **err)
7721{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02007722 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007723
Thierry FOURNIER718e2a72015-12-20 20:13:14 +01007724 /* HTTP applets are forbidden in tcp-request rules.
7725 * HTTP applet request requires everything initilized by
7726 * "http_process_request" (analyzer flag AN_REQ_HTTP_INNER).
7727 * The applet will be immediately initilized, but its before
7728 * the call of this analyzer.
7729 */
7730 if (rule->from != ACT_F_HTTP_REQ) {
7731 memprintf(err, "HTTP applets are forbidden from 'tcp-request' rulesets");
7732 return ACT_RET_PRS_ERR;
7733 }
7734
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007735 /* Memory for the rule. */
7736 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
7737 if (!rule->arg.hlua_rule) {
7738 memprintf(err, "out of memory error");
7739 return ACT_RET_PRS_ERR;
7740 }
7741
7742 /* Reference the Lua function and store the reference. */
7743 rule->arg.hlua_rule->fcn = *fcn;
7744
7745 /* TODO: later accept arguments. */
7746 rule->arg.hlua_rule->args = NULL;
7747
7748 /* Add applet pointer in the rule. */
7749 rule->applet.obj_type = OBJ_TYPE_APPLET;
7750 rule->applet.name = fcn->name;
7751 rule->applet.init = hlua_applet_http_init;
7752 rule->applet.fct = hlua_applet_http_fct;
7753 rule->applet.release = hlua_applet_http_release;
7754 rule->applet.timeout = hlua_timeout_applet;
7755
7756 return ACT_RET_PRS_OK;
7757}
7758
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007759/* This function is an LUA binding used for registering
7760 * "sample-conv" functions. It expects a converter name used
7761 * in the haproxy configuration file, and an LUA function.
7762 */
7763__LJMP static int hlua_register_action(lua_State *L)
7764{
7765 struct action_kw_list *akl;
7766 const char *name;
7767 int ref;
7768 int len;
7769 struct hlua_function *fcn;
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007770 int nargs;
Thierry Fourniera9230f82020-11-28 20:41:07 +01007771 struct buffer *trash;
7772 struct action_kw *akw;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007773
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007774 /* Initialise the number of expected arguments at 0. */
7775 nargs = 0;
7776
7777 if (lua_gettop(L) < 3 || lua_gettop(L) > 4)
7778 WILL_LJMP(luaL_error(L, "'register_action' needs between 3 and 4 arguments"));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007779
7780 /* First argument : converter name. */
7781 name = MAY_LJMP(luaL_checkstring(L, 1));
7782
7783 /* Second argument : environment. */
7784 if (lua_type(L, 2) != LUA_TTABLE)
7785 WILL_LJMP(luaL_error(L, "register_action: second argument must be a table of strings"));
7786
7787 /* Third argument : lua function. */
7788 ref = MAY_LJMP(hlua_checkfunction(L, 3));
7789
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08007790 /* Fourth argument : number of mandatory arguments expected on the configuration line. */
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007791 if (lua_gettop(L) >= 4)
7792 nargs = MAY_LJMP(luaL_checkinteger(L, 4));
7793
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08007794 /* browse the second argument as an array. */
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007795 lua_pushnil(L);
7796 while (lua_next(L, 2) != 0) {
7797 if (lua_type(L, -1) != LUA_TSTRING)
7798 WILL_LJMP(luaL_error(L, "register_action: second argument must be a table of strings"));
7799
Thierry Fourniera9230f82020-11-28 20:41:07 +01007800 /* Check if action exists */
7801 trash = get_trash_chunk();
7802 chunk_printf(trash, "lua.%s", name);
7803 if (strcmp(lua_tostring(L, -1), "tcp-req") == 0) {
7804 akw = tcp_req_cont_action(trash->area);
7805 } else if (strcmp(lua_tostring(L, -1), "tcp-res") == 0) {
7806 akw = tcp_res_cont_action(trash->area);
7807 } else if (strcmp(lua_tostring(L, -1), "http-req") == 0) {
7808 akw = action_http_req_custom(trash->area);
7809 } else if (strcmp(lua_tostring(L, -1), "http-res") == 0) {
7810 akw = action_http_res_custom(trash->area);
7811 } else {
7812 akw = NULL;
7813 }
7814 if (akw != NULL) {
7815 ha_warning("Trying to register action 'lua.%s' more than once. "
7816 "This will become a hard error in version 2.5.\n", name);
7817 }
7818
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007819 /* Check required environment. Only accepted "http" or "tcp". */
7820 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02007821 akl = calloc(1, sizeof(*akl) + sizeof(struct action_kw) * 2);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007822 if (!akl)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007823 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02007824 fcn = calloc(1, sizeof(*fcn));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007825 if (!fcn)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007826 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007827
7828 /* Fill fcn. */
7829 fcn->name = strdup(name);
7830 if (!fcn->name)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007831 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007832 fcn->function_ref = ref;
7833
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007834 /* Set the expected number od arguments. */
7835 fcn->nargs = nargs;
7836
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007837 /* List head */
7838 akl->list.n = akl->list.p = NULL;
7839
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007840 /* action keyword. */
7841 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02007842 akl->kw[0].kw = calloc(1, len);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007843 if (!akl->kw[0].kw)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007844 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007845
7846 snprintf((char *)akl->kw[0].kw, len, "lua.%s", name);
7847
7848 akl->kw[0].match_pfx = 0;
7849 akl->kw[0].private = fcn;
7850 akl->kw[0].parse = action_register_lua;
7851
7852 /* select the action registering point. */
7853 if (strcmp(lua_tostring(L, -1), "tcp-req") == 0)
7854 tcp_req_cont_keywords_register(akl);
7855 else if (strcmp(lua_tostring(L, -1), "tcp-res") == 0)
7856 tcp_res_cont_keywords_register(akl);
7857 else if (strcmp(lua_tostring(L, -1), "http-req") == 0)
7858 http_req_keywords_register(akl);
7859 else if (strcmp(lua_tostring(L, -1), "http-res") == 0)
7860 http_res_keywords_register(akl);
7861 else
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007862 WILL_LJMP(luaL_error(L, "Lua action environment '%s' is unknown. "
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007863 "'tcp-req', 'tcp-res', 'http-req' or 'http-res' "
7864 "are expected.", lua_tostring(L, -1)));
7865
7866 /* pop the environment string. */
7867 lua_pop(L, 1);
7868 }
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007869 return ACT_RET_PRS_OK;
7870}
7871
7872static enum act_parse_ret action_register_service_tcp(const char **args, int *cur_arg, struct proxy *px,
7873 struct act_rule *rule, char **err)
7874{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02007875 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007876
Christopher Fauleteb709802019-04-11 22:04:08 +02007877 if (px->mode == PR_MODE_HTTP && (px->options2 & PR_O2_USE_HTX)) {
Christopher Fauletafd8f102018-11-08 11:34:21 +01007878 memprintf(err, "Lua services cannot be used when the HTX internal representation is enabled");
7879 return ACT_RET_PRS_ERR;
7880 }
7881
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007882 /* Memory for the rule. */
7883 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
7884 if (!rule->arg.hlua_rule) {
7885 memprintf(err, "out of memory error");
7886 return ACT_RET_PRS_ERR;
7887 }
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007888
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007889 /* Reference the Lua function and store the reference. */
7890 rule->arg.hlua_rule->fcn = *fcn;
7891
7892 /* TODO: later accept arguments. */
7893 rule->arg.hlua_rule->args = NULL;
7894
7895 /* Add applet pointer in the rule. */
7896 rule->applet.obj_type = OBJ_TYPE_APPLET;
7897 rule->applet.name = fcn->name;
7898 rule->applet.init = hlua_applet_tcp_init;
7899 rule->applet.fct = hlua_applet_tcp_fct;
7900 rule->applet.release = hlua_applet_tcp_release;
7901 rule->applet.timeout = hlua_timeout_applet;
7902
7903 return 0;
7904}
7905
7906/* This function is an LUA binding used for registering
7907 * "sample-conv" functions. It expects a converter name used
7908 * in the haproxy configuration file, and an LUA function.
7909 */
7910__LJMP static int hlua_register_service(lua_State *L)
7911{
7912 struct action_kw_list *akl;
7913 const char *name;
7914 const char *env;
7915 int ref;
7916 int len;
7917 struct hlua_function *fcn;
Thierry Fourniera9230f82020-11-28 20:41:07 +01007918 struct buffer *trash;
7919 struct action_kw *akw;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007920
7921 MAY_LJMP(check_args(L, 3, "register_service"));
7922
7923 /* First argument : converter name. */
7924 name = MAY_LJMP(luaL_checkstring(L, 1));
7925
7926 /* Second argument : environment. */
7927 env = MAY_LJMP(luaL_checkstring(L, 2));
7928
7929 /* Third argument : lua function. */
7930 ref = MAY_LJMP(hlua_checkfunction(L, 3));
7931
Thierry Fourniera9230f82020-11-28 20:41:07 +01007932 /* Check for service already registered */
7933 trash = get_trash_chunk();
7934 chunk_printf(trash, "lua.%s", name);
7935 akw = service_find(trash->area);
7936 if (akw != NULL) {
7937 ha_warning("Trying to register service 'lua.%s' more than once. "
7938 "This will become a hard error in version 2.5.\n", name);
7939 }
7940
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007941 /* Allocate and fill the sample fetch keyword struct. */
7942 akl = calloc(1, sizeof(*akl) + sizeof(struct action_kw) * 2);
7943 if (!akl)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007944 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007945 fcn = calloc(1, sizeof(*fcn));
7946 if (!fcn)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007947 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007948
7949 /* Fill fcn. */
7950 len = strlen("<lua.>") + strlen(name) + 1;
7951 fcn->name = calloc(1, len);
7952 if (!fcn->name)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007953 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007954 snprintf((char *)fcn->name, len, "<lua.%s>", name);
7955 fcn->function_ref = ref;
7956
7957 /* List head */
7958 akl->list.n = akl->list.p = NULL;
7959
7960 /* converter keyword. */
7961 len = strlen("lua.") + strlen(name) + 1;
7962 akl->kw[0].kw = calloc(1, len);
7963 if (!akl->kw[0].kw)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007964 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007965
7966 snprintf((char *)akl->kw[0].kw, len, "lua.%s", name);
7967
Thierry FOURNIER / OZON.IO02564fd2016-11-12 11:07:05 +01007968 /* Check required environment. Only accepted "http" or "tcp". */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007969 if (strcmp(env, "tcp") == 0)
7970 akl->kw[0].parse = action_register_service_tcp;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007971 else if (strcmp(env, "http") == 0)
7972 akl->kw[0].parse = action_register_service_http;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007973 else
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007974 WILL_LJMP(luaL_error(L, "Lua service environment '%s' is unknown. "
Eric Salamafe7456f2017-12-21 14:30:07 +01007975 "'tcp' or 'http' are expected.", env));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007976
7977 akl->kw[0].match_pfx = 0;
7978 akl->kw[0].private = fcn;
7979
7980 /* End of array. */
7981 memset(&akl->kw[1], 0, sizeof(*akl->kw));
7982
7983 /* Register this new converter */
7984 service_keywords_register(akl);
7985
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007986 return 0;
7987}
7988
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007989/* This function initialises Lua cli handler. It copies the
7990 * arguments in the Lua stack and create channel IO objects.
7991 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02007992static int hlua_cli_parse_fct(char **args, char *payload, struct appctx *appctx, void *private)
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007993{
7994 struct hlua *hlua;
7995 struct hlua_function *fcn;
7996 int i;
7997 const char *error;
7998
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007999 fcn = private;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01008000 appctx->ctx.hlua_cli.fcn = private;
8001
Willy Tarreaubafbe012017-11-24 17:34:44 +01008002 hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01008003 if (!hlua) {
8004 SEND_ERR(NULL, "Lua cli '%s': out of memory.\n", fcn->name);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01008005 return 1;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01008006 }
8007 HLUA_INIT(hlua);
8008 appctx->ctx.hlua_cli.hlua = hlua;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008009
8010 /* Create task used by signal to wakeup applets.
8011 * We use the same wakeup fonction than the Lua applet_tcp and
8012 * applet_http. It is absolutely compatible.
8013 */
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01008014 appctx->ctx.hlua_cli.task = task_new(tid_bit);
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008015 if (!appctx->ctx.hlua_cli.task) {
Thierry FOURNIERffbf5692016-12-16 11:14:06 +01008016 SEND_ERR(NULL, "Lua cli '%s': out of memory.\n", fcn->name);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01008017 goto error;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008018 }
8019 appctx->ctx.hlua_cli.task->nice = 0;
8020 appctx->ctx.hlua_cli.task->context = appctx;
8021 appctx->ctx.hlua_cli.task->process = hlua_applet_wakeup;
8022
8023 /* Initialises the Lua context */
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01008024 if (!hlua_ctx_init(hlua, appctx->ctx.hlua_cli.task, 0)) {
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008025 SEND_ERR(NULL, "Lua cli '%s': can't initialize Lua context.\n", fcn->name);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01008026 goto error;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008027 }
8028
8029 /* The following Lua calls can fail. */
8030 if (!SET_SAFE_LJMP(hlua->T)) {
8031 if (lua_type(hlua->T, -1) == LUA_TSTRING)
8032 error = lua_tostring(hlua->T, -1);
8033 else
8034 error = "critical error";
8035 SEND_ERR(NULL, "Lua cli '%s': %s.\n", fcn->name, error);
8036 goto error;
8037 }
8038
8039 /* Check stack available size. */
8040 if (!lua_checkstack(hlua->T, 2)) {
8041 SEND_ERR(NULL, "Lua cli '%s': full stack.\n", fcn->name);
8042 goto error;
8043 }
8044
8045 /* Restore the function in the stack. */
8046 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, fcn->function_ref);
8047
8048 /* Once the arguments parsed, the CLI is like an AppletTCP,
8049 * so push AppletTCP in the stack.
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008050 */
8051 if (!hlua_applet_tcp_new(hlua->T, appctx)) {
8052 SEND_ERR(NULL, "Lua cli '%s': full stack.\n", fcn->name);
8053 goto error;
8054 }
8055 hlua->nargs = 1;
8056
8057 /* push keywords in the stack. */
8058 for (i = 0; *args[i]; i++) {
8059 /* Check stack available size. */
8060 if (!lua_checkstack(hlua->T, 1)) {
8061 SEND_ERR(NULL, "Lua cli '%s': full stack.\n", fcn->name);
8062 goto error;
8063 }
8064 lua_pushstring(hlua->T, args[i]);
8065 hlua->nargs++;
8066 }
8067
8068 /* We must initialize the execution timeouts. */
8069 hlua->max_time = hlua_timeout_session;
8070
8071 /* At this point the execution is safe. */
8072 RESET_SAFE_LJMP(hlua->T);
8073
8074 /* It's ok */
8075 return 0;
8076
8077 /* It's not ok. */
8078error:
8079 RESET_SAFE_LJMP(hlua->T);
8080 hlua_ctx_destroy(hlua);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01008081 appctx->ctx.hlua_cli.hlua = NULL;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008082 return 1;
8083}
8084
8085static int hlua_cli_io_handler_fct(struct appctx *appctx)
8086{
8087 struct hlua *hlua;
8088 struct stream_interface *si;
8089 struct hlua_function *fcn;
8090
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01008091 hlua = appctx->ctx.hlua_cli.hlua;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008092 si = appctx->owner;
Willy Tarreau8ae4f752016-12-14 15:41:45 +01008093 fcn = appctx->ctx.hlua_cli.fcn;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008094
8095 /* If the stream is disconnect or closed, ldo nothing. */
8096 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
8097 return 1;
8098
8099 /* Execute the function. */
8100 switch (hlua_ctx_resume(hlua, 1)) {
8101
8102 /* finished. */
8103 case HLUA_E_OK:
8104 return 1;
8105
8106 /* yield. */
8107 case HLUA_E_AGAIN:
8108 /* We want write. */
8109 if (HLUA_IS_WAKERESWR(hlua))
Willy Tarreaudb398432018-11-15 11:08:52 +01008110 si_rx_room_blk(si);
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008111 /* Set the timeout. */
8112 if (hlua->wake_time != TICK_ETERNITY)
8113 task_schedule(hlua->task, hlua->wake_time);
8114 return 0;
8115
8116 /* finished with error. */
8117 case HLUA_E_ERRMSG:
8118 /* Display log. */
8119 SEND_ERR(NULL, "Lua cli '%s': %s.\n",
8120 fcn->name, lua_tostring(hlua->T, -1));
8121 lua_pop(hlua->T, 1);
8122 return 1;
8123
Thierry Fournierd5b073c2018-05-21 19:42:47 +02008124 case HLUA_E_ETMOUT:
8125 SEND_ERR(NULL, "Lua converter '%s': execution timeout.\n",
8126 fcn->name);
8127 return 1;
8128
8129 case HLUA_E_NOMEM:
8130 SEND_ERR(NULL, "Lua converter '%s': out of memory error.\n",
8131 fcn->name);
8132 return 1;
8133
8134 case HLUA_E_YIELD: /* unexpected */
8135 SEND_ERR(NULL, "Lua converter '%s': yield not allowed.\n",
8136 fcn->name);
8137 return 1;
8138
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008139 case HLUA_E_ERR:
8140 /* Display log. */
8141 SEND_ERR(NULL, "Lua cli '%s' return an unknown error.\n",
8142 fcn->name);
8143 return 1;
8144
8145 default:
8146 return 1;
8147 }
8148
8149 return 1;
8150}
8151
8152static void hlua_cli_io_release_fct(struct appctx *appctx)
8153{
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01008154 hlua_ctx_destroy(appctx->ctx.hlua_cli.hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01008155 appctx->ctx.hlua_cli.hlua = NULL;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008156}
8157
8158/* This function is an LUA binding used for registering
8159 * new keywords in the cli. It expects a list of keywords
8160 * which are the "path". It is limited to 5 keywords. A
8161 * description of the command, a function to be executed
8162 * for the parsing and a function for io handlers.
8163 */
8164__LJMP static int hlua_register_cli(lua_State *L)
8165{
8166 struct cli_kw_list *cli_kws;
8167 const char *message;
8168 int ref_io;
8169 int len;
8170 struct hlua_function *fcn;
8171 int index;
8172 int i;
Thierry Fourniera9230f82020-11-28 20:41:07 +01008173 struct buffer *trash;
8174 const char *kw[5];
8175 struct cli_kw *cli_kw;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008176
8177 MAY_LJMP(check_args(L, 3, "register_cli"));
8178
8179 /* First argument : an array of maximum 5 keywords. */
8180 if (!lua_istable(L, 1))
8181 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table"));
8182
8183 /* Second argument : string with contextual message. */
8184 message = MAY_LJMP(luaL_checkstring(L, 2));
8185
8186 /* Third and fourth argument : lua function. */
8187 ref_io = MAY_LJMP(hlua_checkfunction(L, 3));
8188
Thierry Fourniera9230f82020-11-28 20:41:07 +01008189 /* Check for CLI service already registered */
8190 trash = get_trash_chunk();
8191 index = 0;
8192 lua_pushnil(L);
8193 memset(kw, 0, sizeof(kw));
8194 while (lua_next(L, 1) != 0) {
8195 if (index >= CLI_PREFIX_KW_NB)
8196 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table with a maximum of 5 entries"));
8197 if (lua_type(L, -1) != LUA_TSTRING)
8198 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table filled with strings"));
8199 kw[index] = lua_tostring(L, -1);
8200 if (index == 0)
8201 chunk_printf(trash, "%s", kw[index]);
8202 else
8203 chunk_appendf(trash, " %s", kw[index]);
8204 index++;
8205 lua_pop(L, 1);
8206 }
8207 cli_kw = cli_find_kw_exact((char **)kw);
8208 if (cli_kw != NULL) {
8209 ha_warning("Trying to register CLI keyword 'lua.%s' more than once. "
8210 "This will become a hard error in version 2.5.\n", trash->area);
8211 }
8212
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008213 /* Allocate and fill the sample fetch keyword struct. */
8214 cli_kws = calloc(1, sizeof(*cli_kws) + sizeof(struct cli_kw) * 2);
8215 if (!cli_kws)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008216 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008217 fcn = calloc(1, sizeof(*fcn));
8218 if (!fcn)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008219 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008220
8221 /* Fill path. */
8222 index = 0;
8223 lua_pushnil(L);
8224 while(lua_next(L, 1) != 0) {
8225 if (index >= 5)
8226 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table with a maximum of 5 entries"));
8227 if (lua_type(L, -1) != LUA_TSTRING)
8228 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table filled with strings"));
8229 cli_kws->kw[0].str_kw[index] = strdup(lua_tostring(L, -1));
8230 if (!cli_kws->kw[0].str_kw[index])
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008231 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008232 index++;
8233 lua_pop(L, 1);
8234 }
8235
8236 /* Copy help message. */
8237 cli_kws->kw[0].usage = strdup(message);
8238 if (!cli_kws->kw[0].usage)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008239 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008240
8241 /* Fill fcn io handler. */
8242 len = strlen("<lua.cli>") + 1;
8243 for (i = 0; i < index; i++)
8244 len += strlen(cli_kws->kw[0].str_kw[i]) + 1;
8245 fcn->name = calloc(1, len);
8246 if (!fcn->name)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008247 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008248 strncat((char *)fcn->name, "<lua.cli", len);
8249 for (i = 0; i < index; i++) {
8250 strncat((char *)fcn->name, ".", len);
8251 strncat((char *)fcn->name, cli_kws->kw[0].str_kw[i], len);
8252 }
8253 strncat((char *)fcn->name, ">", len);
8254 fcn->function_ref = ref_io;
8255
8256 /* Fill last entries. */
8257 cli_kws->kw[0].private = fcn;
8258 cli_kws->kw[0].parse = hlua_cli_parse_fct;
8259 cli_kws->kw[0].io_handler = hlua_cli_io_handler_fct;
8260 cli_kws->kw[0].io_release = hlua_cli_io_release_fct;
8261
8262 /* Register this new converter */
8263 cli_register_kw(cli_kws);
8264
8265 return 0;
8266}
8267
Thierry FOURNIERbd413492015-03-03 16:52:26 +01008268static int hlua_read_timeout(char **args, int section_type, struct proxy *curpx,
8269 struct proxy *defpx, const char *file, int line,
8270 char **err, unsigned int *timeout)
8271{
8272 const char *error;
8273
8274 error = parse_time_err(args[1], timeout, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02008275 if (error == PARSE_TIME_OVER) {
8276 memprintf(err, "timer overflow in argument <%s> to <%s> (maximum value is 2147483647 ms or ~24.8 days)",
8277 args[1], args[0]);
8278 return -1;
8279 }
8280 else if (error == PARSE_TIME_UNDER) {
8281 memprintf(err, "timer underflow in argument <%s> to <%s> (minimum non-null value is 1 ms)",
8282 args[1], args[0]);
8283 return -1;
8284 }
8285 else if (error) {
Thierry FOURNIERbd413492015-03-03 16:52:26 +01008286 memprintf(err, "%s: invalid timeout", args[0]);
8287 return -1;
8288 }
8289 return 0;
8290}
8291
8292static int hlua_session_timeout(char **args, int section_type, struct proxy *curpx,
8293 struct proxy *defpx, const char *file, int line,
8294 char **err)
8295{
8296 return hlua_read_timeout(args, section_type, curpx, defpx,
8297 file, line, err, &hlua_timeout_session);
8298}
8299
8300static int hlua_task_timeout(char **args, int section_type, struct proxy *curpx,
8301 struct proxy *defpx, const char *file, int line,
8302 char **err)
8303{
8304 return hlua_read_timeout(args, section_type, curpx, defpx,
8305 file, line, err, &hlua_timeout_task);
8306}
8307
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008308static int hlua_applet_timeout(char **args, int section_type, struct proxy *curpx,
8309 struct proxy *defpx, const char *file, int line,
8310 char **err)
8311{
8312 return hlua_read_timeout(args, section_type, curpx, defpx,
8313 file, line, err, &hlua_timeout_applet);
8314}
8315
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01008316static int hlua_forced_yield(char **args, int section_type, struct proxy *curpx,
8317 struct proxy *defpx, const char *file, int line,
8318 char **err)
8319{
8320 char *error;
8321
8322 hlua_nb_instruction = strtoll(args[1], &error, 10);
8323 if (*error != '\0') {
8324 memprintf(err, "%s: invalid number", args[0]);
8325 return -1;
8326 }
8327 return 0;
8328}
8329
Willy Tarreau32f61e22015-03-18 17:54:59 +01008330static int hlua_parse_maxmem(char **args, int section_type, struct proxy *curpx,
8331 struct proxy *defpx, const char *file, int line,
8332 char **err)
8333{
8334 char *error;
8335
8336 if (*(args[1]) == 0) {
8337 memprintf(err, "'%s' expects an integer argument (Lua memory size in MB).\n", args[0]);
8338 return -1;
8339 }
8340 hlua_global_allocator.limit = strtoll(args[1], &error, 10) * 1024L * 1024L;
8341 if (*error != '\0') {
8342 memprintf(err, "%s: invalid number %s (error at '%c')", args[0], args[1], *error);
8343 return -1;
8344 }
8345 return 0;
8346}
8347
8348
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008349/* This function is called by the main configuration key "lua-load". It loads and
8350 * execute an lua file during the parsing of the HAProxy configuration file. It is
8351 * the main lua entry point.
8352 *
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08008353 * This function runs with the HAProxy keywords API. It returns -1 if an error
8354 * occurs, otherwise it returns 0.
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008355 *
8356 * In some error case, LUA set an error message in top of the stack. This function
8357 * returns this error message in the HAProxy logs and pop it from the stack.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02008358 *
8359 * This function can fail with an abort() due to an Lua critical error.
8360 * We are in the configuration parsing process of HAProxy, this abort() is
8361 * tolerated.
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008362 */
8363static int hlua_load(char **args, int section_type, struct proxy *curpx,
8364 struct proxy *defpx, const char *file, int line,
8365 char **err)
8366{
8367 int error;
8368
Thierry Fourniere6679502020-11-29 01:06:24 +01008369 if (*(args[1]) == 0) {
8370 memprintf(err, "'%s' expects a file name as parameter.\n", args[0]);
8371 return -1;
8372 }
8373
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008374 /* Just load and compile the file. */
8375 error = luaL_loadfile(gL.T, args[1]);
8376 if (error) {
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008377 memprintf(err, "error in Lua file '%s': %s", args[1], lua_tostring(gL.T, -1));
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008378 lua_pop(gL.T, 1);
8379 return -1;
8380 }
8381
8382 /* If no syntax error where detected, execute the code. */
8383 error = lua_pcall(gL.T, 0, LUA_MULTRET, 0);
8384 switch (error) {
8385 case LUA_OK:
8386 break;
8387 case LUA_ERRRUN:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008388 memprintf(err, "Lua runtime error: %s\n", lua_tostring(gL.T, -1));
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008389 lua_pop(gL.T, 1);
8390 return -1;
8391 case LUA_ERRMEM:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008392 memprintf(err, "Lua out of memory error.n");
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008393 return -1;
8394 case LUA_ERRERR:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008395 memprintf(err, "Lua message handler error: %s\n", lua_tostring(gL.T, -1));
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008396 lua_pop(gL.T, 1);
8397 return -1;
Christopher Faulet20699902020-07-28 10:33:25 +02008398#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM <= 503
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008399 case LUA_ERRGCMM:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008400 memprintf(err, "Lua garbage collector error: %s\n", lua_tostring(gL.T, -1));
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008401 lua_pop(gL.T, 1);
8402 return -1;
Christopher Faulet20699902020-07-28 10:33:25 +02008403#endif
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008404 default:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008405 memprintf(err, "Lua unknonwn error: %s\n", lua_tostring(gL.T, -1));
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008406 lua_pop(gL.T, 1);
8407 return -1;
8408 }
8409
8410 return 0;
8411}
8412
8413/* configuration keywords declaration */
8414static struct cfg_kw_list cfg_kws = {{ },{
Thierry FOURNIERbd413492015-03-03 16:52:26 +01008415 { CFG_GLOBAL, "lua-load", hlua_load },
8416 { CFG_GLOBAL, "tune.lua.session-timeout", hlua_session_timeout },
8417 { CFG_GLOBAL, "tune.lua.task-timeout", hlua_task_timeout },
Thierry FOURNIER56da1012015-10-01 08:42:31 +02008418 { CFG_GLOBAL, "tune.lua.service-timeout", hlua_applet_timeout },
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01008419 { CFG_GLOBAL, "tune.lua.forced-yield", hlua_forced_yield },
Willy Tarreau32f61e22015-03-18 17:54:59 +01008420 { CFG_GLOBAL, "tune.lua.maxmem", hlua_parse_maxmem },
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008421 { 0, NULL, NULL },
8422}};
8423
Willy Tarreau0108d902018-11-25 19:14:37 +01008424INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
8425
Christopher Fauletafd8f102018-11-08 11:34:21 +01008426
Thierry FOURNIERbabae282015-09-17 11:36:37 +02008427/* This function can fail with an abort() due to an Lua critical error.
8428 * We are in the initialisation process of HAProxy, this abort() is
8429 * tolerated.
8430 */
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008431int hlua_post_init()
8432{
8433 struct hlua_init_function *init;
8434 const char *msg;
8435 enum hlua_exec ret;
Thierry Fournierfd107a22016-02-19 19:57:23 +01008436 const char *error;
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008437
Thierry Fournier3d4a6752016-02-19 20:53:30 +01008438 /* Call post initialisation function in safe environement. */
8439 if (!SET_SAFE_LJMP(gL.T)) {
8440 if (lua_type(gL.T, -1) == LUA_TSTRING)
8441 error = lua_tostring(gL.T, -1);
8442 else
8443 error = "critical error";
8444 fprintf(stderr, "Lua post-init: %s.\n", error);
8445 exit(1);
8446 }
Frédéric Lécaille54f2bcf2018-08-29 13:46:24 +02008447
8448#if USE_OPENSSL
8449 /* Initialize SSL server. */
8450 if (socket_ssl.xprt->prepare_srv) {
8451 int saved_used_backed = global.ssl_used_backend;
8452 // don't affect maxconn automatic computation
8453 socket_ssl.xprt->prepare_srv(&socket_ssl);
8454 global.ssl_used_backend = saved_used_backed;
8455 }
8456#endif
8457
Thierry Fournier3d4a6752016-02-19 20:53:30 +01008458 hlua_fcn_post_init(gL.T);
8459 RESET_SAFE_LJMP(gL.T);
8460
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008461 list_for_each_entry(init, &hlua_init_functions, l) {
8462 lua_rawgeti(gL.T, LUA_REGISTRYINDEX, init->function_ref);
8463 ret = hlua_ctx_resume(&gL, 0);
8464 switch (ret) {
8465 case HLUA_E_OK:
8466 lua_pop(gL.T, -1);
Thierry Fournier65588c92020-11-28 11:02:58 +01008467 break;
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008468 case HLUA_E_AGAIN:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008469 ha_alert("Lua init: yield not allowed.\n");
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008470 return 0;
8471 case HLUA_E_ERRMSG:
8472 msg = lua_tostring(gL.T, -1);
Christopher Faulet767a84b2017-11-24 16:50:31 +01008473 ha_alert("lua init: %s.\n", msg);
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008474 return 0;
8475 case HLUA_E_ERR:
8476 default:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008477 ha_alert("Lua init: unknown runtime error.\n");
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008478 return 0;
8479 }
8480 }
8481 return 1;
8482}
8483
Willy Tarreau32f61e22015-03-18 17:54:59 +01008484/* The memory allocator used by the Lua stack. <ud> is a pointer to the
8485 * allocator's context. <ptr> is the pointer to alloc/free/realloc. <osize>
8486 * is the previously allocated size or the kind of object in case of a new
8487 * allocation. <nsize> is the requested new size.
8488 */
8489static void *hlua_alloc(void *ud, void *ptr, size_t osize, size_t nsize)
8490{
8491 struct hlua_mem_allocator *zone = ud;
8492
8493 if (nsize == 0) {
8494 /* it's a free */
8495 if (ptr)
8496 zone->allocated -= osize;
8497 free(ptr);
8498 return NULL;
8499 }
8500
8501 if (!ptr) {
8502 /* it's a new allocation */
8503 if (zone->limit && zone->allocated + nsize > zone->limit)
8504 return NULL;
8505
8506 ptr = malloc(nsize);
8507 if (ptr)
8508 zone->allocated += nsize;
8509 return ptr;
8510 }
8511
8512 /* it's a realloc */
8513 if (zone->limit && zone->allocated + nsize - osize > zone->limit)
8514 return NULL;
8515
8516 ptr = realloc(ptr, nsize);
8517 if (ptr)
8518 zone->allocated += nsize - osize;
8519 return ptr;
8520}
8521
Thierry FOURNIERbabae282015-09-17 11:36:37 +02008522/* Ithis function can fail with an abort() due to an Lua critical error.
8523 * We are in the initialisation process of HAProxy, this abort() is
8524 * tolerated.
8525 */
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +01008526void hlua_init(void)
8527{
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008528 int i;
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008529 int idx;
8530 struct sample_fetch *sf;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008531 struct sample_conv *sc;
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008532 char *p;
Thierry Fournierfd107a22016-02-19 19:57:23 +01008533 const char *error_msg;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01008534#ifdef USE_OPENSSL
Willy Tarreau80f5fae2015-02-27 16:38:20 +01008535 struct srv_kw *kw;
8536 int tmp_error;
8537 char *error;
Thierry FOURNIER36d13742015-03-17 16:48:53 +01008538 char *args[] = { /* SSL client configuration. */
8539 "ssl",
8540 "verify",
8541 "none",
Thierry FOURNIER36d13742015-03-17 16:48:53 +01008542 NULL
8543 };
Willy Tarreau80f5fae2015-02-27 16:38:20 +01008544#endif
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008545
Thierry FOURNIER380d0932015-01-23 14:27:52 +01008546 /* Init main lua stack. */
8547 gL.Mref = LUA_REFNIL;
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01008548 gL.flags = 0;
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +01008549 LIST_INIT(&gL.com);
Willy Tarreau42ef75f2017-04-12 21:40:29 +02008550 gL.T = lua_newstate(hlua_alloc, &hlua_global_allocator);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01008551 hlua_sethlua(&gL);
8552 gL.Tref = LUA_REFNIL;
8553 gL.task = NULL;
8554
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08008555 /* From this point, until the end of the initialisation function,
Thierry FOURNIERbabae282015-09-17 11:36:37 +02008556 * the Lua function can fail with an abort. We are in the initialisation
8557 * process of HAProxy, this abort() is tolerated.
8558 */
8559
Thierry Fournier75933d42016-01-21 09:30:18 +01008560 /* Set safe environment for the initialisation. */
8561 if (!SET_SAFE_LJMP(gL.T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01008562 if (lua_type(gL.T, -1) == LUA_TSTRING)
8563 error_msg = lua_tostring(gL.T, -1);
8564 else
8565 error_msg = "critical error";
8566 fprintf(stderr, "Lua init: %s.\n", error_msg);
Thierry Fournier75933d42016-01-21 09:30:18 +01008567 exit(1);
8568 }
8569
Thierry Fourniera5d62582020-11-28 16:08:02 +01008570 /* Initialise lua. */
8571 luaL_openlibs(gL.T);
8572
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008573 /*
8574 *
8575 * Create "core" object.
8576 *
8577 */
8578
Thierry FOURNIERa2d8c652015-03-11 17:29:39 +01008579 /* This table entry is the object "core" base. */
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008580 lua_newtable(gL.T);
8581
8582 /* Push the loglevel constants. */
Willy Tarreau80f5fae2015-02-27 16:38:20 +01008583 for (i = 0; i < NB_LOG_LEVELS; i++)
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008584 hlua_class_const_int(gL.T, log_levels[i], i);
8585
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008586 /* Register special functions. */
8587 hlua_class_function(gL.T, "register_init", hlua_register_init);
Thierry FOURNIER24f33532015-01-23 12:13:00 +01008588 hlua_class_function(gL.T, "register_task", hlua_register_task);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01008589 hlua_class_function(gL.T, "register_fetches", hlua_register_fetches);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01008590 hlua_class_function(gL.T, "register_converters", hlua_register_converters);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02008591 hlua_class_function(gL.T, "register_action", hlua_register_action);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008592 hlua_class_function(gL.T, "register_service", hlua_register_service);
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008593 hlua_class_function(gL.T, "register_cli", hlua_register_cli);
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01008594 hlua_class_function(gL.T, "yield", hlua_yield);
Willy Tarreau59551662015-03-10 14:23:13 +01008595 hlua_class_function(gL.T, "set_nice", hlua_set_nice);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01008596 hlua_class_function(gL.T, "sleep", hlua_sleep);
8597 hlua_class_function(gL.T, "msleep", hlua_msleep);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01008598 hlua_class_function(gL.T, "add_acl", hlua_add_acl);
8599 hlua_class_function(gL.T, "del_acl", hlua_del_acl);
8600 hlua_class_function(gL.T, "set_map", hlua_set_map);
8601 hlua_class_function(gL.T, "del_map", hlua_del_map);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008602 hlua_class_function(gL.T, "tcp", hlua_socket_new);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01008603 hlua_class_function(gL.T, "log", hlua_log);
8604 hlua_class_function(gL.T, "Debug", hlua_log_debug);
8605 hlua_class_function(gL.T, "Info", hlua_log_info);
8606 hlua_class_function(gL.T, "Warning", hlua_log_warning);
8607 hlua_class_function(gL.T, "Alert", hlua_log_alert);
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02008608 hlua_class_function(gL.T, "done", hlua_done);
Thierry Fournierfb0b5462016-01-21 09:28:58 +01008609 hlua_fcn_reg_core_fcn(gL.T);
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008610
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008611 lua_setglobal(gL.T, "core");
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01008612
8613 /*
8614 *
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008615 * Register class Map
8616 *
8617 */
8618
8619 /* This table entry is the object "Map" base. */
8620 lua_newtable(gL.T);
8621
8622 /* register pattern types. */
8623 for (i=0; i<PAT_MATCH_NUM; i++)
8624 hlua_class_const_int(gL.T, pat_match_names[i], i);
Thierry FOURNIER4dc71972017-01-28 08:33:08 +01008625 for (i=0; i<PAT_MATCH_NUM; i++) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008626 snprintf(trash.area, trash.size, "_%s", pat_match_names[i]);
8627 hlua_class_const_int(gL.T, trash.area, i);
Thierry FOURNIER4dc71972017-01-28 08:33:08 +01008628 }
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008629
8630 /* register constructor. */
8631 hlua_class_function(gL.T, "new", hlua_map_new);
8632
8633 /* Create and fill the metatable. */
8634 lua_newtable(gL.T);
8635
8636 /* Create and fille the __index entry. */
8637 lua_pushstring(gL.T, "__index");
8638 lua_newtable(gL.T);
8639
8640 /* Register . */
8641 hlua_class_function(gL.T, "lookup", hlua_map_lookup);
8642 hlua_class_function(gL.T, "slookup", hlua_map_slookup);
8643
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008644 lua_rawset(gL.T, -3);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008645
Thierry Fournier45e78d72016-02-19 18:34:46 +01008646 /* Register previous table in the registry with reference and named entry.
8647 * The function hlua_register_metatable() pops the stack, so we
8648 * previously create a copy of the table.
8649 */
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008650 lua_pushvalue(gL.T, -1); /* Copy the -1 entry and push it on the stack. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008651 class_map_ref = hlua_register_metatable(gL.T, CLASS_MAP);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008652
8653 /* Assign the metatable to the mai Map object. */
8654 lua_setmetatable(gL.T, -2);
8655
8656 /* Set a name to the table. */
8657 lua_setglobal(gL.T, "Map");
8658
8659 /*
8660 *
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008661 * Register class Channel
8662 *
8663 */
8664
8665 /* Create and fill the metatable. */
8666 lua_newtable(gL.T);
8667
8668 /* Create and fille the __index entry. */
8669 lua_pushstring(gL.T, "__index");
8670 lua_newtable(gL.T);
8671
8672 /* Register . */
8673 hlua_class_function(gL.T, "get", hlua_channel_get);
8674 hlua_class_function(gL.T, "dup", hlua_channel_dup);
8675 hlua_class_function(gL.T, "getline", hlua_channel_getline);
8676 hlua_class_function(gL.T, "set", hlua_channel_set);
8677 hlua_class_function(gL.T, "append", hlua_channel_append);
8678 hlua_class_function(gL.T, "send", hlua_channel_send);
8679 hlua_class_function(gL.T, "forward", hlua_channel_forward);
8680 hlua_class_function(gL.T, "get_in_len", hlua_channel_get_in_len);
8681 hlua_class_function(gL.T, "get_out_len", hlua_channel_get_out_len);
Thierry FOURNIER / OZON.IO65192f32016-11-07 15:28:40 +01008682 hlua_class_function(gL.T, "is_full", hlua_channel_is_full);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008683
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008684 lua_rawset(gL.T, -3);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008685
8686 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008687 class_channel_ref = hlua_register_metatable(gL.T, CLASS_CHANNEL);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008688
8689 /*
8690 *
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01008691 * Register class Fetches
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01008692 *
8693 */
8694
8695 /* Create and fill the metatable. */
8696 lua_newtable(gL.T);
8697
8698 /* Create and fille the __index entry. */
8699 lua_pushstring(gL.T, "__index");
8700 lua_newtable(gL.T);
8701
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008702 /* Browse existing fetches and create the associated
8703 * object method.
8704 */
8705 sf = NULL;
8706 while ((sf = sample_fetch_getnext(sf, &idx)) != NULL) {
8707
8708 /* Dont register the keywork if the arguments check function are
8709 * not safe during the runtime.
8710 */
8711 if ((sf->val_args != NULL) &&
8712 (sf->val_args != val_payload_lv) &&
8713 (sf->val_args != val_hdr))
8714 continue;
8715
8716 /* gL.Tua doesn't support '.' and '-' in the function names, replace it
8717 * by an underscore.
8718 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008719 strncpy(trash.area, sf->kw, trash.size);
8720 trash.area[trash.size - 1] = '\0';
8721 for (p = trash.area; *p; p++)
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008722 if (*p == '.' || *p == '-' || *p == '+')
8723 *p = '_';
8724
8725 /* Register the function. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008726 lua_pushstring(gL.T, trash.area);
Willy Tarreau2ec22742015-03-10 14:27:20 +01008727 lua_pushlightuserdata(gL.T, sf);
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008728 lua_pushcclosure(gL.T, hlua_run_sample_fetch, 1);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008729 lua_rawset(gL.T, -3);
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008730 }
8731
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008732 lua_rawset(gL.T, -3);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01008733
8734 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008735 class_fetches_ref = hlua_register_metatable(gL.T, CLASS_FETCHES);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01008736
8737 /*
8738 *
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008739 * Register class Converters
8740 *
8741 */
8742
8743 /* Create and fill the metatable. */
8744 lua_newtable(gL.T);
8745
8746 /* Create and fill the __index entry. */
8747 lua_pushstring(gL.T, "__index");
8748 lua_newtable(gL.T);
8749
8750 /* Browse existing converters and create the associated
8751 * object method.
8752 */
8753 sc = NULL;
8754 while ((sc = sample_conv_getnext(sc, &idx)) != NULL) {
8755 /* Dont register the keywork if the arguments check function are
8756 * not safe during the runtime.
8757 */
8758 if (sc->val_args != NULL)
8759 continue;
8760
8761 /* gL.Tua doesn't support '.' and '-' in the function names, replace it
8762 * by an underscore.
8763 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008764 strncpy(trash.area, sc->kw, trash.size);
8765 trash.area[trash.size - 1] = '\0';
8766 for (p = trash.area; *p; p++)
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008767 if (*p == '.' || *p == '-' || *p == '+')
8768 *p = '_';
8769
8770 /* Register the function. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008771 lua_pushstring(gL.T, trash.area);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008772 lua_pushlightuserdata(gL.T, sc);
8773 lua_pushcclosure(gL.T, hlua_run_sample_conv, 1);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008774 lua_rawset(gL.T, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008775 }
8776
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008777 lua_rawset(gL.T, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008778
8779 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008780 class_converters_ref = hlua_register_metatable(gL.T, CLASS_CONVERTERS);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008781
8782 /*
8783 *
Thierry FOURNIER08504f42015-03-16 14:17:08 +01008784 * Register class HTTP
8785 *
8786 */
8787
8788 /* Create and fill the metatable. */
8789 lua_newtable(gL.T);
8790
8791 /* Create and fille the __index entry. */
8792 lua_pushstring(gL.T, "__index");
8793 lua_newtable(gL.T);
8794
8795 /* Register Lua functions. */
8796 hlua_class_function(gL.T, "req_get_headers",hlua_http_req_get_headers);
8797 hlua_class_function(gL.T, "req_del_header", hlua_http_req_del_hdr);
8798 hlua_class_function(gL.T, "req_rep_header", hlua_http_req_rep_hdr);
8799 hlua_class_function(gL.T, "req_rep_value", hlua_http_req_rep_val);
8800 hlua_class_function(gL.T, "req_add_header", hlua_http_req_add_hdr);
8801 hlua_class_function(gL.T, "req_set_header", hlua_http_req_set_hdr);
8802 hlua_class_function(gL.T, "req_set_method", hlua_http_req_set_meth);
8803 hlua_class_function(gL.T, "req_set_path", hlua_http_req_set_path);
8804 hlua_class_function(gL.T, "req_set_query", hlua_http_req_set_query);
8805 hlua_class_function(gL.T, "req_set_uri", hlua_http_req_set_uri);
8806
8807 hlua_class_function(gL.T, "res_get_headers",hlua_http_res_get_headers);
8808 hlua_class_function(gL.T, "res_del_header", hlua_http_res_del_hdr);
8809 hlua_class_function(gL.T, "res_rep_header", hlua_http_res_rep_hdr);
8810 hlua_class_function(gL.T, "res_rep_value", hlua_http_res_rep_val);
8811 hlua_class_function(gL.T, "res_add_header", hlua_http_res_add_hdr);
8812 hlua_class_function(gL.T, "res_set_header", hlua_http_res_set_hdr);
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02008813 hlua_class_function(gL.T, "res_set_status", hlua_http_res_set_status);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01008814
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008815 lua_rawset(gL.T, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01008816
8817 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008818 class_http_ref = hlua_register_metatable(gL.T, CLASS_HTTP);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01008819
8820 /*
8821 *
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008822 * Register class AppletTCP
8823 *
8824 */
8825
8826 /* Create and fill the metatable. */
8827 lua_newtable(gL.T);
8828
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008829 /* Create and fille the __index entry. */
8830 lua_pushstring(gL.T, "__index");
8831 lua_newtable(gL.T);
8832
8833 /* Register Lua functions. */
Thierry FOURNIER / OZON.IO3e1d7912016-12-12 12:29:34 +01008834 hlua_class_function(gL.T, "getline", hlua_applet_tcp_getline);
8835 hlua_class_function(gL.T, "receive", hlua_applet_tcp_recv);
8836 hlua_class_function(gL.T, "send", hlua_applet_tcp_send);
8837 hlua_class_function(gL.T, "set_priv", hlua_applet_tcp_set_priv);
8838 hlua_class_function(gL.T, "get_priv", hlua_applet_tcp_get_priv);
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01008839 hlua_class_function(gL.T, "set_var", hlua_applet_tcp_set_var);
8840 hlua_class_function(gL.T, "unset_var", hlua_applet_tcp_unset_var);
8841 hlua_class_function(gL.T, "get_var", hlua_applet_tcp_get_var);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008842
8843 lua_settable(gL.T, -3);
8844
8845 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008846 class_applet_tcp_ref = hlua_register_metatable(gL.T, CLASS_APPLET_TCP);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008847
8848 /*
8849 *
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02008850 * Register class AppletHTTP
8851 *
8852 */
8853
8854 /* Create and fill the metatable. */
8855 lua_newtable(gL.T);
8856
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02008857 /* Create and fille the __index entry. */
8858 lua_pushstring(gL.T, "__index");
8859 lua_newtable(gL.T);
8860
8861 /* Register Lua functions. */
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01008862 hlua_class_function(gL.T, "set_priv", hlua_applet_http_set_priv);
8863 hlua_class_function(gL.T, "get_priv", hlua_applet_http_get_priv);
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01008864 hlua_class_function(gL.T, "set_var", hlua_applet_http_set_var);
8865 hlua_class_function(gL.T, "unset_var", hlua_applet_http_unset_var);
8866 hlua_class_function(gL.T, "get_var", hlua_applet_http_get_var);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02008867 hlua_class_function(gL.T, "getline", hlua_applet_http_getline);
8868 hlua_class_function(gL.T, "receive", hlua_applet_http_recv);
8869 hlua_class_function(gL.T, "send", hlua_applet_http_send);
8870 hlua_class_function(gL.T, "add_header", hlua_applet_http_addheader);
8871 hlua_class_function(gL.T, "set_status", hlua_applet_http_status);
8872 hlua_class_function(gL.T, "start_response", hlua_applet_http_start_response);
8873
8874 lua_settable(gL.T, -3);
8875
8876 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008877 class_applet_http_ref = hlua_register_metatable(gL.T, CLASS_APPLET_HTTP);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02008878
8879 /*
8880 *
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01008881 * Register class TXN
8882 *
8883 */
8884
8885 /* Create and fill the metatable. */
8886 lua_newtable(gL.T);
8887
8888 /* Create and fille the __index entry. */
8889 lua_pushstring(gL.T, "__index");
8890 lua_newtable(gL.T);
8891
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01008892 /* Register Lua functions. */
Patrick Hemmer268a7072018-05-11 12:52:31 -04008893 hlua_class_function(gL.T, "set_priv", hlua_set_priv);
8894 hlua_class_function(gL.T, "get_priv", hlua_get_priv);
8895 hlua_class_function(gL.T, "set_var", hlua_set_var);
8896 hlua_class_function(gL.T, "unset_var", hlua_unset_var);
8897 hlua_class_function(gL.T, "get_var", hlua_get_var);
8898 hlua_class_function(gL.T, "done", hlua_txn_done);
8899 hlua_class_function(gL.T, "set_loglevel", hlua_txn_set_loglevel);
8900 hlua_class_function(gL.T, "set_tos", hlua_txn_set_tos);
8901 hlua_class_function(gL.T, "set_mark", hlua_txn_set_mark);
8902 hlua_class_function(gL.T, "set_priority_class", hlua_txn_set_priority_class);
8903 hlua_class_function(gL.T, "set_priority_offset", hlua_txn_set_priority_offset);
8904 hlua_class_function(gL.T, "deflog", hlua_txn_deflog);
8905 hlua_class_function(gL.T, "log", hlua_txn_log);
8906 hlua_class_function(gL.T, "Debug", hlua_txn_log_debug);
8907 hlua_class_function(gL.T, "Info", hlua_txn_log_info);
8908 hlua_class_function(gL.T, "Warning", hlua_txn_log_warning);
8909 hlua_class_function(gL.T, "Alert", hlua_txn_log_alert);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01008910
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008911 lua_rawset(gL.T, -3);
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01008912
8913 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008914 class_txn_ref = hlua_register_metatable(gL.T, CLASS_TXN);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008915
8916 /*
8917 *
8918 * Register class Socket
8919 *
8920 */
8921
8922 /* Create and fill the metatable. */
8923 lua_newtable(gL.T);
8924
8925 /* Create and fille the __index entry. */
8926 lua_pushstring(gL.T, "__index");
8927 lua_newtable(gL.T);
8928
Baptiste Assmann84bb4932015-03-02 21:40:06 +01008929#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008930 hlua_class_function(gL.T, "connect_ssl", hlua_socket_connect_ssl);
Baptiste Assmann84bb4932015-03-02 21:40:06 +01008931#endif
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008932 hlua_class_function(gL.T, "connect", hlua_socket_connect);
8933 hlua_class_function(gL.T, "send", hlua_socket_send);
8934 hlua_class_function(gL.T, "receive", hlua_socket_receive);
8935 hlua_class_function(gL.T, "close", hlua_socket_close);
8936 hlua_class_function(gL.T, "getpeername", hlua_socket_getpeername);
8937 hlua_class_function(gL.T, "getsockname", hlua_socket_getsockname);
8938 hlua_class_function(gL.T, "setoption", hlua_socket_setoption);
8939 hlua_class_function(gL.T, "settimeout", hlua_socket_settimeout);
8940
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008941 lua_rawset(gL.T, -3); /* Push the last 2 entries in the table at index -3 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008942
8943 /* Register the garbage collector entry. */
8944 lua_pushstring(gL.T, "__gc");
8945 lua_pushcclosure(gL.T, hlua_socket_gc, 0);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008946 lua_rawset(gL.T, -3); /* Push the last 2 entries in the table at index -3 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008947
8948 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008949 class_socket_ref = hlua_register_metatable(gL.T, CLASS_SOCKET);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008950
8951 /* Proxy and server configuration initialisation. */
8952 memset(&socket_proxy, 0, sizeof(socket_proxy));
8953 init_new_proxy(&socket_proxy);
8954 socket_proxy.parent = NULL;
8955 socket_proxy.last_change = now.tv_sec;
8956 socket_proxy.id = "LUA-SOCKET";
8957 socket_proxy.cap = PR_CAP_FE | PR_CAP_BE;
8958 socket_proxy.maxconn = 0;
8959 socket_proxy.accept = NULL;
8960 socket_proxy.options2 |= PR_O2_INDEPSTR;
8961 socket_proxy.srv = NULL;
8962 socket_proxy.conn_retries = 0;
8963 socket_proxy.timeout.connect = 5000; /* By default the timeout connection is 5s. */
8964
8965 /* Init TCP server: unchanged parameters */
8966 memset(&socket_tcp, 0, sizeof(socket_tcp));
8967 socket_tcp.next = NULL;
8968 socket_tcp.proxy = &socket_proxy;
8969 socket_tcp.obj_type = OBJ_TYPE_SERVER;
8970 LIST_INIT(&socket_tcp.actconns);
Patrick Hemmer0355dab2018-05-11 12:52:31 -04008971 socket_tcp.pendconns = EB_ROOT;
Christopher Faulet40a007c2017-07-03 15:41:01 +02008972 socket_tcp.priv_conns = NULL;
8973 socket_tcp.idle_conns = NULL;
8974 socket_tcp.safe_conns = NULL;
Emeric Brun52a91d32017-08-31 14:41:55 +02008975 socket_tcp.next_state = SRV_ST_RUNNING; /* early server setup */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008976 socket_tcp.last_change = 0;
8977 socket_tcp.id = "LUA-TCP-CONN";
8978 socket_tcp.check.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
8979 socket_tcp.agent.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
8980 socket_tcp.pp_opts = 0; /* Remove proxy protocol. */
8981
8982 /* XXX: Copy default parameter from default server,
8983 * but the default server is not initialized.
8984 */
8985 socket_tcp.maxqueue = socket_proxy.defsrv.maxqueue;
8986 socket_tcp.minconn = socket_proxy.defsrv.minconn;
8987 socket_tcp.maxconn = socket_proxy.defsrv.maxconn;
8988 socket_tcp.slowstart = socket_proxy.defsrv.slowstart;
8989 socket_tcp.onerror = socket_proxy.defsrv.onerror;
8990 socket_tcp.onmarkeddown = socket_proxy.defsrv.onmarkeddown;
8991 socket_tcp.onmarkedup = socket_proxy.defsrv.onmarkedup;
8992 socket_tcp.consecutive_errors_limit = socket_proxy.defsrv.consecutive_errors_limit;
8993 socket_tcp.uweight = socket_proxy.defsrv.iweight;
8994 socket_tcp.iweight = socket_proxy.defsrv.iweight;
8995
8996 socket_tcp.check.status = HCHK_STATUS_INI;
8997 socket_tcp.check.rise = socket_proxy.defsrv.check.rise;
8998 socket_tcp.check.fall = socket_proxy.defsrv.check.fall;
8999 socket_tcp.check.health = socket_tcp.check.rise; /* socket, but will fall down at first failure */
9000 socket_tcp.check.server = &socket_tcp;
9001
9002 socket_tcp.agent.status = HCHK_STATUS_INI;
9003 socket_tcp.agent.rise = socket_proxy.defsrv.agent.rise;
9004 socket_tcp.agent.fall = socket_proxy.defsrv.agent.fall;
9005 socket_tcp.agent.health = socket_tcp.agent.rise; /* socket, but will fall down at first failure */
9006 socket_tcp.agent.server = &socket_tcp;
9007
Willy Tarreaua261e9b2016-12-22 20:44:00 +01009008 socket_tcp.xprt = xprt_get(XPRT_RAW);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009009
9010#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009011 /* Init TCP server: unchanged parameters */
9012 memset(&socket_ssl, 0, sizeof(socket_ssl));
9013 socket_ssl.next = NULL;
9014 socket_ssl.proxy = &socket_proxy;
9015 socket_ssl.obj_type = OBJ_TYPE_SERVER;
9016 LIST_INIT(&socket_ssl.actconns);
Patrick Hemmer0355dab2018-05-11 12:52:31 -04009017 socket_ssl.pendconns = EB_ROOT;
Willy Tarreaub784b352019-02-07 14:48:24 +01009018 socket_ssl.priv_conns = NULL;
9019 socket_ssl.idle_conns = NULL;
9020 socket_ssl.safe_conns = NULL;
Emeric Brun52a91d32017-08-31 14:41:55 +02009021 socket_ssl.next_state = SRV_ST_RUNNING; /* early server setup */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009022 socket_ssl.last_change = 0;
9023 socket_ssl.id = "LUA-SSL-CONN";
9024 socket_ssl.check.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
9025 socket_ssl.agent.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
9026 socket_ssl.pp_opts = 0; /* Remove proxy protocol. */
9027
9028 /* XXX: Copy default parameter from default server,
9029 * but the default server is not initialized.
9030 */
9031 socket_ssl.maxqueue = socket_proxy.defsrv.maxqueue;
9032 socket_ssl.minconn = socket_proxy.defsrv.minconn;
9033 socket_ssl.maxconn = socket_proxy.defsrv.maxconn;
9034 socket_ssl.slowstart = socket_proxy.defsrv.slowstart;
9035 socket_ssl.onerror = socket_proxy.defsrv.onerror;
9036 socket_ssl.onmarkeddown = socket_proxy.defsrv.onmarkeddown;
9037 socket_ssl.onmarkedup = socket_proxy.defsrv.onmarkedup;
9038 socket_ssl.consecutive_errors_limit = socket_proxy.defsrv.consecutive_errors_limit;
9039 socket_ssl.uweight = socket_proxy.defsrv.iweight;
9040 socket_ssl.iweight = socket_proxy.defsrv.iweight;
9041
9042 socket_ssl.check.status = HCHK_STATUS_INI;
9043 socket_ssl.check.rise = socket_proxy.defsrv.check.rise;
9044 socket_ssl.check.fall = socket_proxy.defsrv.check.fall;
9045 socket_ssl.check.health = socket_ssl.check.rise; /* socket, but will fall down at first failure */
9046 socket_ssl.check.server = &socket_ssl;
9047
9048 socket_ssl.agent.status = HCHK_STATUS_INI;
9049 socket_ssl.agent.rise = socket_proxy.defsrv.agent.rise;
9050 socket_ssl.agent.fall = socket_proxy.defsrv.agent.fall;
9051 socket_ssl.agent.health = socket_ssl.agent.rise; /* socket, but will fall down at first failure */
9052 socket_ssl.agent.server = &socket_ssl;
9053
Thierry FOURNIER36d13742015-03-17 16:48:53 +01009054 socket_ssl.use_ssl = 1;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01009055 socket_ssl.xprt = xprt_get(XPRT_SSL);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009056
Thierry FOURNIER36d13742015-03-17 16:48:53 +01009057 for (idx = 0; args[idx] != NULL; idx++) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009058 if ((kw = srv_find_kw(args[idx])) != NULL) { /* Maybe it's registered server keyword */
9059 /*
9060 *
9061 * If the keyword is not known, we can search in the registered
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08009062 * server keywords. This is useful to configure special SSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009063 * features like client certificates and ssl_verify.
9064 *
9065 */
9066 tmp_error = kw->parse(args, &idx, &socket_proxy, &socket_ssl, &error);
9067 if (tmp_error != 0) {
9068 fprintf(stderr, "INTERNAL ERROR: %s\n", error);
9069 abort(); /* This must be never arrives because the command line
9070 not editable by the user. */
9071 }
9072 idx += kw->skip;
9073 }
9074 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009075#endif
Thierry Fournier75933d42016-01-21 09:30:18 +01009076
9077 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +01009078}
Willy Tarreaubb57d942016-12-21 19:04:56 +01009079
Willy Tarreau80713382018-11-26 10:19:54 +01009080static void hlua_register_build_options(void)
9081{
Willy Tarreaubb57d942016-12-21 19:04:56 +01009082 char *ptr = NULL;
Willy Tarreau80713382018-11-26 10:19:54 +01009083
Willy Tarreaubb57d942016-12-21 19:04:56 +01009084 memprintf(&ptr, "Built with Lua version : %s", LUA_RELEASE);
9085 hap_register_build_opts(ptr, 1);
9086}
Willy Tarreau80713382018-11-26 10:19:54 +01009087
9088INITCALL0(STG_REGISTER, hlua_register_build_options);