blob: d220d6db1c2f7d75fcf641b16c9e3063048debf4 [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
Bertrand Jacquinf4c12d42021-01-21 21:14:07 +000013#define _GNU_SOURCE
14
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +010015#include <ctype.h>
Thierry FOURNIERbabae282015-09-17 11:36:37 +020016#include <setjmp.h>
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +010017
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +010018#include <lauxlib.h>
19#include <lua.h>
20#include <lualib.h>
21
Thierry FOURNIER463119c2015-03-10 00:35:36 +010022#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 503
23#error "Requires Lua 5.3 or later."
Cyril Bontédc0306e2015-03-02 00:08:40 +010024#endif
25
Willy Tarreau8d2b7772020-05-27 10:58:19 +020026#include <import/ebpttree.h>
Thierry FOURNIER380d0932015-01-23 14:27:52 +010027
Willy Tarreaub2551052020-06-09 09:07:15 +020028#include <haproxy/api.h>
29#include <haproxy/applet.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020030#include <haproxy/arg.h>
Christopher Fauletd25d9262020-08-06 11:04:46 +020031#include <haproxy/auth.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020032#include <haproxy/cfgparse.h>
Willy Tarreauf1d32c42020-06-04 21:07:02 +020033#include <haproxy/channel.h>
Willy Tarreau83487a82020-06-04 20:19:54 +020034#include <haproxy/cli.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020035#include <haproxy/connection.h>
Willy Tarreau5413a872020-06-02 19:33:08 +020036#include <haproxy/h1.h>
Willy Tarreau86416052020-06-04 09:20:54 +020037#include <haproxy/hlua.h>
Willy Tarreau8c794002020-06-04 10:05:25 +020038#include <haproxy/hlua_fcn.h>
Willy Tarreauc2b1ff02020-06-04 21:21:03 +020039#include <haproxy/http_ana.h>
Willy Tarreau126ba3a2020-06-04 18:26:43 +020040#include <haproxy/http_fetch.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020041#include <haproxy/http_htx.h>
Willy Tarreauc761f842020-06-04 11:40:28 +020042#include <haproxy/http_rules.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020043#include <haproxy/log.h>
Willy Tarreau2cd58092020-06-04 15:10:43 +020044#include <haproxy/map.h>
Willy Tarreau8efbdfb2020-06-04 11:29:21 +020045#include <haproxy/obj_type.h>
Willy Tarreau225a90a2020-06-04 15:06:28 +020046#include <haproxy/pattern.h>
Willy Tarreau469509b2020-06-04 15:13:30 +020047#include <haproxy/payload.h>
Willy Tarreau3d6ee402021-05-08 20:28:07 +020048#include <haproxy/proxy.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020049#include <haproxy/regex.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020050#include <haproxy/sample.h>
Willy Tarreau198e92a2021-03-05 10:23:32 +010051#include <haproxy/server.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020052#include <haproxy/session.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020053#include <haproxy/stats-t.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020054#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020055#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020056#include <haproxy/task.h>
Willy Tarreau8b550af2020-06-04 17:42:48 +020057#include <haproxy/tcp_rules.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020058#include <haproxy/thread.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020059#include <haproxy/tools.h>
Willy Tarreaua1718922020-06-04 16:25:31 +020060#include <haproxy/vars.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020061#include <haproxy/xref.h>
62
Thierry FOURNIER380d0932015-01-23 14:27:52 +010063
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +010064/* Lua uses longjmp to perform yield or throwing errors. This
65 * macro is used only for identifying the function that can
66 * not return because a longjmp is executed.
67 * __LJMP marks a prototype of hlua file that can use longjmp.
68 * WILL_LJMP() marks an lua function that will use longjmp.
69 * MAY_LJMP() marks an lua function that may use longjmp.
70 */
71#define __LJMP
Willy Tarreau4e7cc332018-10-20 17:45:48 +020072#define WILL_LJMP(func) do { func; my_unreachable(); } while(0)
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +010073#define MAY_LJMP(func) func
74
Thierry FOURNIERbabae282015-09-17 11:36:37 +020075/* This couple of function executes securely some Lua calls outside of
76 * the lua runtime environment. Each Lua call can return a longjmp
77 * if it encounter a memory error.
78 *
79 * Lua documentation extract:
80 *
81 * If an error happens outside any protected environment, Lua calls
82 * a panic function (see lua_atpanic) and then calls abort, thus
83 * exiting the host application. Your panic function can avoid this
84 * exit by never returning (e.g., doing a long jump to your own
85 * recovery point outside Lua).
86 *
87 * The panic function runs as if it were a message handler (see
88 * §2.3); in particular, the error message is at the top of the
89 * stack. However, there is no guarantee about stack space. To push
90 * anything on the stack, the panic function must first check the
91 * available space (see §4.2).
92 *
93 * We must check all the Lua entry point. This includes:
94 * - The include/proto/hlua.h exported functions
95 * - the task wrapper function
96 * - The action wrapper function
97 * - The converters wrapper function
98 * - The sample-fetch wrapper functions
99 *
Ilya Shipitsin46a030c2020-07-05 16:36:08 +0500100 * It is tolerated that the initialisation function returns an abort.
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -0800101 * Before each Lua abort, an error message is written on stderr.
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200102 *
103 * The macro SET_SAFE_LJMP initialise the longjmp. The Macro
104 * RESET_SAFE_LJMP reset the longjmp. These function must be macro
105 * because they must be exists in the program stack when the longjmp
106 * is called.
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +0200107 *
108 * Note that the Lua processing is not really thread safe. It provides
109 * heavy system which consists to add our own lock function in the Lua
110 * code and recompile the library. This system will probably not accepted
111 * by maintainers of various distribs.
112 *
Ilya Shipitsin856aabc2020-04-16 23:51:34 +0500113 * Our main execution point of the Lua is the function lua_resume(). A
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +0200114 * quick looking on the Lua sources displays a lua_lock() a the start
115 * of function and a lua_unlock() at the end of the function. So I
116 * conclude that the Lua thread safe mode just perform a mutex around
117 * all execution. So I prefer to do this in the HAProxy code, it will be
118 * easier for distro maintainers.
119 *
120 * Note that the HAProxy lua functions rounded by the macro SET_SAFE_LJMP
121 * and RESET_SAFE_LJMP manipulates the Lua stack, so it will be careful
122 * to set mutex around these functions.
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200123 */
Willy Tarreau86abe442018-11-25 20:12:18 +0100124__decl_spinlock(hlua_global_lock);
Thierry FOURNIERffbad792017-07-12 11:39:04 +0200125THREAD_LOCAL jmp_buf safe_ljmp_env;
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200126static int hlua_panic_safe(lua_State *L) { return 0; }
Willy Tarreau69c66e32021-07-14 19:41:25 +0200127static int hlua_panic_ljmp(lua_State *L) { WILL_LJMP(longjmp(safe_ljmp_env, 1)); return 0; }
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200128
Thierry Fournier62a22aa2020-11-28 21:06:35 +0100129/* This is the chained list of struct hlua_function referenced
130 * for haproxy action, sample-fetches, converters, cli and
131 * applet bindings. It is used for a post-initialisation control.
132 */
133static struct list referenced_functions = LIST_HEAD_INIT(referenced_functions);
134
Thierry Fournierc7492592020-11-28 23:57:24 +0100135/* This variable is used only during initialization to identify the Lua state
136 * currently being initialized. 0 is the common lua state, 1 to n are the Lua
137 * states dedicated to each thread (in this case hlua_state_id==tid+1).
138 */
139static int hlua_state_id;
140
Thierry Fournier59f11be2020-11-29 00:37:41 +0100141/* This is a NULL-terminated list of lua file which are referenced to load per thread */
142static char **per_thread_load = NULL;
143
144lua_State *hlua_init_state(int thread_id);
145
Willy Tarreau3eb2e472021-08-20 15:47:25 +0200146/* This function takes the Lua global lock. Keep this function's visibility
147 * global so that it can appear in stack dumps and performance profiles!
148 */
149void lua_take_global_lock()
150{
151 HA_SPIN_LOCK(LUA_LOCK, &hlua_global_lock);
152}
153
154static inline void lua_drop_global_lock()
155{
156 HA_SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock);
157}
158
Thierry Fournier7cbe5042020-11-28 17:02:21 +0100159#define SET_SAFE_LJMP_L(__L, __HLUA) \
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200160 ({ \
161 int ret; \
Thierry Fournier021d9862020-11-28 23:42:03 +0100162 if ((__HLUA)->state_id == 0) \
Willy Tarreau3eb2e472021-08-20 15:47:25 +0200163 lua_take_global_lock(); \
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200164 if (setjmp(safe_ljmp_env) != 0) { \
165 lua_atpanic(__L, hlua_panic_safe); \
166 ret = 0; \
Thierry Fournier021d9862020-11-28 23:42:03 +0100167 if ((__HLUA)->state_id == 0) \
Willy Tarreau3eb2e472021-08-20 15:47:25 +0200168 lua_drop_global_lock(); \
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200169 } else { \
170 lua_atpanic(__L, hlua_panic_ljmp); \
171 ret = 1; \
172 } \
173 ret; \
174 })
175
176/* If we are the last function catching Lua errors, we
177 * must reset the panic function.
178 */
Thierry Fournier7cbe5042020-11-28 17:02:21 +0100179#define RESET_SAFE_LJMP_L(__L, __HLUA) \
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200180 do { \
181 lua_atpanic(__L, hlua_panic_safe); \
Thierry Fournier021d9862020-11-28 23:42:03 +0100182 if ((__HLUA)->state_id == 0) \
Willy Tarreau3eb2e472021-08-20 15:47:25 +0200183 lua_drop_global_lock(); \
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200184 } while(0)
185
Thierry Fournier7cbe5042020-11-28 17:02:21 +0100186#define SET_SAFE_LJMP(__HLUA) \
187 SET_SAFE_LJMP_L((__HLUA)->T, __HLUA)
188
189#define RESET_SAFE_LJMP(__HLUA) \
190 RESET_SAFE_LJMP_L((__HLUA)->T, __HLUA)
191
192#define SET_SAFE_LJMP_PARENT(__HLUA) \
Thierry Fournier021d9862020-11-28 23:42:03 +0100193 SET_SAFE_LJMP_L(hlua_states[(__HLUA)->state_id], __HLUA)
Thierry Fournier7cbe5042020-11-28 17:02:21 +0100194
195#define RESET_SAFE_LJMP_PARENT(__HLUA) \
Thierry Fournier021d9862020-11-28 23:42:03 +0100196 RESET_SAFE_LJMP_L(hlua_states[(__HLUA)->state_id], __HLUA)
Thierry Fournier7cbe5042020-11-28 17:02:21 +0100197
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200198/* Applet status flags */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200199#define APPLET_DONE 0x01 /* applet processing is done. */
Christopher Faulet18c2e8d2019-03-01 12:02:08 +0100200/* unused: 0x02 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200201#define APPLET_HDR_SENT 0x04 /* Response header sent. */
Christopher Fauleta2097962019-07-15 16:25:33 +0200202/* unused: 0x08, 0x10 */
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +0100203#define APPLET_HTTP11 0x20 /* Last chunk sent. */
Christopher Faulet56a3d6e2019-02-27 22:06:23 +0100204#define APPLET_RSP_SENT 0x40 /* The response was fully sent */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200205
Thierry Fournierafc63e22020-11-28 17:06:51 +0100206/* The main Lua execution context. The 0 index is the
207 * common state shared by all threads.
208 */
Willy Tarreau186f3762020-12-04 11:48:12 +0100209static lua_State *hlua_states[MAX_THREADS + 1];
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100210
Thierry FOURNIERebed6e92016-12-16 11:54:07 +0100211/* This is the memory pool containing struct lua for applets
212 * (including cli).
213 */
Willy Tarreau8ceae722018-11-26 11:58:30 +0100214DECLARE_STATIC_POOL(pool_head_hlua, "hlua", sizeof(struct hlua));
Thierry FOURNIERebed6e92016-12-16 11:54:07 +0100215
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +0100216/* Used for Socket connection. */
Amaury Denoyelle239fdbf2021-03-24 10:22:03 +0100217static struct proxy *socket_proxy;
Amaury Denoyelle704ba1d2021-03-24 17:57:47 +0100218static struct server *socket_tcp;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +0100219#ifdef USE_OPENSSL
Amaury Denoyelle704ba1d2021-03-24 17:57:47 +0100220static struct server *socket_ssl;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +0100221#endif
222
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +0100223/* List head of the function called at the initialisation time. */
Thierry Fournierc7492592020-11-28 23:57:24 +0100224struct list hlua_init_functions[MAX_THREADS + 1];
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +0100225
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +0100226/* The following variables contains the reference of the different
227 * Lua classes. These references are useful for identify metadata
228 * associated with an object.
229 */
Thierry FOURNIER65f34c62015-02-16 20:11:43 +0100230static int class_txn_ref;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +0100231static int class_socket_ref;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +0100232static int class_channel_ref;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +0100233static int class_fetches_ref;
Thierry FOURNIER594afe72015-03-10 23:58:30 +0100234static int class_converters_ref;
Thierry FOURNIER08504f42015-03-16 14:17:08 +0100235static int class_http_ref;
Thierry FOURNIER3def3932015-04-07 11:27:54 +0200236static int class_map_ref;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200237static int class_applet_tcp_ref;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200238static int class_applet_http_ref;
Christopher Faulet700d9e82020-01-31 12:21:52 +0100239static int class_txn_reply_ref;
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +0100240
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100241/* Global Lua execution timeout. By default Lua, execution linked
Willy Tarreau87b09662015-04-03 00:22:06 +0200242 * with stream (actions, sample-fetches and converters) have a
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100243 * short timeout. Lua linked with tasks doesn't have a timeout
244 * because a task may remain alive during all the haproxy execution.
245 */
246static unsigned int hlua_timeout_session = 4000; /* session timeout. */
247static unsigned int hlua_timeout_task = TICK_ETERNITY; /* task timeout. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200248static unsigned int hlua_timeout_applet = 4000; /* applet timeout. */
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100249
Thierry FOURNIERee9f8022015-03-03 17:37:37 +0100250/* Interrupts the Lua processing each "hlua_nb_instruction" instructions.
251 * it is used for preventing infinite loops.
252 *
253 * I test the scheer with an infinite loop containing one incrementation
254 * and one test. I run this loop between 10 seconds, I raise a ceil of
255 * 710M loops from one interrupt each 9000 instructions, so I fix the value
256 * to one interrupt each 10 000 instructions.
257 *
258 * configured | Number of
259 * instructions | loops executed
260 * between two | in milions
261 * forced yields |
262 * ---------------+---------------
263 * 10 | 160
264 * 500 | 670
265 * 1000 | 680
266 * 5000 | 700
267 * 7000 | 700
268 * 8000 | 700
269 * 9000 | 710 <- ceil
270 * 10000 | 710
271 * 100000 | 710
272 * 1000000 | 710
273 *
274 */
275static unsigned int hlua_nb_instruction = 10000;
276
Willy Tarreaucdb53462020-12-02 12:12:00 +0100277/* Descriptor for the memory allocation state. The limit is pre-initialised to
278 * 0 until it is replaced by "tune.lua.maxmem" during the config parsing, or it
279 * is replaced with ~0 during post_init after everything was loaded. This way
280 * it is guaranteed that if limit is ~0 the boot is complete and that if it's
281 * zero it's not yet limited and proper accounting is required.
Willy Tarreau32f61e22015-03-18 17:54:59 +0100282 */
283struct hlua_mem_allocator {
284 size_t allocated;
285 size_t limit;
286};
287
Willy Tarreaucdb53462020-12-02 12:12:00 +0100288static struct hlua_mem_allocator hlua_global_allocator THREAD_ALIGNED(64);
Willy Tarreau32f61e22015-03-18 17:54:59 +0100289
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100290/* These functions converts types between HAProxy internal args or
291 * sample and LUA types. Another function permits to check if the
292 * LUA stack contains arguments according with an required ARG_T
293 * format.
294 */
295static int hlua_arg2lua(lua_State *L, const struct arg *arg);
296static int hlua_lua2arg(lua_State *L, int ud, struct arg *arg);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100297__LJMP static int hlua_lua2arg_check(lua_State *L, int first, struct arg *argp,
David Carlier0c437f42016-04-27 16:21:56 +0100298 uint64_t mask, struct proxy *p);
Willy Tarreau5eadada2015-03-10 17:28:54 +0100299static int hlua_smp2lua(lua_State *L, struct sample *smp);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100300static int hlua_smp2lua_str(lua_State *L, struct sample *smp);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100301static int hlua_lua2smp(lua_State *L, int ud, struct sample *smp);
302
Christopher Faulet9d1332b2020-02-24 16:46:16 +0100303__LJMP static int hlua_http_get_headers(lua_State *L, struct http_msg *msg);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200304
Thierry Fournier59f11be2020-11-29 00:37:41 +0100305struct prepend_path {
306 struct list l;
307 char *type;
308 char *path;
309};
310
311static struct list prepend_path_list = LIST_HEAD_INIT(prepend_path_list);
312
Thierry FOURNIER23bc3752015-09-11 19:15:43 +0200313#define SEND_ERR(__be, __fmt, __args...) \
314 do { \
315 send_log(__be, LOG_ERR, __fmt, ## __args); \
316 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) \
Christopher Faulet767a84b2017-11-24 16:50:31 +0100317 ha_alert(__fmt, ## __args); \
Thierry FOURNIER23bc3752015-09-11 19:15:43 +0200318 } while (0)
319
Thierry Fournier62a22aa2020-11-28 21:06:35 +0100320static inline struct hlua_function *new_hlua_function()
321{
322 struct hlua_function *fcn;
Thierry Fournierc7492592020-11-28 23:57:24 +0100323 int i;
Thierry Fournier62a22aa2020-11-28 21:06:35 +0100324
325 fcn = calloc(1, sizeof(*fcn));
326 if (!fcn)
327 return NULL;
Willy Tarreau2b718102021-04-21 07:32:39 +0200328 LIST_APPEND(&referenced_functions, &fcn->l);
Thierry Fournierc7492592020-11-28 23:57:24 +0100329 for (i = 0; i < MAX_THREADS + 1; i++)
330 fcn->function_ref[i] = -1;
Thierry Fournier62a22aa2020-11-28 21:06:35 +0100331 return fcn;
332}
333
Christopher Fauletdda44442021-04-12 14:05:43 +0200334static inline void release_hlua_function(struct hlua_function *fcn)
335{
336 if (!fcn)
337 return;
338 if (fcn->name)
339 ha_free(&fcn->name);
Willy Tarreau2b718102021-04-21 07:32:39 +0200340 LIST_DELETE(&fcn->l);
Christopher Fauletdda44442021-04-12 14:05:43 +0200341 ha_free(&fcn);
342}
343
Thierry Fournierc7492592020-11-28 23:57:24 +0100344/* If the common state is set, the stack id is 0, otherwise it is the tid + 1 */
345static inline int fcn_ref_to_stack_id(struct hlua_function *fcn)
346{
347 if (fcn->function_ref[0] == -1)
348 return tid + 1;
349 return 0;
350}
351
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100352/* Used to check an Lua function type in the stack. It creates and
353 * returns a reference of the function. This function throws an
354 * error if the rgument is not a "function".
355 */
356__LJMP unsigned int hlua_checkfunction(lua_State *L, int argno)
357{
358 if (!lua_isfunction(L, argno)) {
Thierry FOURNIERfd1e9552018-02-23 18:41:18 +0100359 const char *msg = lua_pushfstring(L, "function expected, got %s", luaL_typename(L, argno));
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100360 WILL_LJMP(luaL_argerror(L, argno, msg));
361 }
362 lua_pushvalue(L, argno);
363 return luaL_ref(L, LUA_REGISTRYINDEX);
364}
365
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200366/* Return the string that is of the top of the stack. */
367const char *hlua_get_top_error_string(lua_State *L)
368{
369 if (lua_gettop(L) < 1)
370 return "unknown error";
371 if (lua_type(L, -1) != LUA_TSTRING)
372 return "unknown error";
373 return lua_tostring(L, -1);
374}
375
Christopher Fauletd09cc512021-03-24 14:48:45 +0100376__LJMP const char *hlua_traceback(lua_State *L, const char* sep)
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200377{
378 lua_Debug ar;
379 int level = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +0200380 struct buffer *msg = get_trash_chunk();
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200381
382 while (lua_getstack(L, level++, &ar)) {
383
384 /* Add separator */
Christopher Fauletd09cc512021-03-24 14:48:45 +0100385 if (b_data(msg))
386 chunk_appendf(msg, "%s", sep);
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200387
388 /* Fill fields:
389 * 'S': fills in the fields source, short_src, linedefined, lastlinedefined, and what;
390 * 'l': fills in the field currentline;
391 * 'n': fills in the field name and namewhat;
392 * 't': fills in the field istailcall;
393 */
394 lua_getinfo(L, "Slnt", &ar);
395
396 /* Append code localisation */
397 if (ar.currentline > 0)
Christopher Fauletd09cc512021-03-24 14:48:45 +0100398 chunk_appendf(msg, "%s:%d: ", ar.short_src, ar.currentline);
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200399 else
Christopher Fauletd09cc512021-03-24 14:48:45 +0100400 chunk_appendf(msg, "%s: ", ar.short_src);
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200401
402 /*
403 * Get function name
404 *
405 * if namewhat is no empty, name is defined.
406 * what contains "Lua" for Lua function, "C" for C function,
407 * or "main" for main code.
408 */
409 if (*ar.namewhat != '\0' && ar.name != NULL) /* is there a name from code? */
Christopher Fauletd09cc512021-03-24 14:48:45 +0100410 chunk_appendf(msg, "in %s '%s'", ar.namewhat, ar.name); /* use it */
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200411
412 else if (*ar.what == 'm') /* "main", the code is not executed in a function */
Christopher Fauletd09cc512021-03-24 14:48:45 +0100413 chunk_appendf(msg, "in main chunk");
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200414
415 else if (*ar.what != 'C') /* for Lua functions, use <file:line> */
Christopher Fauletd09cc512021-03-24 14:48:45 +0100416 chunk_appendf(msg, "in function line %d", ar.linedefined);
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200417
418 else /* nothing left... */
419 chunk_appendf(msg, "?");
420
421
422 /* Display tailed call */
423 if (ar.istailcall)
424 chunk_appendf(msg, " ...");
425 }
426
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200427 return msg->area;
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200428}
429
430
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100431/* This function check the number of arguments available in the
432 * stack. If the number of arguments available is not the same
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500433 * then <nb> an error is thrown.
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100434 */
435__LJMP static inline void check_args(lua_State *L, int nb, char *fcn)
436{
437 if (lua_gettop(L) == nb)
438 return;
439 WILL_LJMP(luaL_error(L, "'%s' needs %d arguments", fcn, nb));
440}
441
Mark Lakes22154b42018-01-29 14:38:40 -0800442/* This function pushes an error string prefixed by the file name
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100443 * and the line number where the error is encountered.
444 */
445static int hlua_pusherror(lua_State *L, const char *fmt, ...)
446{
447 va_list argp;
448 va_start(argp, fmt);
449 luaL_where(L, 1);
450 lua_pushvfstring(L, fmt, argp);
451 va_end(argp);
452 lua_concat(L, 2);
453 return 1;
454}
455
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100456/* This functions is used with sample fetch and converters. It
457 * converts the HAProxy configuration argument in a lua stack
458 * values.
459 *
460 * It takes an array of "arg", and each entry of the array is
461 * converted and pushed in the LUA stack.
462 */
463static int hlua_arg2lua(lua_State *L, const struct arg *arg)
464{
465 switch (arg->type) {
466 case ARGT_SINT:
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100467 case ARGT_TIME:
468 case ARGT_SIZE:
Thierry FOURNIERf90838b2015-03-06 13:48:32 +0100469 lua_pushinteger(L, arg->data.sint);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100470 break;
471
472 case ARGT_STR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200473 lua_pushlstring(L, arg->data.str.area, arg->data.str.data);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100474 break;
475
476 case ARGT_IPV4:
477 case ARGT_IPV6:
478 case ARGT_MSK4:
479 case ARGT_MSK6:
480 case ARGT_FE:
481 case ARGT_BE:
482 case ARGT_TAB:
483 case ARGT_SRV:
484 case ARGT_USR:
485 case ARGT_MAP:
486 default:
487 lua_pushnil(L);
488 break;
489 }
490 return 1;
491}
492
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500493/* This function take one entry in an LUA stack at the index "ud",
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100494 * and try to convert it in an HAProxy argument entry. This is useful
Ilya Shipitsind4259502020-04-08 01:07:56 +0500495 * with sample fetch wrappers. The input arguments are given to the
496 * lua wrapper and converted as arg list by the function.
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100497 */
498static int hlua_lua2arg(lua_State *L, int ud, struct arg *arg)
499{
500 switch (lua_type(L, ud)) {
501
502 case LUA_TNUMBER:
503 case LUA_TBOOLEAN:
504 arg->type = ARGT_SINT;
505 arg->data.sint = lua_tointeger(L, ud);
506 break;
507
508 case LUA_TSTRING:
509 arg->type = ARGT_STR;
Tim Duesterhus2e89dec2019-09-29 23:03:08 +0200510 arg->data.str.area = (char *)lua_tolstring(L, ud, &arg->data.str.data);
Tim Duesterhus29d2e8a2019-09-29 23:03:07 +0200511 /* We don't know the actual size of the underlying allocation, so be conservative. */
Christopher Fauletfdea1b62020-08-06 08:29:18 +0200512 arg->data.str.size = arg->data.str.data+1; /* count the terminating null byte */
Tim Duesterhus29d2e8a2019-09-29 23:03:07 +0200513 arg->data.str.head = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100514 break;
515
516 case LUA_TUSERDATA:
517 case LUA_TNIL:
518 case LUA_TTABLE:
519 case LUA_TFUNCTION:
520 case LUA_TTHREAD:
521 case LUA_TLIGHTUSERDATA:
522 arg->type = ARGT_SINT;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +0200523 arg->data.sint = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100524 break;
525 }
526 return 1;
527}
528
529/* the following functions are used to convert a struct sample
530 * in Lua type. This useful to convert the return of the
Ilya Shipitsind4259502020-04-08 01:07:56 +0500531 * fetches or converters.
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100532 */
Willy Tarreau5eadada2015-03-10 17:28:54 +0100533static int hlua_smp2lua(lua_State *L, struct sample *smp)
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100534{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200535 switch (smp->data.type) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100536 case SMP_T_SINT:
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100537 case SMP_T_BOOL:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200538 lua_pushinteger(L, smp->data.u.sint);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100539 break;
540
541 case SMP_T_BIN:
542 case SMP_T_STR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200543 lua_pushlstring(L, smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100544 break;
545
546 case SMP_T_METH:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200547 switch (smp->data.u.meth.meth) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100548 case HTTP_METH_OPTIONS: lua_pushstring(L, "OPTIONS"); break;
549 case HTTP_METH_GET: lua_pushstring(L, "GET"); break;
550 case HTTP_METH_HEAD: lua_pushstring(L, "HEAD"); break;
551 case HTTP_METH_POST: lua_pushstring(L, "POST"); break;
552 case HTTP_METH_PUT: lua_pushstring(L, "PUT"); break;
553 case HTTP_METH_DELETE: lua_pushstring(L, "DELETE"); break;
554 case HTTP_METH_TRACE: lua_pushstring(L, "TRACE"); break;
555 case HTTP_METH_CONNECT: lua_pushstring(L, "CONNECT"); break;
556 case HTTP_METH_OTHER:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200557 lua_pushlstring(L, smp->data.u.meth.str.area, smp->data.u.meth.str.data);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100558 break;
559 default:
560 lua_pushnil(L);
561 break;
562 }
563 break;
564
565 case SMP_T_IPV4:
566 case SMP_T_IPV6:
567 case SMP_T_ADDR: /* This type is never used to qualify a sample. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200568 if (sample_casts[smp->data.type][SMP_T_STR] &&
569 sample_casts[smp->data.type][SMP_T_STR](smp))
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200570 lua_pushlstring(L, smp->data.u.str.area, smp->data.u.str.data);
Willy Tarreau5eadada2015-03-10 17:28:54 +0100571 else
572 lua_pushnil(L);
573 break;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100574 default:
575 lua_pushnil(L);
576 break;
577 }
578 return 1;
579}
580
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100581/* the following functions are used to convert a struct sample
582 * in Lua strings. This is useful to convert the return of the
Ilya Shipitsind4259502020-04-08 01:07:56 +0500583 * fetches or converters.
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100584 */
585static int hlua_smp2lua_str(lua_State *L, struct sample *smp)
586{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200587 switch (smp->data.type) {
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100588
589 case SMP_T_BIN:
590 case SMP_T_STR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200591 lua_pushlstring(L, smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100592 break;
593
594 case SMP_T_METH:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200595 switch (smp->data.u.meth.meth) {
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100596 case HTTP_METH_OPTIONS: lua_pushstring(L, "OPTIONS"); break;
597 case HTTP_METH_GET: lua_pushstring(L, "GET"); break;
598 case HTTP_METH_HEAD: lua_pushstring(L, "HEAD"); break;
599 case HTTP_METH_POST: lua_pushstring(L, "POST"); break;
600 case HTTP_METH_PUT: lua_pushstring(L, "PUT"); break;
601 case HTTP_METH_DELETE: lua_pushstring(L, "DELETE"); break;
602 case HTTP_METH_TRACE: lua_pushstring(L, "TRACE"); break;
603 case HTTP_METH_CONNECT: lua_pushstring(L, "CONNECT"); break;
604 case HTTP_METH_OTHER:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200605 lua_pushlstring(L, smp->data.u.meth.str.area, smp->data.u.meth.str.data);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100606 break;
607 default:
608 lua_pushstring(L, "");
609 break;
610 }
611 break;
612
613 case SMP_T_SINT:
614 case SMP_T_BOOL:
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100615 case SMP_T_IPV4:
616 case SMP_T_IPV6:
617 case SMP_T_ADDR: /* This type is never used to qualify a sample. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200618 if (sample_casts[smp->data.type][SMP_T_STR] &&
619 sample_casts[smp->data.type][SMP_T_STR](smp))
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200620 lua_pushlstring(L, smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100621 else
622 lua_pushstring(L, "");
623 break;
624 default:
625 lua_pushstring(L, "");
626 break;
627 }
628 return 1;
629}
630
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100631/* the following functions are used to convert an Lua type in a
632 * struct sample. This is useful to provide data from a converter
633 * to the LUA code.
634 */
635static int hlua_lua2smp(lua_State *L, int ud, struct sample *smp)
636{
637 switch (lua_type(L, ud)) {
638
639 case LUA_TNUMBER:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200640 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200641 smp->data.u.sint = lua_tointeger(L, ud);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100642 break;
643
644
645 case LUA_TBOOLEAN:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200646 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200647 smp->data.u.sint = lua_toboolean(L, ud);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100648 break;
649
650 case LUA_TSTRING:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200651 smp->data.type = SMP_T_STR;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100652 smp->flags |= SMP_F_CONST;
Tim Duesterhus2e89dec2019-09-29 23:03:08 +0200653 smp->data.u.str.area = (char *)lua_tolstring(L, ud, &smp->data.u.str.data);
Tim Duesterhus29d2e8a2019-09-29 23:03:07 +0200654 /* We don't know the actual size of the underlying allocation, so be conservative. */
Christopher Fauletfdea1b62020-08-06 08:29:18 +0200655 smp->data.u.str.size = smp->data.u.str.data+1; /* count the terminating null byte */
Tim Duesterhus29d2e8a2019-09-29 23:03:07 +0200656 smp->data.u.str.head = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100657 break;
658
659 case LUA_TUSERDATA:
660 case LUA_TNIL:
661 case LUA_TTABLE:
662 case LUA_TFUNCTION:
663 case LUA_TTHREAD:
664 case LUA_TLIGHTUSERDATA:
Thierry FOURNIER93405e12015-08-26 14:19:03 +0200665 case LUA_TNONE:
666 default:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200667 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200668 smp->data.u.sint = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100669 break;
670 }
671 return 1;
672}
673
Ilya Shipitsind4259502020-04-08 01:07:56 +0500674/* This function check the "argp" built by another conversion function
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -0800675 * is in accord with the expected argp defined by the "mask". The function
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100676 * returns true or false. It can be adjust the types if there compatibles.
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100677 *
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500678 * This function assumes that the argp argument contains ARGM_NBARGS + 1
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100679 * entries.
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100680 */
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100681__LJMP int hlua_lua2arg_check(lua_State *L, int first, struct arg *argp,
David Carlier0c437f42016-04-27 16:21:56 +0100682 uint64_t mask, struct proxy *p)
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100683{
684 int min_arg;
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200685 int i, idx;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100686 struct proxy *px;
Christopher Fauletd25d9262020-08-06 11:04:46 +0200687 struct userlist *ul;
Christopher Fauletfd2e9062020-08-06 11:10:57 +0200688 struct my_regex *reg;
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200689 const char *msg = NULL;
Christopher Fauletfd2e9062020-08-06 11:10:57 +0200690 char *sname, *pname, *err = NULL;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100691
692 idx = 0;
693 min_arg = ARGM(mask);
694 mask >>= ARGM_BITS;
695
696 while (1) {
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200697 struct buffer tmp = BUF_NULL;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100698
699 /* Check oversize. */
700 if (idx >= ARGM_NBARGS && argp[idx].type != ARGT_STOP) {
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200701 msg = "Malformed argument mask";
702 goto error;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100703 }
704
705 /* Check for mandatory arguments. */
706 if (argp[idx].type == ARGT_STOP) {
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100707 if (idx < min_arg) {
708
709 /* If miss other argument than the first one, we return an error. */
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200710 if (idx > 0) {
711 msg = "Mandatory argument expected";
712 goto error;
713 }
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100714
715 /* If first argument have a certain type, some default values
716 * may be used. See the function smp_resolve_args().
717 */
718 switch (mask & ARGT_MASK) {
719
720 case ARGT_FE:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200721 if (!(p->cap & PR_CAP_FE)) {
722 msg = "Mandatory argument expected";
723 goto error;
724 }
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100725 argp[idx].data.prx = p;
726 argp[idx].type = ARGT_FE;
727 argp[idx+1].type = ARGT_STOP;
728 break;
729
730 case ARGT_BE:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200731 if (!(p->cap & PR_CAP_BE)) {
732 msg = "Mandatory argument expected";
733 goto error;
734 }
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100735 argp[idx].data.prx = p;
736 argp[idx].type = ARGT_BE;
737 argp[idx+1].type = ARGT_STOP;
738 break;
739
740 case ARGT_TAB:
741 argp[idx].data.prx = p;
742 argp[idx].type = ARGT_TAB;
743 argp[idx+1].type = ARGT_STOP;
744 break;
745
746 default:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200747 msg = "Mandatory argument expected";
748 goto error;
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100749 break;
750 }
751 }
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200752 break;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100753 }
754
Ilya Shipitsin856aabc2020-04-16 23:51:34 +0500755 /* Check for exceed the number of required argument. */
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100756 if ((mask & ARGT_MASK) == ARGT_STOP &&
757 argp[idx].type != ARGT_STOP) {
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200758 msg = "Last argument expected";
759 goto error;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100760 }
761
762 if ((mask & ARGT_MASK) == ARGT_STOP &&
763 argp[idx].type == ARGT_STOP) {
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200764 break;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100765 }
766
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200767 /* Convert some argument types. All string in argp[] are for not
768 * duplicated yet.
769 */
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100770 switch (mask & ARGT_MASK) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100771 case ARGT_SINT:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200772 if (argp[idx].type != ARGT_SINT) {
773 msg = "integer expected";
774 goto error;
775 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100776 argp[idx].type = ARGT_SINT;
777 break;
778
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100779 case ARGT_TIME:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200780 if (argp[idx].type != ARGT_SINT) {
781 msg = "integer expected";
782 goto error;
783 }
Thierry FOURNIER29176f32015-07-07 00:41:29 +0200784 argp[idx].type = ARGT_TIME;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100785 break;
786
787 case ARGT_SIZE:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200788 if (argp[idx].type != ARGT_SINT) {
789 msg = "integer expected";
790 goto error;
791 }
Thierry FOURNIER29176f32015-07-07 00:41:29 +0200792 argp[idx].type = ARGT_SIZE;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100793 break;
794
795 case ARGT_FE:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200796 if (argp[idx].type != ARGT_STR) {
797 msg = "string expected";
798 goto error;
799 }
Christopher Fauletfdea1b62020-08-06 08:29:18 +0200800 argp[idx].data.prx = proxy_fe_by_name(argp[idx].data.str.area);
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200801 if (!argp[idx].data.prx) {
802 msg = "frontend doesn't exist";
803 goto error;
804 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100805 argp[idx].type = ARGT_FE;
806 break;
807
808 case ARGT_BE:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200809 if (argp[idx].type != ARGT_STR) {
810 msg = "string expected";
811 goto error;
812 }
Christopher Fauletfdea1b62020-08-06 08:29:18 +0200813 argp[idx].data.prx = proxy_be_by_name(argp[idx].data.str.area);
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200814 if (!argp[idx].data.prx) {
815 msg = "backend doesn't exist";
816 goto error;
817 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100818 argp[idx].type = ARGT_BE;
819 break;
820
821 case ARGT_TAB:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200822 if (argp[idx].type != ARGT_STR) {
823 msg = "string expected";
824 goto error;
825 }
Christopher Fauletfdea1b62020-08-06 08:29:18 +0200826 argp[idx].data.t = stktable_find_by_name(argp[idx].data.str.area);
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200827 if (!argp[idx].data.t) {
828 msg = "table doesn't exist";
829 goto error;
830 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100831 argp[idx].type = ARGT_TAB;
832 break;
833
834 case ARGT_SRV:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200835 if (argp[idx].type != ARGT_STR) {
836 msg = "string expected";
837 goto error;
838 }
Christopher Fauletfdea1b62020-08-06 08:29:18 +0200839 sname = strrchr(argp[idx].data.str.area, '/');
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100840 if (sname) {
841 *sname++ = '\0';
Christopher Fauletfdea1b62020-08-06 08:29:18 +0200842 pname = argp[idx].data.str.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +0200843 px = proxy_be_by_name(pname);
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200844 if (!px) {
845 msg = "backend doesn't exist";
846 goto error;
847 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100848 }
849 else {
Christopher Fauletfdea1b62020-08-06 08:29:18 +0200850 sname = argp[idx].data.str.area;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100851 px = p;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100852 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100853 argp[idx].data.srv = findserver(px, sname);
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200854 if (!argp[idx].data.srv) {
855 msg = "server doesn't exist";
856 goto error;
857 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100858 argp[idx].type = ARGT_SRV;
859 break;
860
861 case ARGT_IPV4:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200862 if (argp[idx].type != ARGT_STR) {
863 msg = "string expected";
864 goto error;
865 }
866 if (inet_pton(AF_INET, argp[idx].data.str.area, &argp[idx].data.ipv4)) {
867 msg = "invalid IPv4 address";
868 goto error;
869 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100870 argp[idx].type = ARGT_IPV4;
871 break;
872
873 case ARGT_MSK4:
Christopher Faulete663a6e2020-08-07 09:11:22 +0200874 if (argp[idx].type == ARGT_SINT)
875 len2mask4(argp[idx].data.sint, &argp[idx].data.ipv4);
876 else if (argp[idx].type == ARGT_STR) {
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200877 if (!str2mask(argp[idx].data.str.area, &argp[idx].data.ipv4)) {
878 msg = "invalid IPv4 mask";
879 goto error;
880 }
881 }
882 else {
883 msg = "integer or string expected";
884 goto error;
Christopher Faulete663a6e2020-08-07 09:11:22 +0200885 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100886 argp[idx].type = ARGT_MSK4;
887 break;
888
889 case ARGT_IPV6:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200890 if (argp[idx].type != ARGT_STR) {
891 msg = "string expected";
892 goto error;
893 }
894 if (inet_pton(AF_INET6, argp[idx].data.str.area, &argp[idx].data.ipv6)) {
895 msg = "invalid IPv6 address";
896 goto error;
897 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100898 argp[idx].type = ARGT_IPV6;
899 break;
900
901 case ARGT_MSK6:
Christopher Faulete663a6e2020-08-07 09:11:22 +0200902 if (argp[idx].type == ARGT_SINT)
903 len2mask6(argp[idx].data.sint, &argp[idx].data.ipv6);
904 else if (argp[idx].type == ARGT_STR) {
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200905 if (!str2mask6(argp[idx].data.str.area, &argp[idx].data.ipv6)) {
906 msg = "invalid IPv6 mask";
907 goto error;
908 }
909 }
910 else {
911 msg = "integer or string expected";
912 goto error;
Christopher Faulete663a6e2020-08-07 09:11:22 +0200913 }
Tim Duesterhusb814da62018-01-25 16:24:50 +0100914 argp[idx].type = ARGT_MSK6;
915 break;
916
Christopher Fauletfd2e9062020-08-06 11:10:57 +0200917 case ARGT_REG:
918 if (argp[idx].type != ARGT_STR) {
919 msg = "string expected";
920 goto error;
921 }
922 reg = regex_comp(argp[idx].data.str.area, !(argp[idx].type_flags & ARGF_REG_ICASE), 1, &err);
923 if (!reg) {
924 msg = lua_pushfstring(L, "error compiling regex '%s' : '%s'",
925 argp[idx].data.str.area, err);
926 free(err);
927 goto error;
928 }
929 argp[idx].type = ARGT_REG;
930 argp[idx].data.reg = reg;
931 break;
932
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100933 case ARGT_USR:
Christopher Fauletd25d9262020-08-06 11:04:46 +0200934 if (argp[idx].type != ARGT_STR) {
935 msg = "string expected";
936 goto error;
937 }
938 if (p->uri_auth && p->uri_auth->userlist &&
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100939 strcmp(p->uri_auth->userlist->name, argp[idx].data.str.area) == 0)
Christopher Fauletd25d9262020-08-06 11:04:46 +0200940 ul = p->uri_auth->userlist;
941 else
942 ul = auth_find_userlist(argp[idx].data.str.area);
943
944 if (!ul) {
945 msg = lua_pushfstring(L, "unable to find userlist '%s'", argp[idx].data.str.area);
946 goto error;
947 }
948 argp[idx].type = ARGT_USR;
949 argp[idx].data.usr = ul;
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200950 break;
951
952 case ARGT_STR:
953 if (!chunk_dup(&tmp, &argp[idx].data.str)) {
954 msg = "unable to duplicate string arg";
955 goto error;
956 }
957 argp[idx].data.str = tmp;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100958 break;
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200959
Christopher Fauletd25d9262020-08-06 11:04:46 +0200960 case ARGT_MAP:
Christopher Fauletd25d9262020-08-06 11:04:46 +0200961 msg = "type not yet supported";
962 goto error;
963 break;
964
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100965 }
966
967 /* Check for type of argument. */
968 if ((mask & ARGT_MASK) != argp[idx].type) {
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200969 msg = lua_pushfstring(L, "'%s' expected, got '%s'",
970 arg_type_names[(mask & ARGT_MASK)],
971 arg_type_names[argp[idx].type & ARGT_MASK]);
972 goto error;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100973 }
974
975 /* Next argument. */
976 mask >>= ARGT_BITS;
977 idx++;
978 }
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200979 return 0;
980
981 error:
982 for (i = 0; i < idx; i++) {
983 if (argp[i].type == ARGT_STR)
984 chunk_destroy(&argp[i].data.str);
Christopher Fauletfd2e9062020-08-06 11:10:57 +0200985 else if (argp[i].type == ARGT_REG)
986 regex_free(argp[i].data.reg);
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200987 }
988 WILL_LJMP(luaL_argerror(L, first + idx, msg));
989 return 0; /* Never reached */
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100990}
991
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100992/*
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500993 * The following functions are used to make correspondence between the the
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100994 * executed lua pointer and the "struct hlua *" that contain the context.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100995 *
996 * - hlua_gethlua : return the hlua context associated with an lua_State.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100997 * - hlua_sethlua : create the association between hlua context and lua_state.
998 */
999static inline struct hlua *hlua_gethlua(lua_State *L)
1000{
Thierry FOURNIER38c5fd62015-03-10 02:40:29 +01001001 struct hlua **hlua = lua_getextraspace(L);
1002 return *hlua;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001003}
1004static inline void hlua_sethlua(struct hlua *hlua)
1005{
Thierry FOURNIER38c5fd62015-03-10 02:40:29 +01001006 struct hlua **hlua_store = lua_getextraspace(hlua->T);
1007 *hlua_store = hlua;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001008}
1009
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01001010/* This function is used to send logs. It try to send on screen (stderr)
1011 * and on the default syslog server.
1012 */
1013static inline void hlua_sendlog(struct proxy *px, int level, const char *msg)
1014{
1015 struct tm tm;
1016 char *p;
1017
1018 /* Cleanup the log message. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001019 p = trash.area;
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01001020 for (; *msg != '\0'; msg++, p++) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001021 if (p >= trash.area + trash.size - 1) {
Thierry FOURNIERccf00632015-09-16 12:47:03 +02001022 /* Break the message if exceed the buffer size. */
1023 *(p-4) = ' ';
1024 *(p-3) = '.';
1025 *(p-2) = '.';
1026 *(p-1) = '.';
1027 break;
1028 }
Willy Tarreau90807112020-02-25 08:16:33 +01001029 if (isprint((unsigned char)*msg))
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01001030 *p = *msg;
1031 else
1032 *p = '.';
1033 }
1034 *p = '\0';
1035
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001036 send_log(px, level, "%s\n", trash.area);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01001037 if (!(global.mode & MODE_QUIET) || (global.mode & (MODE_VERBOSE | MODE_STARTING))) {
Christopher Fauletf98d8212020-10-02 18:13:52 +02001038 if (level == LOG_DEBUG && !(global.mode & MODE_DEBUG))
1039 return;
1040
Willy Tarreaua678b432015-08-28 10:14:59 +02001041 get_localtime(date.tv_sec, &tm);
1042 fprintf(stderr, "[%s] %03d/%02d%02d%02d (%d) : %s\n",
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01001043 log_levels[level], tm.tm_yday, tm.tm_hour, tm.tm_min, tm.tm_sec,
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001044 (int)getpid(), trash.area);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01001045 fflush(stderr);
1046 }
1047}
1048
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001049/* This function just ensure that the yield will be always
1050 * returned with a timeout and permit to set some flags
1051 */
1052__LJMP void hlua_yieldk(lua_State *L, int nresults, int ctx,
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001053 lua_KFunction k, int timeout, unsigned int flags)
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001054{
Thierry Fournier4234dbd2020-11-28 13:18:23 +01001055 struct hlua *hlua;
1056
1057 /* Get hlua struct, or NULL if we execute from main lua state */
1058 hlua = hlua_gethlua(L);
1059 if (!hlua) {
1060 return;
1061 }
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001062
1063 /* Set the wake timeout. If timeout is required, we set
1064 * the expiration time.
1065 */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001066 hlua->wake_time = timeout;
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001067
Thierry FOURNIER4abd3ae2015-03-03 17:29:06 +01001068 hlua->flags |= flags;
1069
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001070 /* Process the yield. */
Willy Tarreau9635e032018-10-16 17:52:55 +02001071 MAY_LJMP(lua_yieldk(L, nresults, ctx, k));
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001072}
1073
Willy Tarreau87b09662015-04-03 00:22:06 +02001074/* This function initialises the Lua environment stored in the stream.
1075 * It must be called at the start of the stream. This function creates
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001076 * an LUA coroutine. It can not be use to crete the main LUA context.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02001077 *
1078 * This function is particular. it initialises a new Lua thread. If the
1079 * initialisation fails (example: out of memory error), the lua function
1080 * throws an error (longjmp).
1081 *
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01001082 * In some case (at least one), this function can be called from safe
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001083 * environment, so we must not initialise it. While the support of
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01001084 * threads appear, the safe environment set a lock to ensure only one
1085 * Lua execution at a time. If we initialize safe environment in another
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001086 * safe environment, we have a dead lock.
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01001087 *
1088 * set "already_safe" true if the context is initialized form safe
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001089 * Lua function.
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01001090 *
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001091 * This function manipulates two Lua stacks: the main and the thread. Only
Thierry FOURNIERbabae282015-09-17 11:36:37 +02001092 * the main stack can fail. The thread is not manipulated. This function
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001093 * MUST NOT manipulate the created thread stack state, because it is not
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001094 * protected against errors thrown by the thread stack.
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001095 */
Thierry Fournier021d9862020-11-28 23:42:03 +01001096int hlua_ctx_init(struct hlua *lua, int state_id, struct task *task, int already_safe)
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001097{
1098 lua->Mref = LUA_REFNIL;
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001099 lua->flags = 0;
Willy Tarreauf31af932020-01-14 09:59:38 +01001100 lua->gc_count = 0;
Christopher Fauletbc275a92020-02-26 14:55:16 +01001101 lua->wake_time = TICK_ETERNITY;
Thierry Fournier021d9862020-11-28 23:42:03 +01001102 lua->state_id = state_id;
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +01001103 LIST_INIT(&lua->com);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01001104 if (!already_safe) {
1105 if (!SET_SAFE_LJMP_PARENT(lua)) {
1106 lua->Tref = LUA_REFNIL;
1107 return 0;
1108 }
1109 }
Thierry Fournier021d9862020-11-28 23:42:03 +01001110 lua->T = lua_newthread(hlua_states[state_id]);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001111 if (!lua->T) {
1112 lua->Tref = LUA_REFNIL;
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01001113 if (!already_safe)
Thierry Fournier7cbe5042020-11-28 17:02:21 +01001114 RESET_SAFE_LJMP_PARENT(lua);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001115 return 0;
1116 }
1117 hlua_sethlua(lua);
Thierry Fournier021d9862020-11-28 23:42:03 +01001118 lua->Tref = luaL_ref(hlua_states[state_id], LUA_REGISTRYINDEX);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001119 lua->task = task;
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01001120 if (!already_safe)
Thierry Fournier7cbe5042020-11-28 17:02:21 +01001121 RESET_SAFE_LJMP_PARENT(lua);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001122 return 1;
1123}
1124
Willy Tarreau87b09662015-04-03 00:22:06 +02001125/* Used to destroy the Lua coroutine when the attached stream or task
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001126 * is destroyed. The destroy also the memory context. The struct "lua"
1127 * is not freed.
1128 */
1129void hlua_ctx_destroy(struct hlua *lua)
1130{
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01001131 if (!lua)
Thierry FOURNIERa718b292015-03-04 16:48:34 +01001132 return;
1133
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01001134 if (!lua->T)
1135 goto end;
1136
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +01001137 /* Purge all the pending signals. */
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001138 notification_purge(&lua->com);
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +01001139
Thierry Fournier7cbe5042020-11-28 17:02:21 +01001140 if (!SET_SAFE_LJMP(lua))
Thierry FOURNIER75d02082017-07-12 13:41:33 +02001141 return;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001142 luaL_unref(lua->T, LUA_REGISTRYINDEX, lua->Mref);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01001143 RESET_SAFE_LJMP(lua);
Thierry FOURNIER5a50a852015-09-23 16:59:28 +02001144
Thierry Fournier7cbe5042020-11-28 17:02:21 +01001145 if (!SET_SAFE_LJMP_PARENT(lua))
Thierry FOURNIER75d02082017-07-12 13:41:33 +02001146 return;
Thierry Fournier021d9862020-11-28 23:42:03 +01001147 luaL_unref(hlua_states[lua->state_id], LUA_REGISTRYINDEX, lua->Tref);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01001148 RESET_SAFE_LJMP_PARENT(lua);
Thierry FOURNIER5a50a852015-09-23 16:59:28 +02001149 /* Forces a garbage collecting process. If the Lua program is finished
1150 * without error, we run the GC on the thread pointer. Its freed all
1151 * the unused memory.
1152 * If the thread is finnish with an error or is currently yielded,
1153 * it seems that the GC applied on the thread doesn't clean anything,
1154 * so e run the GC on the main thread.
1155 * NOTE: maybe this action locks all the Lua threads untiml the en of
1156 * the garbage collection.
1157 */
Willy Tarreauf31af932020-01-14 09:59:38 +01001158 if (lua->gc_count) {
Thierry Fournier7cbe5042020-11-28 17:02:21 +01001159 if (!SET_SAFE_LJMP_PARENT(lua))
Thierry FOURNIER75d02082017-07-12 13:41:33 +02001160 return;
Thierry Fournier021d9862020-11-28 23:42:03 +01001161 lua_gc(hlua_states[lua->state_id], LUA_GCCOLLECT, 0);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01001162 RESET_SAFE_LJMP_PARENT(lua);
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +02001163 }
Thierry FOURNIER5a50a852015-09-23 16:59:28 +02001164
Thierry FOURNIERa7b536b2015-09-21 22:50:24 +02001165 lua->T = NULL;
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01001166
1167end:
Willy Tarreaubafbe012017-11-24 17:34:44 +01001168 pool_free(pool_head_hlua, lua);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001169}
1170
1171/* This function is used to restore the Lua context when a coroutine
1172 * fails. This function copy the common memory between old coroutine
1173 * and the new coroutine. The old coroutine is destroyed, and its
1174 * replaced by the new coroutine.
1175 * If the flag "keep_msg" is set, the last entry of the old is assumed
1176 * as string error message and it is copied in the new stack.
1177 */
1178static int hlua_ctx_renew(struct hlua *lua, int keep_msg)
1179{
1180 lua_State *T;
1181 int new_ref;
1182
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001183 /* New Lua coroutine. */
Thierry Fournier021d9862020-11-28 23:42:03 +01001184 T = lua_newthread(hlua_states[lua->state_id]);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001185 if (!T)
1186 return 0;
1187
1188 /* Copy last error message. */
1189 if (keep_msg)
1190 lua_xmove(lua->T, T, 1);
1191
1192 /* Copy data between the coroutines. */
1193 lua_rawgeti(lua->T, LUA_REGISTRYINDEX, lua->Mref);
1194 lua_xmove(lua->T, T, 1);
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05001195 new_ref = luaL_ref(T, LUA_REGISTRYINDEX); /* Value popped. */
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001196
1197 /* Destroy old data. */
1198 luaL_unref(lua->T, LUA_REGISTRYINDEX, lua->Mref);
1199
1200 /* The thread is garbage collected by Lua. */
Thierry Fournier021d9862020-11-28 23:42:03 +01001201 luaL_unref(hlua_states[lua->state_id], LUA_REGISTRYINDEX, lua->Tref);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001202
1203 /* Fill the struct with the new coroutine values. */
1204 lua->Mref = new_ref;
1205 lua->T = T;
Thierry Fournier021d9862020-11-28 23:42:03 +01001206 lua->Tref = luaL_ref(hlua_states[lua->state_id], LUA_REGISTRYINDEX);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001207
1208 /* Set context. */
1209 hlua_sethlua(lua);
1210
1211 return 1;
1212}
1213
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001214void hlua_hook(lua_State *L, lua_Debug *ar)
1215{
Thierry Fournier4234dbd2020-11-28 13:18:23 +01001216 struct hlua *hlua;
1217
1218 /* Get hlua struct, or NULL if we execute from main lua state */
1219 hlua = hlua_gethlua(L);
1220 if (!hlua)
1221 return;
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001222
1223 /* Lua cannot yield when its returning from a function,
1224 * so, we can fix the interrupt hook to 1 instruction,
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001225 * expecting that the function is finished.
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001226 */
1227 if (lua_gethookmask(L) & LUA_MASKRET) {
1228 lua_sethook(hlua->T, hlua_hook, LUA_MASKCOUNT, 1);
1229 return;
1230 }
1231
1232 /* restore the interrupt condition. */
1233 lua_sethook(hlua->T, hlua_hook, LUA_MASKCOUNT, hlua_nb_instruction);
1234
1235 /* If we interrupt the Lua processing in yieldable state, we yield.
1236 * If the state is not yieldable, trying yield causes an error.
1237 */
1238 if (lua_isyieldable(L))
Willy Tarreau9635e032018-10-16 17:52:55 +02001239 MAY_LJMP(hlua_yieldk(L, 0, 0, NULL, TICK_ETERNITY, HLUA_CTRLYIELD));
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001240
Thierry FOURNIERa85cfb12015-03-13 14:50:06 +01001241 /* If we cannot yield, update the clock and check the timeout. */
1242 tv_update_date(0, 1);
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001243 hlua->run_time += now_ms - hlua->start_time;
1244 if (hlua->max_time && hlua->run_time >= hlua->max_time) {
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001245 lua_pushfstring(L, "execution timeout");
1246 WILL_LJMP(lua_error(L));
1247 }
1248
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001249 /* Update the start time. */
1250 hlua->start_time = now_ms;
1251
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001252 /* Try to interrupt the process at the end of the current
1253 * unyieldable function.
1254 */
1255 lua_sethook(hlua->T, hlua_hook, LUA_MASKRET|LUA_MASKCOUNT, hlua_nb_instruction);
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001256}
1257
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001258/* This function start or resumes the Lua stack execution. If the flag
1259 * "yield_allowed" if no set and the LUA stack execution returns a yield
1260 * The function return an error.
1261 *
1262 * The function can returns 4 values:
1263 * - HLUA_E_OK : The execution is terminated without any errors.
1264 * - HLUA_E_AGAIN : The execution must continue at the next associated
1265 * task wakeup.
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001266 * - HLUA_E_ERRMSG : An error has occurred, an error message is set in
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001267 * the top of the stack.
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001268 * - HLUA_E_ERR : An error has occurred without error message.
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001269 *
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001270 * If an error occurred, the stack is renewed and it is ready to run new
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001271 * LUA code.
1272 */
1273static enum hlua_exec hlua_ctx_resume(struct hlua *lua, int yield_allowed)
1274{
Christopher Faulet08ed98f2020-07-28 10:33:25 +02001275#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 504
1276 int nres;
1277#endif
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001278 int ret;
1279 const char *msg;
Thierry FOURNIERfc044c92018-06-07 14:40:48 +02001280 const char *trace;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001281
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001282 /* Initialise run time counter. */
1283 if (!HLUA_IS_RUNNING(lua))
1284 lua->run_time = 0;
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001285
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +02001286 /* Lock the whole Lua execution. This lock must be before the
1287 * label "resume_execution".
1288 */
Thierry Fournier021d9862020-11-28 23:42:03 +01001289 if (lua->state_id == 0)
Willy Tarreau3eb2e472021-08-20 15:47:25 +02001290 lua_take_global_lock();
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +02001291
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001292resume_execution:
1293
1294 /* This hook interrupts the Lua processing each 'hlua_nb_instruction'
1295 * instructions. it is used for preventing infinite loops.
1296 */
1297 lua_sethook(lua->T, hlua_hook, LUA_MASKCOUNT, hlua_nb_instruction);
1298
Thierry FOURNIER1bfc09b2015-03-05 17:10:14 +01001299 /* Remove all flags except the running flags. */
Thierry FOURNIER2f3867f2015-09-28 01:02:01 +02001300 HLUA_SET_RUN(lua);
1301 HLUA_CLR_CTRLYIELD(lua);
1302 HLUA_CLR_WAKERESWR(lua);
1303 HLUA_CLR_WAKEREQWR(lua);
Christopher Fauleta6e792f2021-08-04 17:58:21 +02001304 HLUA_CLR_NOYIELD(lua);
1305 if (!yield_allowed)
1306 HLUA_SET_NOYIELD(lua);
Thierry FOURNIER1bfc09b2015-03-05 17:10:14 +01001307
Christopher Fauletbc275a92020-02-26 14:55:16 +01001308 /* Update the start time and reset wake_time. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001309 lua->start_time = now_ms;
Christopher Fauletbc275a92020-02-26 14:55:16 +01001310 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001311
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001312 /* Call the function. */
Christopher Faulet08ed98f2020-07-28 10:33:25 +02001313#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 504
Thierry Fournier021d9862020-11-28 23:42:03 +01001314 ret = lua_resume(lua->T, hlua_states[lua->state_id], lua->nargs, &nres);
Christopher Faulet08ed98f2020-07-28 10:33:25 +02001315#else
Thierry Fournier021d9862020-11-28 23:42:03 +01001316 ret = lua_resume(lua->T, hlua_states[lua->state_id], lua->nargs);
Christopher Faulet08ed98f2020-07-28 10:33:25 +02001317#endif
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001318 switch (ret) {
1319
1320 case LUA_OK:
1321 ret = HLUA_E_OK;
1322 break;
1323
1324 case LUA_YIELD:
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001325 /* Check if the execution timeout is expired. It it is the case, we
1326 * break the Lua execution.
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001327 */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001328 tv_update_date(0, 1);
1329 lua->run_time += now_ms - lua->start_time;
1330 if (lua->max_time && lua->run_time > lua->max_time) {
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001331 lua_settop(lua->T, 0); /* Empty the stack. */
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001332 ret = HLUA_E_ETMOUT;
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001333 break;
1334 }
1335 /* Process the forced yield. if the general yield is not allowed or
1336 * if no task were associated this the current Lua execution
1337 * coroutine, we resume the execution. Else we want to return in the
1338 * scheduler and we want to be waked up again, to continue the
1339 * current Lua execution. So we schedule our own task.
1340 */
1341 if (HLUA_IS_CTRLYIELDING(lua)) {
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001342 if (!yield_allowed || !lua->task)
1343 goto resume_execution;
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001344 task_wakeup(lua->task, TASK_WOKEN_MSG);
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001345 }
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001346 if (!yield_allowed) {
1347 lua_settop(lua->T, 0); /* Empty the stack. */
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001348 ret = HLUA_E_YIELD;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001349 break;
1350 }
1351 ret = HLUA_E_AGAIN;
1352 break;
1353
1354 case LUA_ERRRUN:
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001355
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001356 /* Special exit case. The traditional exit is returned as an error
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001357 * because the errors ares the only one mean to return immediately
1358 * from and lua execution.
1359 */
1360 if (lua->flags & HLUA_EXIT) {
1361 ret = HLUA_E_OK;
Christopher Faulet7716cdf2020-01-29 11:53:30 +01001362 hlua_ctx_renew(lua, 1);
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001363 break;
1364 }
1365
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001366 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001367 if (!lua_checkstack(lua->T, 1)) {
1368 ret = HLUA_E_ERR;
1369 break;
1370 }
1371 msg = lua_tostring(lua->T, -1);
1372 lua_settop(lua->T, 0); /* Empty the stack. */
1373 lua_pop(lua->T, 1);
Christopher Fauletd09cc512021-03-24 14:48:45 +01001374 trace = hlua_traceback(lua->T, ", ");
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001375 if (msg)
Thierry Fournier46278ff2020-11-29 11:48:12 +01001376 lua_pushfstring(lua->T, "[state-id %d] runtime error: %s from %s", lua->state_id, msg, trace);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001377 else
Thierry Fournier46278ff2020-11-29 11:48:12 +01001378 lua_pushfstring(lua->T, "[state-id %d] unknown runtime error from %s", lua->state_id, trace);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001379 ret = HLUA_E_ERRMSG;
1380 break;
1381
1382 case LUA_ERRMEM:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001383 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001384 lua_settop(lua->T, 0); /* Empty the stack. */
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001385 ret = HLUA_E_NOMEM;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001386 break;
1387
1388 case LUA_ERRERR:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001389 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001390 if (!lua_checkstack(lua->T, 1)) {
1391 ret = HLUA_E_ERR;
1392 break;
1393 }
1394 msg = lua_tostring(lua->T, -1);
1395 lua_settop(lua->T, 0); /* Empty the stack. */
1396 lua_pop(lua->T, 1);
1397 if (msg)
Thierry Fournier46278ff2020-11-29 11:48:12 +01001398 lua_pushfstring(lua->T, "[state-id %d] message handler error: %s", lua->state_id, msg);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001399 else
Thierry Fournier46278ff2020-11-29 11:48:12 +01001400 lua_pushfstring(lua->T, "[state-id %d] message handler error", lua->state_id);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001401 ret = HLUA_E_ERRMSG;
1402 break;
1403
1404 default:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001405 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001406 lua_settop(lua->T, 0); /* Empty the stack. */
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001407 ret = HLUA_E_ERR;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001408 break;
1409 }
1410
1411 switch (ret) {
1412 case HLUA_E_AGAIN:
1413 break;
1414
1415 case HLUA_E_ERRMSG:
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001416 notification_purge(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001417 hlua_ctx_renew(lua, 1);
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001418 HLUA_CLR_RUN(lua);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001419 break;
1420
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001421 case HLUA_E_ETMOUT:
1422 case HLUA_E_NOMEM:
1423 case HLUA_E_YIELD:
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001424 case HLUA_E_ERR:
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001425 HLUA_CLR_RUN(lua);
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001426 notification_purge(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001427 hlua_ctx_renew(lua, 0);
1428 break;
1429
1430 case HLUA_E_OK:
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001431 HLUA_CLR_RUN(lua);
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001432 notification_purge(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001433 break;
1434 }
1435
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +02001436 /* This is the main exit point, remove the Lua lock. */
Thierry Fournier021d9862020-11-28 23:42:03 +01001437 if (lua->state_id == 0)
Willy Tarreau3eb2e472021-08-20 15:47:25 +02001438 lua_drop_global_lock();
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +02001439
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001440 return ret;
1441}
1442
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001443/* This function exit the current code. */
1444__LJMP static int hlua_done(lua_State *L)
1445{
Thierry Fournier4234dbd2020-11-28 13:18:23 +01001446 struct hlua *hlua;
1447
1448 /* Get hlua struct, or NULL if we execute from main lua state */
1449 hlua = hlua_gethlua(L);
1450 if (!hlua)
1451 return 0;
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001452
1453 hlua->flags |= HLUA_EXIT;
1454 WILL_LJMP(lua_error(L));
1455
1456 return 0;
1457}
1458
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001459/* This function is an LUA binding. It provides a function
1460 * for deleting ACL from a referenced ACL file.
1461 */
1462__LJMP static int hlua_del_acl(lua_State *L)
1463{
1464 const char *name;
1465 const char *key;
1466 struct pat_ref *ref;
1467
1468 MAY_LJMP(check_args(L, 2, "del_acl"));
1469
1470 name = MAY_LJMP(luaL_checkstring(L, 1));
1471 key = MAY_LJMP(luaL_checkstring(L, 2));
1472
1473 ref = pat_ref_lookup(name);
1474 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001475 WILL_LJMP(luaL_error(L, "'del_acl': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001476
Christopher Faulet5cf2dfc2020-06-03 18:39:16 +02001477 HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001478 pat_ref_delete(ref, key);
Christopher Faulet5cf2dfc2020-06-03 18:39:16 +02001479 HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001480 return 0;
1481}
1482
1483/* This function is an LUA binding. It provides a function
1484 * for deleting map entry from a referenced map file.
1485 */
1486static int hlua_del_map(lua_State *L)
1487{
1488 const char *name;
1489 const char *key;
1490 struct pat_ref *ref;
1491
1492 MAY_LJMP(check_args(L, 2, "del_map"));
1493
1494 name = MAY_LJMP(luaL_checkstring(L, 1));
1495 key = MAY_LJMP(luaL_checkstring(L, 2));
1496
1497 ref = pat_ref_lookup(name);
1498 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001499 WILL_LJMP(luaL_error(L, "'del_map': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001500
Christopher Faulet5cf2dfc2020-06-03 18:39:16 +02001501 HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001502 pat_ref_delete(ref, key);
Christopher Faulet5cf2dfc2020-06-03 18:39:16 +02001503 HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001504 return 0;
1505}
1506
1507/* This function is an LUA binding. It provides a function
1508 * for adding ACL pattern from a referenced ACL file.
1509 */
1510static int hlua_add_acl(lua_State *L)
1511{
1512 const char *name;
1513 const char *key;
1514 struct pat_ref *ref;
1515
1516 MAY_LJMP(check_args(L, 2, "add_acl"));
1517
1518 name = MAY_LJMP(luaL_checkstring(L, 1));
1519 key = MAY_LJMP(luaL_checkstring(L, 2));
1520
1521 ref = pat_ref_lookup(name);
1522 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001523 WILL_LJMP(luaL_error(L, "'add_acl': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001524
Christopher Faulet5cf2dfc2020-06-03 18:39:16 +02001525 HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001526 if (pat_ref_find_elt(ref, key) == NULL)
1527 pat_ref_add(ref, key, NULL, NULL);
Christopher Faulet5cf2dfc2020-06-03 18:39:16 +02001528 HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001529 return 0;
1530}
1531
1532/* This function is an LUA binding. It provides a function
1533 * for setting map pattern and sample from a referenced map
1534 * file.
1535 */
1536static int hlua_set_map(lua_State *L)
1537{
1538 const char *name;
1539 const char *key;
1540 const char *value;
1541 struct pat_ref *ref;
1542
1543 MAY_LJMP(check_args(L, 3, "set_map"));
1544
1545 name = MAY_LJMP(luaL_checkstring(L, 1));
1546 key = MAY_LJMP(luaL_checkstring(L, 2));
1547 value = MAY_LJMP(luaL_checkstring(L, 3));
1548
1549 ref = pat_ref_lookup(name);
1550 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001551 WILL_LJMP(luaL_error(L, "'set_map': unknown map file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001552
Christopher Faulet5cf2dfc2020-06-03 18:39:16 +02001553 HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001554 if (pat_ref_find_elt(ref, key) != NULL)
1555 pat_ref_set(ref, key, value, NULL);
1556 else
1557 pat_ref_add(ref, key, value, NULL);
Christopher Faulet5cf2dfc2020-06-03 18:39:16 +02001558 HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001559 return 0;
1560}
1561
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01001562/* A class is a lot of memory that contain data. This data can be a table,
1563 * an integer or user data. This data is associated with a metatable. This
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001564 * metatable have an original version registered in the global context with
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01001565 * the name of the object (_G[<name>] = <metable> ).
1566 *
1567 * A metable is a table that modify the standard behavior of a standard
1568 * access to the associated data. The entries of this new metatable are
1569 * defined as is:
1570 *
1571 * http://lua-users.org/wiki/MetatableEvents
1572 *
1573 * __index
1574 *
1575 * we access an absent field in a table, the result is nil. This is
1576 * true, but it is not the whole truth. Actually, such access triggers
1577 * the interpreter to look for an __index metamethod: If there is no
1578 * such method, as usually happens, then the access results in nil;
1579 * otherwise, the metamethod will provide the result.
1580 *
1581 * Control 'prototype' inheritance. When accessing "myTable[key]" and
1582 * the key does not appear in the table, but the metatable has an __index
1583 * property:
1584 *
1585 * - if the value is a function, the function is called, passing in the
1586 * table and the key; the return value of that function is returned as
1587 * the result.
1588 *
1589 * - if the value is another table, the value of the key in that table is
1590 * asked for and returned (and if it doesn't exist in that table, but that
1591 * table's metatable has an __index property, then it continues on up)
1592 *
1593 * - Use "rawget(myTable,key)" to skip this metamethod.
1594 *
1595 * http://www.lua.org/pil/13.4.1.html
1596 *
1597 * __newindex
1598 *
1599 * Like __index, but control property assignment.
1600 *
1601 * __mode - Control weak references. A string value with one or both
1602 * of the characters 'k' and 'v' which specifies that the the
1603 * keys and/or values in the table are weak references.
1604 *
1605 * __call - Treat a table like a function. When a table is followed by
1606 * parenthesis such as "myTable( 'foo' )" and the metatable has
1607 * a __call key pointing to a function, that function is invoked
1608 * (passing any specified arguments) and the return value is
1609 * returned.
1610 *
1611 * __metatable - Hide the metatable. When "getmetatable( myTable )" is
1612 * called, if the metatable for myTable has a __metatable
1613 * key, the value of that key is returned instead of the
1614 * actual metatable.
1615 *
1616 * __tostring - Control string representation. When the builtin
1617 * "tostring( myTable )" function is called, if the metatable
1618 * for myTable has a __tostring property set to a function,
1619 * that function is invoked (passing myTable to it) and the
1620 * return value is used as the string representation.
1621 *
1622 * __len - Control table length. When the table length is requested using
1623 * the length operator ( '#' ), if the metatable for myTable has
1624 * a __len key pointing to a function, that function is invoked
1625 * (passing myTable to it) and the return value used as the value
1626 * of "#myTable".
1627 *
1628 * __gc - Userdata finalizer code. When userdata is set to be garbage
1629 * collected, if the metatable has a __gc field pointing to a
1630 * function, that function is first invoked, passing the userdata
1631 * to it. The __gc metamethod is not called for tables.
1632 * (See http://lua-users.org/lists/lua-l/2006-11/msg00508.html)
1633 *
1634 * Special metamethods for redefining standard operators:
1635 * http://www.lua.org/pil/13.1.html
1636 *
1637 * __add "+"
1638 * __sub "-"
1639 * __mul "*"
1640 * __div "/"
1641 * __unm "!"
1642 * __pow "^"
1643 * __concat ".."
1644 *
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001645 * Special methods for redefining standard relations
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01001646 * http://www.lua.org/pil/13.2.html
1647 *
1648 * __eq "=="
1649 * __lt "<"
1650 * __le "<="
1651 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001652
1653/*
1654 *
1655 *
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001656 * Class Map
1657 *
1658 *
1659 */
1660
1661/* Returns a struct hlua_map if the stack entry "ud" is
1662 * a class session, otherwise it throws an error.
1663 */
1664__LJMP static struct map_descriptor *hlua_checkmap(lua_State *L, int ud)
1665{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02001666 return MAY_LJMP(hlua_checkudata(L, ud, class_map_ref));
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001667}
1668
1669/* This function is the map constructor. It don't need
1670 * the class Map object. It creates and return a new Map
1671 * object. It must be called only during "body" or "init"
1672 * context because it process some filesystem accesses.
1673 */
1674__LJMP static int hlua_map_new(struct lua_State *L)
1675{
1676 const char *fn;
1677 int match = PAT_MATCH_STR;
1678 struct sample_conv conv;
1679 const char *file = "";
1680 int line = 0;
1681 lua_Debug ar;
1682 char *err = NULL;
1683 struct arg args[2];
1684
1685 if (lua_gettop(L) < 1 || lua_gettop(L) > 2)
1686 WILL_LJMP(luaL_error(L, "'new' needs at least 1 argument."));
1687
1688 fn = MAY_LJMP(luaL_checkstring(L, 1));
1689
1690 if (lua_gettop(L) >= 2) {
1691 match = MAY_LJMP(luaL_checkinteger(L, 2));
1692 if (match < 0 || match >= PAT_MATCH_NUM)
1693 WILL_LJMP(luaL_error(L, "'new' needs a valid match method."));
1694 }
1695
1696 /* Get Lua filename and line number. */
1697 if (lua_getstack(L, 1, &ar)) { /* check function at level */
1698 lua_getinfo(L, "Sl", &ar); /* get info about it */
1699 if (ar.currentline > 0) { /* is there info? */
1700 file = ar.short_src;
1701 line = ar.currentline;
1702 }
1703 }
1704
1705 /* fill fake sample_conv struct. */
1706 conv.kw = ""; /* unused. */
1707 conv.process = NULL; /* unused. */
1708 conv.arg_mask = 0; /* unused. */
1709 conv.val_args = NULL; /* unused. */
1710 conv.out_type = SMP_T_STR;
1711 conv.private = (void *)(long)match;
1712 switch (match) {
1713 case PAT_MATCH_STR: conv.in_type = SMP_T_STR; break;
1714 case PAT_MATCH_BEG: conv.in_type = SMP_T_STR; break;
1715 case PAT_MATCH_SUB: conv.in_type = SMP_T_STR; break;
1716 case PAT_MATCH_DIR: conv.in_type = SMP_T_STR; break;
1717 case PAT_MATCH_DOM: conv.in_type = SMP_T_STR; break;
1718 case PAT_MATCH_END: conv.in_type = SMP_T_STR; break;
1719 case PAT_MATCH_REG: conv.in_type = SMP_T_STR; break;
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001720 case PAT_MATCH_INT: conv.in_type = SMP_T_SINT; break;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001721 case PAT_MATCH_IP: conv.in_type = SMP_T_ADDR; break;
1722 default:
1723 WILL_LJMP(luaL_error(L, "'new' doesn't support this match mode."));
1724 }
1725
1726 /* fill fake args. */
1727 args[0].type = ARGT_STR;
Christopher Faulet73292e92020-08-06 08:40:09 +02001728 args[0].data.str.area = strdup(fn);
1729 args[0].data.str.data = strlen(fn);
1730 args[0].data.str.size = args[0].data.str.data+1;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001731 args[1].type = ARGT_STOP;
1732
1733 /* load the map. */
1734 if (!sample_load_map(args, &conv, file, line, &err)) {
Ilya Shipitsinb8888ab2021-01-06 21:20:16 +05001735 /* error case: we can't use luaL_error because we must
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001736 * free the err variable.
1737 */
1738 luaL_where(L, 1);
1739 lua_pushfstring(L, "'new': %s.", err);
1740 lua_concat(L, 2);
1741 free(err);
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001742 chunk_destroy(&args[0].data.str);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001743 WILL_LJMP(lua_error(L));
1744 }
1745
1746 /* create the lua object. */
1747 lua_newtable(L);
1748 lua_pushlightuserdata(L, args[0].data.map);
1749 lua_rawseti(L, -2, 0);
1750
1751 /* Pop a class Map metatable and affect it to the userdata. */
1752 lua_rawgeti(L, LUA_REGISTRYINDEX, class_map_ref);
1753 lua_setmetatable(L, -2);
1754
1755
1756 return 1;
1757}
1758
1759__LJMP static inline int _hlua_map_lookup(struct lua_State *L, int str)
1760{
1761 struct map_descriptor *desc;
1762 struct pattern *pat;
1763 struct sample smp;
1764
1765 MAY_LJMP(check_args(L, 2, "lookup"));
1766 desc = MAY_LJMP(hlua_checkmap(L, 1));
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001767 if (desc->pat.expect_type == SMP_T_SINT) {
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001768 smp.data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001769 smp.data.u.sint = MAY_LJMP(luaL_checkinteger(L, 2));
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001770 }
1771 else {
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001772 smp.data.type = SMP_T_STR;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001773 smp.flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001774 smp.data.u.str.area = (char *)MAY_LJMP(luaL_checklstring(L, 2, (size_t *)&smp.data.u.str.data));
Thierry Fournier91dc0c02020-11-10 20:38:20 +01001775 smp.data.u.str.size = smp.data.u.str.data + 1;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001776 }
1777
1778 pat = pattern_exec_match(&desc->pat, &smp, 1);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001779 if (!pat || !pat->data) {
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001780 if (str)
1781 lua_pushstring(L, "");
1782 else
1783 lua_pushnil(L);
1784 return 1;
1785 }
1786
1787 /* The Lua pattern must return a string, so we can't check the returned type */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001788 lua_pushlstring(L, pat->data->u.str.area, pat->data->u.str.data);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001789 return 1;
1790}
1791
1792__LJMP static int hlua_map_lookup(struct lua_State *L)
1793{
1794 return _hlua_map_lookup(L, 0);
1795}
1796
1797__LJMP static int hlua_map_slookup(struct lua_State *L)
1798{
1799 return _hlua_map_lookup(L, 1);
1800}
1801
1802/*
1803 *
1804 *
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001805 * Class Socket
1806 *
1807 *
1808 */
1809
1810__LJMP static struct hlua_socket *hlua_checksocket(lua_State *L, int ud)
1811{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02001812 return MAY_LJMP(hlua_checkudata(L, ud, class_socket_ref));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001813}
1814
1815/* This function is the handler called for each I/O on the established
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001816 * connection. It is used for notify space available to send or data
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001817 * received.
1818 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02001819static void hlua_socket_handler(struct appctx *appctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001820{
Willy Tarreau00a37f02015-04-13 12:05:19 +02001821 struct stream_interface *si = appctx->owner;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001822
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02001823 if (appctx->ctx.hlua_cosocket.die) {
1824 si_shutw(si);
1825 si_shutr(si);
1826 si_ic(si)->flags |= CF_READ_NULL;
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001827 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1828 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02001829 stream_shutdown(si_strm(si), SF_ERR_KILLED);
1830 }
1831
Ilya Shipitsinb8888ab2021-01-06 21:20:16 +05001832 /* If we can't write, wakeup the pending write signals. */
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001833 if (channel_output_closed(si_ic(si)))
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001834 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001835
Ilya Shipitsinb8888ab2021-01-06 21:20:16 +05001836 /* If we can't read, wakeup the pending read signals. */
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001837 if (channel_input_closed(si_oc(si)))
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001838 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001839
Willy Tarreau5a0b25d2019-07-18 18:01:14 +02001840 /* if the connection is not established, inform the stream that we want
Thierry FOURNIER316e3192015-09-04 18:25:53 +02001841 * to be notified whenever the connection completes.
1842 */
Willy Tarreau5a0b25d2019-07-18 18:01:14 +02001843 if (si_opposite(si)->state < SI_ST_EST) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01001844 si_cant_get(si);
Willy Tarreau12c24232018-12-06 15:29:50 +01001845 si_rx_conn_blk(si);
Willy Tarreau3367d412018-11-15 10:57:41 +01001846 si_rx_endp_more(si);
Willy Tarreaud4da1962015-04-20 01:31:23 +02001847 return;
Thierry FOURNIER316e3192015-09-04 18:25:53 +02001848 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001849
1850 /* This function is called after the connect. */
Thierry FOURNIER18d09902016-12-16 09:25:38 +01001851 appctx->ctx.hlua_cosocket.connected = 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001852
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001853 /* Wake the tasks which wants to write if the buffer have available space. */
Thierry FOURNIEReba6f642015-09-26 22:01:07 +02001854 if (channel_may_recv(si_ic(si)))
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001855 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001856
1857 /* Wake the tasks which wants to read if the buffer contains data. */
Thierry FOURNIEReba6f642015-09-26 22:01:07 +02001858 if (!channel_is_empty(si_oc(si)))
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001859 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
Thierry FOURNIER101b9762018-05-27 01:27:40 +02001860
1861 /* Some data were injected in the buffer, notify the stream
1862 * interface.
1863 */
1864 if (!channel_is_empty(si_ic(si)))
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01001865 si_update(si);
Thierry FOURNIER101b9762018-05-27 01:27:40 +02001866
1867 /* If write notifications are registered, we considers we want
Willy Tarreau3367d412018-11-15 10:57:41 +01001868 * to write, so we clear the blocking flag.
Thierry FOURNIER101b9762018-05-27 01:27:40 +02001869 */
1870 if (notification_registered(&appctx->ctx.hlua_cosocket.wake_on_write))
Willy Tarreau3367d412018-11-15 10:57:41 +01001871 si_rx_endp_more(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001872}
1873
Willy Tarreau87b09662015-04-03 00:22:06 +02001874/* This function is called when the "struct stream" is destroyed.
1875 * Remove the link from the object to this stream.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001876 * Wake all the pending signals.
1877 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02001878static void hlua_socket_release(struct appctx *appctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001879{
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001880 struct xref *peer;
1881
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001882 /* Remove my link in the original object. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001883 peer = xref_get_peer_and_lock(&appctx->ctx.hlua_cosocket.xref);
1884 if (peer)
1885 xref_disconnect(&appctx->ctx.hlua_cosocket.xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001886
1887 /* Wake all the task waiting for me. */
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001888 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1889 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001890}
1891
1892/* If the garbage collectio of the object is launch, nobody
Willy Tarreau87b09662015-04-03 00:22:06 +02001893 * uses this object. If the stream does not exists, just quit.
1894 * Send the shutdown signal to the stream. In some cases,
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001895 * pending signal can rest in the read and write lists. destroy
1896 * it.
1897 */
1898__LJMP static int hlua_socket_gc(lua_State *L)
1899{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001900 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001901 struct appctx *appctx;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001902 struct xref *peer;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001903
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001904 MAY_LJMP(check_args(L, 1, "__gc"));
1905
1906 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001907 peer = xref_get_peer_and_lock(&socket->xref);
1908 if (!peer)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001909 return 0;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001910 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001911
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001912 /* Set the flag which destroy the session. */
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02001913 appctx->ctx.hlua_cosocket.die = 1;
1914 appctx_wakeup(appctx);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001915
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001916 /* Remove all reference between the Lua stack and the coroutine stream. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001917 xref_disconnect(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001918 return 0;
1919}
1920
1921/* The close function send shutdown signal and break the
Willy Tarreau87b09662015-04-03 00:22:06 +02001922 * links between the stream and the object.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001923 */
sada05ed3302018-05-11 11:48:18 -07001924__LJMP static int hlua_socket_close_helper(lua_State *L)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001925{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001926 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001927 struct appctx *appctx;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001928 struct xref *peer;
Thierry Fournier4234dbd2020-11-28 13:18:23 +01001929 struct hlua *hlua;
1930
1931 /* Get hlua struct, or NULL if we execute from main lua state */
1932 hlua = hlua_gethlua(L);
1933 if (!hlua)
1934 return 0;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001935
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001936 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02001937
1938 /* Check if we run on the same thread than the xreator thread.
1939 * We cannot access to the socket if the thread is different.
1940 */
1941 if (socket->tid != tid)
1942 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
1943
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001944 peer = xref_get_peer_and_lock(&socket->xref);
1945 if (!peer)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001946 return 0;
Willy Tarreauf31af932020-01-14 09:59:38 +01001947
1948 hlua->gc_count--;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001949 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001950
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001951 /* Set the flag which destroy the session. */
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02001952 appctx->ctx.hlua_cosocket.die = 1;
1953 appctx_wakeup(appctx);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001954
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001955 /* Remove all reference between the Lua stack and the coroutine stream. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001956 xref_disconnect(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001957 return 0;
1958}
1959
sada05ed3302018-05-11 11:48:18 -07001960/* The close function calls close_helper.
1961 */
1962__LJMP static int hlua_socket_close(lua_State *L)
1963{
1964 MAY_LJMP(check_args(L, 1, "close"));
1965 return hlua_socket_close_helper(L);
1966}
1967
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001968/* This Lua function assumes that the stack contain three parameters.
1969 * 1 - USERDATA containing a struct socket
1970 * 2 - INTEGER with values of the macro defined below
1971 * If the integer is -1, we must read at most one line.
1972 * If the integer is -2, we ust read all the data until the
1973 * end of the stream.
1974 * If the integer is positive value, we must read a number of
1975 * bytes corresponding to this value.
1976 */
1977#define HLSR_READ_LINE (-1)
1978#define HLSR_READ_ALL (-2)
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001979__LJMP static int hlua_socket_receive_yield(struct lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001980{
1981 struct hlua_socket *socket = MAY_LJMP(hlua_checksocket(L, 1));
1982 int wanted = lua_tointeger(L, 2);
Thierry Fournier4234dbd2020-11-28 13:18:23 +01001983 struct hlua *hlua;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001984 struct appctx *appctx;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02001985 size_t len;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001986 int nblk;
Willy Tarreau206ba832018-06-14 15:27:31 +02001987 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02001988 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02001989 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02001990 size_t len2;
Thierry FOURNIER00543922015-03-09 18:35:06 +01001991 int skip_at_end = 0;
Willy Tarreau81389672015-03-10 12:03:52 +01001992 struct channel *oc;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001993 struct stream_interface *si;
1994 struct stream *s;
1995 struct xref *peer;
Thierry FOURNIER8c126c72018-05-25 16:27:44 +02001996 int missing_bytes;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001997
Thierry Fournier4234dbd2020-11-28 13:18:23 +01001998 /* Get hlua struct, or NULL if we execute from main lua state */
1999 hlua = hlua_gethlua(L);
2000
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002001 /* Check if this lua stack is schedulable. */
2002 if (!hlua || !hlua->task)
2003 WILL_LJMP(luaL_error(L, "The 'receive' function is only allowed in "
2004 "'frontend', 'backend' or 'task'"));
2005
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002006 /* Check if we run on the same thread than the xreator thread.
2007 * We cannot access to the socket if the thread is different.
2008 */
2009 if (socket->tid != tid)
2010 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2011
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002012 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002013 peer = xref_get_peer_and_lock(&socket->xref);
2014 if (!peer)
2015 goto no_peer;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002016 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2017 si = appctx->owner;
2018 s = si_strm(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002019
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002020 oc = &s->res;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002021 if (wanted == HLSR_READ_LINE) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002022 /* Read line. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02002023 nblk = co_getline_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002024 if (nblk < 0) /* Connection close. */
2025 goto connection_closed;
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002026 if (nblk == 0) /* No data available. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002027 goto connection_empty;
Thierry FOURNIER00543922015-03-09 18:35:06 +01002028
2029 /* remove final \r\n. */
2030 if (nblk == 1) {
2031 if (blk1[len1-1] == '\n') {
2032 len1--;
2033 skip_at_end++;
2034 if (blk1[len1-1] == '\r') {
2035 len1--;
2036 skip_at_end++;
2037 }
2038 }
2039 }
2040 else {
2041 if (blk2[len2-1] == '\n') {
2042 len2--;
2043 skip_at_end++;
2044 if (blk2[len2-1] == '\r') {
2045 len2--;
2046 skip_at_end++;
2047 }
2048 }
2049 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002050 }
2051
2052 else if (wanted == HLSR_READ_ALL) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002053 /* Read all the available data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02002054 nblk = co_getblk_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002055 if (nblk < 0) /* Connection close. */
2056 goto connection_closed;
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002057 if (nblk == 0) /* No data available. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002058 goto connection_empty;
2059 }
2060
2061 else {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002062 /* Read a block of data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02002063 nblk = co_getblk_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002064 if (nblk < 0) /* Connection close. */
2065 goto connection_closed;
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002066 if (nblk == 0) /* No data available. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002067 goto connection_empty;
2068
Thierry FOURNIER8c126c72018-05-25 16:27:44 +02002069 missing_bytes = wanted - socket->b.n;
2070 if (len1 > missing_bytes) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002071 nblk = 1;
Thierry FOURNIER8c126c72018-05-25 16:27:44 +02002072 len1 = missing_bytes;
2073 } if (nblk == 2 && len1 + len2 > missing_bytes)
2074 len2 = missing_bytes - len1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002075 }
2076
2077 len = len1;
2078
2079 luaL_addlstring(&socket->b, blk1, len1);
2080 if (nblk == 2) {
2081 len += len2;
2082 luaL_addlstring(&socket->b, blk2, len2);
2083 }
2084
2085 /* Consume data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02002086 co_skip(oc, len + skip_at_end);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002087
2088 /* Don't wait anything. */
Thierry FOURNIER7e4ee472018-05-25 15:03:50 +02002089 appctx_wakeup(appctx);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002090
2091 /* If the pattern reclaim to read all the data
2092 * in the connection, got out.
2093 */
2094 if (wanted == HLSR_READ_ALL)
2095 goto connection_empty;
Thierry FOURNIER8c126c72018-05-25 16:27:44 +02002096 else if (wanted >= 0 && socket->b.n < wanted)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002097 goto connection_empty;
2098
2099 /* Return result. */
2100 luaL_pushresult(&socket->b);
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002101 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002102 return 1;
2103
2104connection_closed:
2105
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002106 xref_unlock(&socket->xref, peer);
2107
2108no_peer:
2109
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002110 /* If the buffer containds data. */
2111 if (socket->b.n > 0) {
2112 luaL_pushresult(&socket->b);
2113 return 1;
2114 }
2115 lua_pushnil(L);
2116 lua_pushstring(L, "connection closed.");
2117 return 2;
2118
2119connection_empty:
2120
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002121 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_read, hlua->task)) {
2122 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002123 WILL_LJMP(luaL_error(L, "out of memory"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002124 }
2125 xref_unlock(&socket->xref, peer);
Willy Tarreau9635e032018-10-16 17:52:55 +02002126 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_receive_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002127 return 0;
2128}
2129
Tim Duesterhusb33754c2018-01-04 19:32:14 +01002130/* This Lua function gets two parameters. The first one can be string
2131 * or a number. If the string is "*l", the user requires one line. If
2132 * the string is "*a", the user requires all the contents of the stream.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002133 * If the value is a number, the user require a number of bytes equal
2134 * to the value. The default value is "*l" (a line).
2135 *
Tim Duesterhusb33754c2018-01-04 19:32:14 +01002136 * This parameter with a variable type is converted in integer. This
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002137 * integer takes this values:
2138 * -1 : read a line
2139 * -2 : read all the stream
Tim Duesterhusb33754c2018-01-04 19:32:14 +01002140 * >0 : amount of bytes.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002141 *
Tim Duesterhusb33754c2018-01-04 19:32:14 +01002142 * The second parameter is optional. It contains a string that must be
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002143 * concatenated with the read data.
2144 */
2145__LJMP static int hlua_socket_receive(struct lua_State *L)
2146{
2147 int wanted = HLSR_READ_LINE;
2148 const char *pattern;
Christopher Fauletc31b2002021-05-03 10:11:13 +02002149 int lastarg, type;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002150 char *error;
2151 size_t len;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002152 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002153
2154 if (lua_gettop(L) < 1 || lua_gettop(L) > 3)
2155 WILL_LJMP(luaL_error(L, "The 'receive' function requires between 1 and 3 arguments."));
2156
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002157 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002158
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002159 /* Check if we run on the same thread than the xreator thread.
2160 * We cannot access to the socket if the thread is different.
2161 */
2162 if (socket->tid != tid)
2163 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2164
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002165 /* check for pattern. */
2166 if (lua_gettop(L) >= 2) {
2167 type = lua_type(L, 2);
2168 if (type == LUA_TSTRING) {
2169 pattern = lua_tostring(L, 2);
2170 if (strcmp(pattern, "*a") == 0)
2171 wanted = HLSR_READ_ALL;
2172 else if (strcmp(pattern, "*l") == 0)
2173 wanted = HLSR_READ_LINE;
2174 else {
2175 wanted = strtoll(pattern, &error, 10);
2176 if (*error != '\0')
2177 WILL_LJMP(luaL_error(L, "Unsupported pattern."));
2178 }
2179 }
2180 else if (type == LUA_TNUMBER) {
2181 wanted = lua_tointeger(L, 2);
2182 if (wanted < 0)
2183 WILL_LJMP(luaL_error(L, "Unsupported size."));
2184 }
2185 }
2186
2187 /* Set pattern. */
2188 lua_pushinteger(L, wanted);
Tim Duesterhusc6e377e2018-01-04 19:32:13 +01002189
2190 /* Check if we would replace the top by itself. */
2191 if (lua_gettop(L) != 2)
2192 lua_replace(L, 2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002193
Christopher Fauletc31b2002021-05-03 10:11:13 +02002194 /* Save index of the top of the stack because since buffers are used, it
2195 * may change
2196 */
2197 lastarg = lua_gettop(L);
2198
Tim Duesterhusb33754c2018-01-04 19:32:14 +01002199 /* init buffer, and fill it with prefix. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002200 luaL_buffinit(L, &socket->b);
2201
2202 /* Check prefix. */
Christopher Fauletc31b2002021-05-03 10:11:13 +02002203 if (lastarg >= 3) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002204 if (lua_type(L, 3) != LUA_TSTRING)
2205 WILL_LJMP(luaL_error(L, "Expect a 'string' for the prefix"));
2206 pattern = lua_tolstring(L, 3, &len);
2207 luaL_addlstring(&socket->b, pattern, len);
2208 }
2209
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002210 return __LJMP(hlua_socket_receive_yield(L, 0, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002211}
2212
2213/* Write the Lua input string in the output buffer.
Mark Lakes22154b42018-01-29 14:38:40 -08002214 * This function returns a yield if no space is available.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002215 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002216static int hlua_socket_write_yield(struct lua_State *L,int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002217{
2218 struct hlua_socket *socket;
Thierry Fournier4234dbd2020-11-28 13:18:23 +01002219 struct hlua *hlua;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002220 struct appctx *appctx;
2221 size_t buf_len;
2222 const char *buf;
2223 int len;
2224 int send_len;
2225 int sent;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002226 struct xref *peer;
2227 struct stream_interface *si;
2228 struct stream *s;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002229
Thierry Fournier4234dbd2020-11-28 13:18:23 +01002230 /* Get hlua struct, or NULL if we execute from main lua state */
2231 hlua = hlua_gethlua(L);
2232
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002233 /* Check if this lua stack is schedulable. */
2234 if (!hlua || !hlua->task)
2235 WILL_LJMP(luaL_error(L, "The 'write' function is only allowed in "
2236 "'frontend', 'backend' or 'task'"));
2237
2238 /* Get object */
2239 socket = MAY_LJMP(hlua_checksocket(L, 1));
2240 buf = MAY_LJMP(luaL_checklstring(L, 2, &buf_len));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002241 sent = MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002242
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002243 /* Check if we run on the same thread than the xreator thread.
2244 * We cannot access to the socket if the thread is different.
2245 */
2246 if (socket->tid != tid)
2247 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2248
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002249 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002250 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002251 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002252 lua_pushinteger(L, -1);
2253 return 1;
2254 }
2255 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2256 si = appctx->owner;
2257 s = si_strm(si);
2258
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002259 /* Check for connection close. */
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002260 if (channel_output_closed(&s->req)) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002261 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002262 lua_pushinteger(L, -1);
2263 return 1;
2264 }
2265
2266 /* Update the input buffer data. */
2267 buf += sent;
2268 send_len = buf_len - sent;
2269
2270 /* All the data are sent. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002271 if (sent >= buf_len) {
2272 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002273 return 1; /* Implicitly return the length sent. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002274 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002275
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002276 /* Check if the buffer is available because HAProxy doesn't allocate
Thierry FOURNIER486d52a2015-03-09 17:51:43 +01002277 * the request buffer if its not required.
2278 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002279 if (s->req.buf.size == 0) {
Willy Tarreau581abd32018-10-25 10:21:41 +02002280 if (!si_alloc_ibuf(si, &appctx->buffer_wait))
Christopher Faulet33834b12016-12-19 09:29:06 +01002281 goto hlua_socket_write_yield_return;
Thierry FOURNIER486d52a2015-03-09 17:51:43 +01002282 }
2283
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002284 /* Check for available space. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002285 len = b_room(&s->req.buf);
Christopher Faulet33834b12016-12-19 09:29:06 +01002286 if (len <= 0) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002287 goto hlua_socket_write_yield_return;
Christopher Faulet33834b12016-12-19 09:29:06 +01002288 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002289
2290 /* send data */
2291 if (len < send_len)
2292 send_len = len;
Thierry FOURNIER66b89192018-05-27 01:14:47 +02002293 len = ci_putblk(&s->req, buf, send_len);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002294
2295 /* "Not enough space" (-1), "Buffer too little to contain
2296 * the data" (-2) are not expected because the available length
2297 * is tested.
2298 * Other unknown error are also not expected.
2299 */
2300 if (len <= 0) {
Willy Tarreaubc18da12015-03-13 14:00:47 +01002301 if (len == -1)
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002302 s->req.flags |= CF_WAKE_WRITE;
Willy Tarreaubc18da12015-03-13 14:00:47 +01002303
sada05ed3302018-05-11 11:48:18 -07002304 MAY_LJMP(hlua_socket_close_helper(L));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002305 lua_pop(L, 1);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002306 lua_pushinteger(L, -1);
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002307 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002308 return 1;
2309 }
2310
2311 /* update buffers. */
Thierry FOURNIER101b9762018-05-27 01:27:40 +02002312 appctx_wakeup(appctx);
Willy Tarreaude70fa12015-09-26 11:25:05 +02002313
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002314 s->req.rex = TICK_ETERNITY;
2315 s->res.wex = TICK_ETERNITY;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002316
2317 /* Update length sent. */
2318 lua_pop(L, 1);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002319 lua_pushinteger(L, sent + len);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002320
2321 /* All the data buffer is sent ? */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002322 if (sent + len >= buf_len) {
2323 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002324 return 1;
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002325 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002326
2327hlua_socket_write_yield_return:
Thierry FOURNIERba42fcd2018-05-27 00:59:48 +02002328 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task)) {
2329 xref_unlock(&socket->xref, peer);
2330 WILL_LJMP(luaL_error(L, "out of memory"));
2331 }
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002332 xref_unlock(&socket->xref, peer);
Willy Tarreau9635e032018-10-16 17:52:55 +02002333 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_write_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002334 return 0;
2335}
2336
2337/* This function initiate the send of data. It just check the input
2338 * parameters and push an integer in the Lua stack that contain the
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002339 * amount of data written to the buffer. This is used by the function
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002340 * "hlua_socket_write_yield" that can yield.
2341 *
2342 * The Lua function gets between 3 and 4 parameters. The first one is
2343 * the associated object. The second is a string buffer. The third is
2344 * a facultative integer that represents where is the buffer position
2345 * of the start of the data that can send. The first byte is the
2346 * position "1". The default value is "1". The fourth argument is a
2347 * facultative integer that represents where is the buffer position
2348 * of the end of the data that can send. The default is the last byte.
2349 */
2350static int hlua_socket_send(struct lua_State *L)
2351{
2352 int i;
2353 int j;
2354 const char *buf;
2355 size_t buf_len;
2356
2357 /* Check number of arguments. */
2358 if (lua_gettop(L) < 2 || lua_gettop(L) > 4)
2359 WILL_LJMP(luaL_error(L, "'send' needs between 2 and 4 arguments"));
2360
2361 /* Get the string. */
2362 buf = MAY_LJMP(luaL_checklstring(L, 2, &buf_len));
2363
2364 /* Get and check j. */
2365 if (lua_gettop(L) == 4) {
2366 j = MAY_LJMP(luaL_checkinteger(L, 4));
2367 if (j < 0)
2368 j = buf_len + j + 1;
2369 if (j > buf_len)
2370 j = buf_len + 1;
2371 lua_pop(L, 1);
2372 }
2373 else
2374 j = buf_len;
2375
2376 /* Get and check i. */
2377 if (lua_gettop(L) == 3) {
2378 i = MAY_LJMP(luaL_checkinteger(L, 3));
2379 if (i < 0)
2380 i = buf_len + i + 1;
2381 if (i > buf_len)
2382 i = buf_len + 1;
2383 lua_pop(L, 1);
2384 } else
2385 i = 1;
2386
2387 /* Check bth i and j. */
2388 if (i > j) {
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002389 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002390 return 1;
2391 }
2392 if (i == 0 && j == 0) {
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002393 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002394 return 1;
2395 }
2396 if (i == 0)
2397 i = 1;
2398 if (j == 0)
2399 j = 1;
2400
2401 /* Pop the string. */
2402 lua_pop(L, 1);
2403
2404 /* Update the buffer length. */
2405 buf += i - 1;
2406 buf_len = j - i + 1;
2407 lua_pushlstring(L, buf, buf_len);
2408
2409 /* This unsigned is used to remember the amount of sent data. */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002410 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002411
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002412 return MAY_LJMP(hlua_socket_write_yield(L, 0, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002413}
2414
Willy Tarreau22b0a682015-06-17 19:43:49 +02002415#define SOCKET_INFO_MAX_LEN sizeof("[0000:0000:0000:0000:0000:0000:0000:0000]:12345")
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002416__LJMP static inline int hlua_socket_info(struct lua_State *L, struct sockaddr_storage *addr)
2417{
2418 static char buffer[SOCKET_INFO_MAX_LEN];
2419 int ret;
2420 int len;
2421 char *p;
2422
2423 ret = addr_to_str(addr, buffer+1, SOCKET_INFO_MAX_LEN-1);
2424 if (ret <= 0) {
2425 lua_pushnil(L);
2426 return 1;
2427 }
2428
2429 if (ret == AF_UNIX) {
2430 lua_pushstring(L, buffer+1);
2431 return 1;
2432 }
2433 else if (ret == AF_INET6) {
2434 buffer[0] = '[';
2435 len = strlen(buffer);
2436 buffer[len] = ']';
2437 len++;
2438 buffer[len] = ':';
2439 len++;
2440 p = buffer;
2441 }
2442 else if (ret == AF_INET) {
2443 p = buffer + 1;
2444 len = strlen(p);
2445 p[len] = ':';
2446 len++;
2447 }
2448 else {
2449 lua_pushnil(L);
2450 return 1;
2451 }
2452
2453 if (port_to_str(addr, p + len, SOCKET_INFO_MAX_LEN-1 - len) <= 0) {
2454 lua_pushnil(L);
2455 return 1;
2456 }
2457
2458 lua_pushstring(L, p);
2459 return 1;
2460}
2461
2462/* Returns information about the peer of the connection. */
2463__LJMP static int hlua_socket_getpeername(struct lua_State *L)
2464{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002465 struct hlua_socket *socket;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002466 struct xref *peer;
2467 struct appctx *appctx;
2468 struct stream_interface *si;
2469 struct stream *s;
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002470 int ret;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002471
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002472 MAY_LJMP(check_args(L, 1, "getpeername"));
2473
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002474 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002475
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002476 /* Check if we run on the same thread than the xreator thread.
2477 * We cannot access to the socket if the thread is different.
2478 */
2479 if (socket->tid != tid)
2480 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2481
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002482 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002483 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002484 if (!peer) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002485 lua_pushnil(L);
2486 return 1;
2487 }
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002488 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2489 si = appctx->owner;
2490 s = si_strm(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002491
Willy Tarreau5a0b25d2019-07-18 18:01:14 +02002492 if (!s->target_addr) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002493 xref_unlock(&socket->xref, peer);
Willy Tarreaua71f6422016-11-16 17:00:14 +01002494 lua_pushnil(L);
2495 return 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002496 }
2497
Willy Tarreau5a0b25d2019-07-18 18:01:14 +02002498 ret = MAY_LJMP(hlua_socket_info(L, s->target_addr));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002499 xref_unlock(&socket->xref, peer);
2500 return ret;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002501}
2502
2503/* Returns information about my connection side. */
2504static int hlua_socket_getsockname(struct lua_State *L)
2505{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002506 struct hlua_socket *socket;
2507 struct connection *conn;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002508 struct appctx *appctx;
2509 struct xref *peer;
2510 struct stream_interface *si;
2511 struct stream *s;
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002512 int ret;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002513
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002514 MAY_LJMP(check_args(L, 1, "getsockname"));
2515
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002516 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002517
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002518 /* Check if we run on the same thread than the xreator thread.
2519 * We cannot access to the socket if the thread is different.
2520 */
2521 if (socket->tid != tid)
2522 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2523
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002524 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002525 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002526 if (!peer) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002527 lua_pushnil(L);
2528 return 1;
2529 }
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002530 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2531 si = appctx->owner;
2532 s = si_strm(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002533
Olivier Houchard9aaf7782017-09-13 18:30:23 +02002534 conn = cs_conn(objt_cs(s->si[1].end));
Willy Tarreau5a0b25d2019-07-18 18:01:14 +02002535 if (!conn || !conn_get_src(conn)) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002536 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002537 lua_pushnil(L);
2538 return 1;
2539 }
2540
Willy Tarreau9da9a6f2019-07-17 14:49:44 +02002541 ret = hlua_socket_info(L, conn->src);
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002542 xref_unlock(&socket->xref, peer);
2543 return ret;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002544}
2545
2546/* This struct define the applet. */
Willy Tarreau30576452015-04-13 13:50:30 +02002547static struct applet update_applet = {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002548 .obj_type = OBJ_TYPE_APPLET,
2549 .name = "<LUA_TCP>",
2550 .fct = hlua_socket_handler,
2551 .release = hlua_socket_release,
2552};
2553
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002554__LJMP static int hlua_socket_connect_yield(struct lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002555{
2556 struct hlua_socket *socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry Fournier4234dbd2020-11-28 13:18:23 +01002557 struct hlua *hlua;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002558 struct xref *peer;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002559 struct appctx *appctx;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002560 struct stream_interface *si;
2561 struct stream *s;
2562
Thierry Fournier4234dbd2020-11-28 13:18:23 +01002563 /* Get hlua struct, or NULL if we execute from main lua state */
2564 hlua = hlua_gethlua(L);
2565 if (!hlua)
2566 return 0;
2567
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002568 /* Check if we run on the same thread than the xreator thread.
2569 * We cannot access to the socket if the thread is different.
2570 */
2571 if (socket->tid != tid)
2572 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2573
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002574 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002575 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002576 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002577 lua_pushnil(L);
2578 lua_pushstring(L, "Can't connect");
2579 return 2;
2580 }
2581 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2582 si = appctx->owner;
2583 s = si_strm(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002584
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002585 /* Check if we run on the same thread than the xreator thread.
2586 * We cannot access to the socket if the thread is different.
2587 */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002588 if (socket->tid != tid) {
2589 xref_unlock(&socket->xref, peer);
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002590 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002591 }
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002592
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002593 /* Check for connection close. */
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002594 if (!hlua || channel_output_closed(&s->req)) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002595 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002596 lua_pushnil(L);
2597 lua_pushstring(L, "Can't connect");
2598 return 2;
2599 }
2600
Willy Tarreaue09101e2018-10-16 17:37:12 +02002601 appctx = __objt_appctx(s->si[0].end);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002602
2603 /* Check for connection established. */
Thierry FOURNIER18d09902016-12-16 09:25:38 +01002604 if (appctx->ctx.hlua_cosocket.connected) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002605 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002606 lua_pushinteger(L, 1);
2607 return 1;
2608 }
2609
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002610 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task)) {
2611 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002612 WILL_LJMP(luaL_error(L, "out of memory error"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002613 }
2614 xref_unlock(&socket->xref, peer);
Willy Tarreau9635e032018-10-16 17:52:55 +02002615 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_connect_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002616 return 0;
2617}
2618
2619/* This function fail or initite the connection. */
2620__LJMP static int hlua_socket_connect(struct lua_State *L)
2621{
2622 struct hlua_socket *socket;
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002623 int port = -1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002624 const char *ip;
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002625 struct hlua *hlua;
2626 struct appctx *appctx;
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002627 int low, high;
2628 struct sockaddr_storage *addr;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002629 struct xref *peer;
2630 struct stream_interface *si;
2631 struct stream *s;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002632
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002633 if (lua_gettop(L) < 2)
2634 WILL_LJMP(luaL_error(L, "connect: need at least 2 arguments"));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002635
2636 /* Get args. */
2637 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002638
2639 /* Check if we run on the same thread than the xreator thread.
2640 * We cannot access to the socket if the thread is different.
2641 */
2642 if (socket->tid != tid)
2643 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2644
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002645 ip = MAY_LJMP(luaL_checkstring(L, 2));
Tim Duesterhus6edab862018-01-06 19:04:45 +01002646 if (lua_gettop(L) >= 3) {
2647 luaL_Buffer b;
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002648 port = MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002649
Tim Duesterhus6edab862018-01-06 19:04:45 +01002650 /* Force the ip to end with a colon, to support IPv6 addresses
2651 * that are not enclosed within square brackets.
2652 */
2653 if (port > 0) {
2654 luaL_buffinit(L, &b);
2655 luaL_addstring(&b, ip);
2656 luaL_addchar(&b, ':');
2657 luaL_pushresult(&b);
2658 ip = lua_tolstring(L, lua_gettop(L), NULL);
2659 }
2660 }
2661
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002662 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002663 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002664 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002665 lua_pushnil(L);
2666 return 1;
2667 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002668
2669 /* Parse ip address. */
Willy Tarreau5fc93282020-09-16 18:25:03 +02002670 addr = str2sa_range(ip, NULL, &low, &high, NULL, NULL, NULL, NULL, NULL, PA_O_PORT_OK | PA_O_STREAM);
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002671 if (!addr) {
2672 xref_unlock(&socket->xref, peer);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002673 WILL_LJMP(luaL_error(L, "connect: cannot parse destination address '%s'", ip));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002674 }
Willy Tarreau9da9a6f2019-07-17 14:49:44 +02002675
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002676 /* Set port. */
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002677 if (low == 0) {
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002678 if (addr->ss_family == AF_INET) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002679 if (port == -1) {
2680 xref_unlock(&socket->xref, peer);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002681 WILL_LJMP(luaL_error(L, "connect: port missing"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002682 }
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002683 ((struct sockaddr_in *)addr)->sin_port = htons(port);
2684 } else if (addr->ss_family == AF_INET6) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002685 if (port == -1) {
2686 xref_unlock(&socket->xref, peer);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002687 WILL_LJMP(luaL_error(L, "connect: port missing"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002688 }
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002689 ((struct sockaddr_in6 *)addr)->sin6_port = htons(port);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002690 }
2691 }
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002692
Willy Tarreau5a0b25d2019-07-18 18:01:14 +02002693 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2694 si = appctx->owner;
2695 s = si_strm(si);
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002696
Willy Tarreau9b7587a2020-10-15 07:32:10 +02002697 if (!sockaddr_alloc(&s->target_addr, addr, sizeof(*addr))) {
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002698 xref_unlock(&socket->xref, peer);
2699 WILL_LJMP(luaL_error(L, "connect: internal error"));
2700 }
Willy Tarreau5a0b25d2019-07-18 18:01:14 +02002701 s->flags |= SF_ADDR_SET;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002702
Thierry Fournier4234dbd2020-11-28 13:18:23 +01002703 /* Get hlua struct, or NULL if we execute from main lua state */
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002704 hlua = hlua_gethlua(L);
Thierry Fournier4234dbd2020-11-28 13:18:23 +01002705 if (!hlua)
2706 return 0;
Willy Tarreaubdc97a82015-08-24 15:42:28 +02002707
2708 /* inform the stream that we want to be notified whenever the
2709 * connection completes.
2710 */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002711 si_cant_get(&s->si[0]);
Willy Tarreau3367d412018-11-15 10:57:41 +01002712 si_rx_endp_more(&s->si[0]);
Thierry FOURNIER8c8fbbe2015-09-26 17:02:35 +02002713 appctx_wakeup(appctx);
Willy Tarreaubdc97a82015-08-24 15:42:28 +02002714
Willy Tarreauf31af932020-01-14 09:59:38 +01002715 hlua->gc_count++;
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +02002716
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002717 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task)) {
2718 xref_unlock(&socket->xref, peer);
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002719 WILL_LJMP(luaL_error(L, "out of memory"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002720 }
2721 xref_unlock(&socket->xref, peer);
PiBa-NL706d5ee2018-05-05 23:51:42 +02002722
2723 task_wakeup(s->task, TASK_WOKEN_INIT);
2724 /* Return yield waiting for connection. */
2725
Willy Tarreau9635e032018-10-16 17:52:55 +02002726 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_connect_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002727
2728 return 0;
2729}
2730
Baptiste Assmann84bb4932015-03-02 21:40:06 +01002731#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002732__LJMP static int hlua_socket_connect_ssl(struct lua_State *L)
2733{
2734 struct hlua_socket *socket;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002735 struct xref *peer;
2736 struct appctx *appctx;
2737 struct stream_interface *si;
2738 struct stream *s;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002739
2740 MAY_LJMP(check_args(L, 3, "connect_ssl"));
2741 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002742
2743 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002744 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002745 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002746 lua_pushnil(L);
2747 return 1;
2748 }
2749 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2750 si = appctx->owner;
2751 s = si_strm(si);
2752
Amaury Denoyelle704ba1d2021-03-24 17:57:47 +01002753 s->target = &socket_ssl->obj_type;
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002754 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002755 return MAY_LJMP(hlua_socket_connect(L));
2756}
Baptiste Assmann84bb4932015-03-02 21:40:06 +01002757#endif
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002758
2759__LJMP static int hlua_socket_setoption(struct lua_State *L)
2760{
2761 return 0;
2762}
2763
2764__LJMP static int hlua_socket_settimeout(struct lua_State *L)
2765{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002766 struct hlua_socket *socket;
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002767 int tmout;
Mark Lakes56cc1252018-03-27 09:48:06 +02002768 double dtmout;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002769 struct xref *peer;
2770 struct appctx *appctx;
2771 struct stream_interface *si;
2772 struct stream *s;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002773
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002774 MAY_LJMP(check_args(L, 2, "settimeout"));
2775
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002776 socket = MAY_LJMP(hlua_checksocket(L, 1));
Mark Lakes56cc1252018-03-27 09:48:06 +02002777
Cyril Bonté7ee465f2018-08-19 22:08:50 +02002778 /* convert the timeout to millis */
2779 dtmout = MAY_LJMP(luaL_checknumber(L, 2)) * 1000;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002780
Thierry Fournier17a921b2018-03-08 09:59:02 +01002781 /* Check for negative values */
Mark Lakes56cc1252018-03-27 09:48:06 +02002782 if (dtmout < 0)
Thierry Fournier17a921b2018-03-08 09:59:02 +01002783 WILL_LJMP(luaL_error(L, "settimeout: cannot set negatives values"));
2784
Mark Lakes56cc1252018-03-27 09:48:06 +02002785 if (dtmout > INT_MAX) /* overflow check */
Cyril Bonté7ee465f2018-08-19 22:08:50 +02002786 WILL_LJMP(luaL_error(L, "settimeout: cannot set values larger than %d ms", INT_MAX));
Mark Lakes56cc1252018-03-27 09:48:06 +02002787
2788 tmout = MS_TO_TICKS((int)dtmout);
Cyril Bonté7ee465f2018-08-19 22:08:50 +02002789 if (tmout == 0)
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05002790 tmout++; /* very small timeouts are adjusted to a minimum of 1ms */
Mark Lakes56cc1252018-03-27 09:48:06 +02002791
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002792 /* Check if we run on the same thread than the xreator thread.
2793 * We cannot access to the socket if the thread is different.
2794 */
2795 if (socket->tid != tid)
2796 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2797
Mark Lakes56cc1252018-03-27 09:48:06 +02002798 /* check for connection break. If some data were read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002799 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002800 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002801 hlua_pusherror(L, "socket: not yet initialised, you can't set timeouts.");
2802 WILL_LJMP(lua_error(L));
2803 return 0;
2804 }
2805 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2806 si = appctx->owner;
2807 s = si_strm(si);
2808
Cyril Bonté7bb63452018-08-17 23:51:02 +02002809 s->sess->fe->timeout.connect = tmout;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002810 s->req.rto = tmout;
2811 s->req.wto = tmout;
2812 s->res.rto = tmout;
2813 s->res.wto = tmout;
Cyril Bonté7bb63452018-08-17 23:51:02 +02002814 s->req.rex = tick_add_ifset(now_ms, tmout);
2815 s->req.wex = tick_add_ifset(now_ms, tmout);
2816 s->res.rex = tick_add_ifset(now_ms, tmout);
2817 s->res.wex = tick_add_ifset(now_ms, tmout);
2818
2819 s->task->expire = tick_add_ifset(now_ms, tmout);
2820 task_queue(s->task);
2821
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002822 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002823
Thierry Fourniere9636f12018-03-08 09:54:32 +01002824 lua_pushinteger(L, 1);
Tim Duesterhus119a5f12018-01-06 19:16:25 +01002825 return 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002826}
2827
2828__LJMP static int hlua_socket_new(lua_State *L)
2829{
2830 struct hlua_socket *socket;
2831 struct appctx *appctx;
Willy Tarreau15b5e142015-04-04 14:38:25 +02002832 struct session *sess;
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002833 struct stream *strm;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002834
2835 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002836 if (!lua_checkstack(L, 3)) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002837 hlua_pusherror(L, "socket: full stack");
2838 goto out_fail_conf;
2839 }
2840
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002841 /* Create the object: obj[0] = userdata. */
2842 lua_newtable(L);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002843 socket = MAY_LJMP(lua_newuserdata(L, sizeof(*socket)));
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002844 lua_rawseti(L, -2, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002845 memset(socket, 0, sizeof(*socket));
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002846 socket->tid = tid;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002847
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05002848 /* Check if the various memory pools are initialized. */
Willy Tarreaubafbe012017-11-24 17:34:44 +01002849 if (!pool_head_stream || !pool_head_buffer) {
Thierry FOURNIER4a6170c2015-03-09 17:07:10 +01002850 hlua_pusherror(L, "socket: uninitialized pools.");
2851 goto out_fail_conf;
2852 }
2853
Willy Tarreau87b09662015-04-03 00:22:06 +02002854 /* Pop a class stream metatable and affect it to the userdata. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002855 lua_rawgeti(L, LUA_REGISTRYINDEX, class_socket_ref);
2856 lua_setmetatable(L, -2);
2857
Willy Tarreaud420a972015-04-06 00:39:18 +02002858 /* Create the applet context */
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01002859 appctx = appctx_new(&update_applet, tid_bit);
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002860 if (!appctx) {
2861 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaufeb76402015-04-03 14:10:06 +02002862 goto out_fail_conf;
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002863 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002864
Thierry FOURNIER18d09902016-12-16 09:25:38 +01002865 appctx->ctx.hlua_cosocket.connected = 0;
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02002866 appctx->ctx.hlua_cosocket.die = 0;
Thierry FOURNIER18d09902016-12-16 09:25:38 +01002867 LIST_INIT(&appctx->ctx.hlua_cosocket.wake_on_write);
2868 LIST_INIT(&appctx->ctx.hlua_cosocket.wake_on_read);
Willy Tarreaub2bf8332015-04-04 15:58:58 +02002869
Willy Tarreaud420a972015-04-06 00:39:18 +02002870 /* Now create a session, task and stream for this applet */
Amaury Denoyelle239fdbf2021-03-24 10:22:03 +01002871 sess = session_new(socket_proxy, NULL, &appctx->obj_type);
Willy Tarreaud420a972015-04-06 00:39:18 +02002872 if (!sess) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002873 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaud420a972015-04-06 00:39:18 +02002874 goto out_fail_sess;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002875 }
2876
Christopher Faulet26256f82020-09-14 11:40:13 +02002877 strm = stream_new(sess, &appctx->obj_type, &BUF_NULL);
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002878 if (!strm) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002879 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaud420a972015-04-06 00:39:18 +02002880 goto out_fail_stream;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002881 }
2882
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002883 /* Initialise cross reference between stream and Lua socket object. */
2884 xref_create(&socket->xref, &appctx->ctx.hlua_cosocket.xref);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002885
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002886 /* Configure "right" stream interface. this "si" is used to connect
2887 * and retrieve data from the server. The connection is initialized
2888 * with the "struct server".
2889 */
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002890 si_set_state(&strm->si[1], SI_ST_ASS);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002891
2892 /* Force destination server. */
Willy Tarreau5a0b25d2019-07-18 18:01:14 +02002893 strm->flags |= SF_DIRECT | SF_ASSIGNED | SF_BE_ASSIGNED;
Amaury Denoyelle704ba1d2021-03-24 17:57:47 +01002894 strm->target = &socket_tcp->obj_type;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002895
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002896 return 1;
2897
Willy Tarreaud420a972015-04-06 00:39:18 +02002898 out_fail_stream:
Willy Tarreau11c36242015-04-04 15:54:03 +02002899 session_free(sess);
Willy Tarreaud420a972015-04-06 00:39:18 +02002900 out_fail_sess:
2901 appctx_free(appctx);
2902 out_fail_conf:
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002903 WILL_LJMP(lua_error(L));
2904 return 0;
2905}
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01002906
2907/*
2908 *
2909 *
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002910 * Class Channel
2911 *
2912 *
2913 */
2914
2915/* Returns the struct hlua_channel join to the class channel in the
2916 * stack entry "ud" or throws an argument error.
2917 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002918__LJMP static struct channel *hlua_checkchannel(lua_State *L, int ud)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002919{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002920 return MAY_LJMP(hlua_checkudata(L, ud, class_channel_ref));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002921}
2922
Willy Tarreau47860ed2015-03-10 14:07:50 +01002923/* Pushes the channel onto the top of the stack. If the stask does not have a
2924 * free slots, the function fails and returns 0;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002925 */
Willy Tarreau2a71af42015-03-10 13:51:50 +01002926static int hlua_channel_new(lua_State *L, struct channel *channel)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002927{
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002928 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002929 if (!lua_checkstack(L, 3))
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002930 return 0;
2931
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002932 lua_newtable(L);
Willy Tarreau47860ed2015-03-10 14:07:50 +01002933 lua_pushlightuserdata(L, channel);
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002934 lua_rawseti(L, -2, 0);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002935
2936 /* Pop a class sesison metatable and affect it to the userdata. */
2937 lua_rawgeti(L, LUA_REGISTRYINDEX, class_channel_ref);
2938 lua_setmetatable(L, -2);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002939 return 1;
2940}
2941
2942/* Duplicate all the data present in the input channel and put it
2943 * in a string LUA variables. Returns -1 and push a nil value in
2944 * the stack if the channel is closed and all the data are consumed,
2945 * returns 0 if no data are available, otherwise it returns the length
Ilya Shipitsind4259502020-04-08 01:07:56 +05002946 * of the built string.
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002947 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002948static inline int _hlua_channel_dup(struct channel *chn, lua_State *L)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002949{
2950 char *blk1;
2951 char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02002952 size_t len1;
2953 size_t len2;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002954 int ret;
2955 luaL_Buffer b;
2956
Willy Tarreau06d80a92017-10-19 14:32:15 +02002957 ret = ci_getblk_nc(chn, &blk1, &len1, &blk2, &len2);
Christopher Faulet055310f2021-08-05 11:58:37 +02002958 if (unlikely(ret <= 0)) {
2959 if (ret < 0 || HLUA_CANT_YIELD(hlua_gethlua(L))) {
2960 lua_pushnil(L);
2961 return -1;
2962 }
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002963 return 0;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002964 }
2965
2966 luaL_buffinit(L, &b);
2967 luaL_addlstring(&b, blk1, len1);
2968 if (unlikely(ret == 2))
2969 luaL_addlstring(&b, blk2, len2);
2970 luaL_pushresult(&b);
2971
2972 if (unlikely(ret == 2))
2973 return len1 + len2;
2974 return len1;
2975}
2976
2977/* "_hlua_channel_dup" wrapper. If no data are available, it returns
2978 * a yield. This function keep the data in the buffer.
2979 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002980__LJMP static int hlua_channel_dup_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002981{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002982 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002983
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002984 chn = MAY_LJMP(hlua_checkchannel(L, 1));
2985
Christopher Faulet1bb6afa2021-03-08 17:57:53 +01002986 if (IS_HTX_STRM(chn_strm(chn))) {
Thierry Fournier77016da2020-08-15 14:35:51 +02002987 lua_pushfstring(L, "Cannot manipulate HAProxy channels in HTTP mode.");
Christopher Faulet3f829a42018-12-13 21:56:45 +01002988 WILL_LJMP(lua_error(L));
Thierry Fournier77016da2020-08-15 14:35:51 +02002989 }
Christopher Faulet3f829a42018-12-13 21:56:45 +01002990
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002991 if (_hlua_channel_dup(chn, L) == 0)
Willy Tarreau9635e032018-10-16 17:52:55 +02002992 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_dup_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002993 return 1;
2994}
2995
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002996/* Check arguments for the function "hlua_channel_dup_yield". */
2997__LJMP static int hlua_channel_dup(lua_State *L)
2998{
2999 MAY_LJMP(check_args(L, 1, "dup"));
3000 MAY_LJMP(hlua_checkchannel(L, 1));
3001 return MAY_LJMP(hlua_channel_dup_yield(L, 0, 0));
3002}
3003
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003004/* "_hlua_channel_dup" wrapper. If no data are available, it returns
3005 * a yield. This function consumes the data in the buffer. It returns
3006 * a string containing the data or a nil pointer if no data are available
3007 * and the channel is closed.
3008 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003009__LJMP static int hlua_channel_get_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003010{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003011 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003012 int ret;
3013
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003014 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003015
Christopher Faulet1bb6afa2021-03-08 17:57:53 +01003016 if (IS_HTX_STRM(chn_strm(chn))) {
Thierry Fournier77016da2020-08-15 14:35:51 +02003017 lua_pushfstring(L, "Cannot manipulate HAProxy channels in HTTP mode.");
Christopher Faulet3f829a42018-12-13 21:56:45 +01003018 WILL_LJMP(lua_error(L));
Thierry Fournier77016da2020-08-15 14:35:51 +02003019 }
Christopher Faulet3f829a42018-12-13 21:56:45 +01003020
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003021 ret = _hlua_channel_dup(chn, L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003022 if (unlikely(ret == 0))
Willy Tarreau9635e032018-10-16 17:52:55 +02003023 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_get_yield, TICK_ETERNITY, 0));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003024
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003025 if (unlikely(ret == -1))
3026 return 1;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003027
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003028 b_sub(&chn->buf, ret);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003029 return 1;
3030}
3031
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003032/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003033__LJMP static int hlua_channel_get(lua_State *L)
3034{
3035 MAY_LJMP(check_args(L, 1, "get"));
3036 MAY_LJMP(hlua_checkchannel(L, 1));
3037 return MAY_LJMP(hlua_channel_get_yield(L, 0, 0));
3038}
3039
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003040/* This functions consumes and returns one line. If the channel is closed,
3041 * and the last data does not contains a final '\n', the data are returned
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003042 * without the final '\n'. When no more data are available, it returns nil
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003043 * value.
3044 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003045__LJMP static int hlua_channel_getline_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003046{
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003047 char *blk1;
3048 char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003049 size_t len1;
3050 size_t len2;
3051 size_t len;
Willy Tarreau47860ed2015-03-10 14:07:50 +01003052 struct channel *chn;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003053 int ret;
3054 luaL_Buffer b;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003055
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003056 chn = MAY_LJMP(hlua_checkchannel(L, 1));
3057
Christopher Faulet1bb6afa2021-03-08 17:57:53 +01003058 if (IS_HTX_STRM(chn_strm(chn))) {
Thierry Fournier77016da2020-08-15 14:35:51 +02003059 lua_pushfstring(L, "Cannot manipulate HAProxy channels in HTTP mode.");
Christopher Faulet3f829a42018-12-13 21:56:45 +01003060 WILL_LJMP(lua_error(L));
Thierry Fournier77016da2020-08-15 14:35:51 +02003061 }
Christopher Faulet3f829a42018-12-13 21:56:45 +01003062
Willy Tarreau06d80a92017-10-19 14:32:15 +02003063 ret = ci_getline_nc(chn, &blk1, &len1, &blk2, &len2);
Christopher Faulet055310f2021-08-05 11:58:37 +02003064 if (ret == 0) {
3065 if (HLUA_CANT_YIELD(hlua_gethlua(L))) {
3066 _hlua_channel_dup(chn, L);
3067 return 1;
3068 }
Willy Tarreau9635e032018-10-16 17:52:55 +02003069 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_getline_yield, TICK_ETERNITY, 0));
Christopher Faulet055310f2021-08-05 11:58:37 +02003070 }
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003071
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003072 if (ret == -1) {
3073 lua_pushnil(L);
3074 return 1;
3075 }
3076
3077 luaL_buffinit(L, &b);
3078 luaL_addlstring(&b, blk1, len1);
3079 len = len1;
3080 if (unlikely(ret == 2)) {
3081 luaL_addlstring(&b, blk2, len2);
3082 len += len2;
3083 }
3084 luaL_pushresult(&b);
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003085 b_rep_blk(&chn->buf, ci_head(chn), ci_head(chn) + len, NULL, 0);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003086 return 1;
3087}
3088
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003089/* Check arguments for the function "hlua_channel_getline_yield". */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003090__LJMP static int hlua_channel_getline(lua_State *L)
3091{
3092 MAY_LJMP(check_args(L, 1, "getline"));
3093 MAY_LJMP(hlua_checkchannel(L, 1));
3094 return MAY_LJMP(hlua_channel_getline_yield(L, 0, 0));
3095}
3096
Christopher Faulet3b7bc3e2021-08-06 09:59:49 +02003097/* This function takes a string as argument, and append it at the input side of
3098 * channel. If data cannot be copied, because there is not enough space to do so
3099 * or because the channel is closed, it returns -1. Otherwise, it returns the
3100 * amount of data written (the string length). This function does not yield.
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003101 */
Christopher Faulet3b7bc3e2021-08-06 09:59:49 +02003102__LJMP static int hlua_channel_append(lua_State *L)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003103{
Christopher Faulet3b7bc3e2021-08-06 09:59:49 +02003104 struct channel *chn;
3105 const char *str;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003106 size_t len;
Christopher Faulet3b7bc3e2021-08-06 09:59:49 +02003107
3108 MAY_LJMP(check_args(L, 2, "append"));
3109 chn = MAY_LJMP(hlua_checkchannel(L, 1));
3110 str = MAY_LJMP(luaL_checklstring(L, 2, &len));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003111
Christopher Faulet1bb6afa2021-03-08 17:57:53 +01003112 if (IS_HTX_STRM(chn_strm(chn))) {
Thierry Fournier77016da2020-08-15 14:35:51 +02003113 lua_pushfstring(L, "Cannot manipulate HAProxy channels in HTTP mode.");
Christopher Faulet3f829a42018-12-13 21:56:45 +01003114 WILL_LJMP(lua_error(L));
Thierry Fournier77016da2020-08-15 14:35:51 +02003115 }
Christopher Faulet3f829a42018-12-13 21:56:45 +01003116
Christopher Faulet3b7bc3e2021-08-06 09:59:49 +02003117 if (len > c_room(chn) || ci_putblk(chn, str, len) < 0)
3118 lua_pushinteger(L, -1);
3119 else
3120 lua_pushinteger(L, len);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003121 return 1;
3122}
3123
Christopher Faulet3b7bc3e2021-08-06 09:59:49 +02003124/* The function replaces input data from the channel by the string passed as
3125 * argument. Before clearing the buffer, we take care the copy will be
3126 * possible. It returns the amount of data written (the string length) on
3127 * success or -1 if the copy is not performed. This function does not yield.
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003128 */
3129__LJMP static int hlua_channel_set(lua_State *L)
3130{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003131 struct channel *chn;
Christopher Faulet3b7bc3e2021-08-06 09:59:49 +02003132 const char *str;
3133 size_t len;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003134
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003135 MAY_LJMP(check_args(L, 2, "set"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003136 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Christopher Faulet3b7bc3e2021-08-06 09:59:49 +02003137 str = MAY_LJMP(luaL_checklstring(L, 2, &len));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003138
Christopher Faulet1bb6afa2021-03-08 17:57:53 +01003139 if (IS_HTX_STRM(chn_strm(chn))) {
Thierry Fournier77016da2020-08-15 14:35:51 +02003140 lua_pushfstring(L, "Cannot manipulate HAProxy channels in HTTP mode.");
Christopher Faulet3f829a42018-12-13 21:56:45 +01003141 WILL_LJMP(lua_error(L));
Thierry Fournier77016da2020-08-15 14:35:51 +02003142 }
Christopher Faulet3f829a42018-12-13 21:56:45 +01003143
Christopher Faulet3b7bc3e2021-08-06 09:59:49 +02003144 /* Be sure we can copied the string once input data will be removed. */
3145 if (len > ci_data(chn) || channel_input_closed(chn))
3146 lua_pushinteger(L, -1);
3147 else {
3148 b_set_data(&chn->buf, co_data(chn));
3149 if (ci_putblk(chn, str, len) < 0)
3150 lua_pushinteger(L, -1);
3151 else
3152 lua_pushinteger(L, len);
3153 }
3154 return -1;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003155}
3156
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003157/* Append data in the output side of the buffer. This data is immediately
3158 * sent. The function returns the amount of data written. If the buffer
3159 * cannot contain the data, the function yields. The function returns -1
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003160 * if the channel is closed.
3161 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003162__LJMP static int hlua_channel_send_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003163{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003164 struct channel *chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003165 size_t len;
3166 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
3167 int l = MAY_LJMP(luaL_checkinteger(L, 3));
3168 int max;
Thierry Fournier4234dbd2020-11-28 13:18:23 +01003169 struct hlua *hlua;
3170
3171 /* Get hlua struct, or NULL if we execute from main lua state */
3172 hlua = hlua_gethlua(L);
3173 if (!hlua) {
3174 lua_pushnil(L);
3175 return 1;
3176 }
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003177
Christopher Faulet1bb6afa2021-03-08 17:57:53 +01003178 if (IS_HTX_STRM(chn_strm(chn))) {
Thierry Fournier77016da2020-08-15 14:35:51 +02003179 lua_pushfstring(L, "Cannot manipulate HAProxy channels in HTTP mode.");
Christopher Faulet3f829a42018-12-13 21:56:45 +01003180 WILL_LJMP(lua_error(L));
Thierry Fournier77016da2020-08-15 14:35:51 +02003181 }
Christopher Faulet3f829a42018-12-13 21:56:45 +01003182
Willy Tarreau47860ed2015-03-10 14:07:50 +01003183 if (unlikely(channel_output_closed(chn))) {
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003184 lua_pushinteger(L, -1);
3185 return 1;
3186 }
3187
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003188 /* Check if the buffer is available because HAProxy doesn't allocate
Thierry FOURNIER3e3a6082015-03-05 17:06:12 +01003189 * the request buffer if its not required.
3190 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003191 if (chn->buf.size == 0) {
Christopher Faulet055310f2021-08-05 11:58:37 +02003192 if (HLUA_CANT_YIELD(hlua_gethlua(L)))
3193 return 1;
Willy Tarreau4b962a42018-11-15 11:03:21 +01003194 si_rx_buff_blk(chn_prod(chn));
Willy Tarreau9635e032018-10-16 17:52:55 +02003195 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIER3e3a6082015-03-05 17:06:12 +01003196 }
3197
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003198 /* The written data will be immediately sent, so we can check
3199 * the available space without taking in account the reserve.
3200 * The reserve is guaranteed for the processing of incoming
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003201 * data, because the buffer will be flushed.
3202 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003203 max = b_room(&chn->buf);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003204
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003205 /* If there is no space available, and the output buffer is empty.
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003206 * in this case, we cannot add more data, so we cannot yield,
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05003207 * we return the amount of copied data.
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003208 */
Willy Tarreaua79021a2018-06-15 18:07:57 +02003209 if (max == 0 && co_data(chn) == 0)
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003210 return 1;
3211
3212 /* Adjust the real required length. */
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003213 if (max > len - l)
3214 max = len - l;
3215
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003216 /* The buffer available size may be not contiguous. This test
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003217 * detects a non contiguous buffer and realign it.
3218 */
Willy Tarreau3f679992018-06-15 15:06:42 +02003219 if (ci_space_for_replace(chn) < max)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003220 channel_slow_realign(chn, trash.area);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003221
3222 /* Copy input data in the buffer. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003223 max = b_rep_blk(&chn->buf, ci_head(chn), ci_head(chn), str + l, max);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003224
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003225 /* buffer replace considers that the input part is filled.
3226 * so, I must forward these new data in the output part.
3227 */
Willy Tarreaubcbd3932018-06-06 07:13:22 +02003228 c_adv(chn, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003229
3230 l += max;
3231 lua_pop(L, 1);
3232 lua_pushinteger(L, l);
3233
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003234 if (l < len) {
Christopher Faulet055310f2021-08-05 11:58:37 +02003235 /* If there is no space available, and the output buffer is empty.
3236 * in this case, we cannot add more data, so we cannot yield,
3237 * we return the amount of copied data.
3238 */
3239 max = b_room(&chn->buf);
3240 if ((max == 0 && co_data(chn) == 0) || HLUA_CANT_YIELD(hlua_gethlua(L)))
3241 return 1;
3242
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003243 /* If we are waiting for space in the response buffer, we
3244 * must set the flag WAKERESWR. This flag required the task
3245 * wake up if any activity is detected on the response buffer.
3246 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01003247 if (chn->flags & CF_ISRESP)
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003248 HLUA_SET_WAKERESWR(hlua);
Thierry FOURNIER53e08ec2015-03-06 00:35:53 +01003249 else
3250 HLUA_SET_WAKEREQWR(hlua);
Willy Tarreau9635e032018-10-16 17:52:55 +02003251 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003252 }
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003253
3254 return 1;
3255}
3256
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05003257/* Just a wrapper of "_hlua_channel_send". This wrapper permits
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003258 * yield the LUA process, and resume it without checking the
3259 * input arguments.
3260 */
3261__LJMP static int hlua_channel_send(lua_State *L)
3262{
3263 MAY_LJMP(check_args(L, 2, "send"));
3264 lua_pushinteger(L, 0);
3265
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003266 return MAY_LJMP(hlua_channel_send_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003267}
3268
3269/* This function forward and amount of butes. The data pass from
3270 * the input side of the buffer to the output side, and can be
3271 * forwarded. This function never fails.
3272 *
3273 * The Lua function takes an amount of bytes to be forwarded in
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05003274 * input. It returns the number of bytes forwarded.
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003275 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003276__LJMP static int hlua_channel_forward_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003277{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003278 struct channel *chn;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003279 int len;
3280 int l;
3281 int max;
Thierry Fournier4234dbd2020-11-28 13:18:23 +01003282 struct hlua *hlua;
3283
3284 /* Get hlua struct, or NULL if we execute from main lua state */
3285 hlua = hlua_gethlua(L);
3286 if (!hlua)
3287 return 1;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003288
3289 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Christopher Faulet3f829a42018-12-13 21:56:45 +01003290
Christopher Faulet1bb6afa2021-03-08 17:57:53 +01003291 if (IS_HTX_STRM(chn_strm(chn))) {
Thierry Fournier77016da2020-08-15 14:35:51 +02003292 lua_pushfstring(L, "Cannot manipulate HAProxy channels in HTTP mode.");
Christopher Faulet3f829a42018-12-13 21:56:45 +01003293 WILL_LJMP(lua_error(L));
Thierry Fournier77016da2020-08-15 14:35:51 +02003294 }
Christopher Faulet3f829a42018-12-13 21:56:45 +01003295
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003296 len = MAY_LJMP(luaL_checkinteger(L, 2));
3297 l = MAY_LJMP(luaL_checkinteger(L, -1));
3298
3299 max = len - l;
Willy Tarreaua79021a2018-06-15 18:07:57 +02003300 if (max > ci_data(chn))
3301 max = ci_data(chn);
Willy Tarreau47860ed2015-03-10 14:07:50 +01003302 channel_forward(chn, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003303 l += max;
3304
3305 lua_pop(L, 1);
3306 lua_pushinteger(L, l);
3307
3308 /* Check if it miss bytes to forward. */
3309 if (l < len) {
3310 /* The the input channel or the output channel are closed, we
3311 * must return the amount of data forwarded.
3312 */
Christopher Faulet055310f2021-08-05 11:58:37 +02003313 if (channel_input_closed(chn) || channel_output_closed(chn) || HLUA_CANT_YIELD(hlua_gethlua(L)))
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003314 return 1;
3315
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003316 /* If we are waiting for space data in the response buffer, we
3317 * must set the flag WAKERESWR. This flag required the task
3318 * wake up if any activity is detected on the response buffer.
3319 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01003320 if (chn->flags & CF_ISRESP)
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003321 HLUA_SET_WAKERESWR(hlua);
Thierry FOURNIER53e08ec2015-03-06 00:35:53 +01003322 else
3323 HLUA_SET_WAKEREQWR(hlua);
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003324
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003325 /* Otherwise, we can yield waiting for new data in the inpout side. */
Willy Tarreau9635e032018-10-16 17:52:55 +02003326 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_forward_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003327 }
3328
3329 return 1;
3330}
3331
3332/* Just check the input and prepare the stack for the previous
3333 * function "hlua_channel_forward_yield"
3334 */
3335__LJMP static int hlua_channel_forward(lua_State *L)
3336{
3337 MAY_LJMP(check_args(L, 2, "forward"));
3338 MAY_LJMP(hlua_checkchannel(L, 1));
3339 MAY_LJMP(luaL_checkinteger(L, 2));
3340
3341 lua_pushinteger(L, 0);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003342 return MAY_LJMP(hlua_channel_forward_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003343}
3344
3345/* Just returns the number of bytes available in the input
3346 * side of the buffer. This function never fails.
3347 */
3348__LJMP static int hlua_channel_get_in_len(lua_State *L)
3349{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003350 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003351
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003352 MAY_LJMP(check_args(L, 1, "get_in_len"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003353 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Christopher Fauleta3ceac12018-12-14 13:39:09 +01003354 if (IS_HTX_STRM(chn_strm(chn))) {
3355 struct htx *htx = htxbuf(&chn->buf);
3356 lua_pushinteger(L, htx->data - co_data(chn));
3357 }
3358 else
3359 lua_pushinteger(L, ci_data(chn));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003360 return 1;
3361}
3362
Thierry FOURNIER / OZON.IO65192f32016-11-07 15:28:40 +01003363/* Returns true if the channel is full. */
3364__LJMP static int hlua_channel_is_full(lua_State *L)
3365{
3366 struct channel *chn;
Thierry FOURNIER / OZON.IO65192f32016-11-07 15:28:40 +01003367
3368 MAY_LJMP(check_args(L, 1, "is_full"));
3369 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Christopher Faulet0ec740e2020-02-26 11:59:19 +01003370 /* ignore the reserve, we are not on a producer side (ie in an
3371 * applet).
3372 */
3373 lua_pushboolean(L, channel_full(chn, 0));
Thierry FOURNIER / OZON.IO65192f32016-11-07 15:28:40 +01003374 return 1;
3375}
3376
Christopher Faulet2ac9ba22020-02-25 10:15:50 +01003377/* Returns true if the channel is the response channel. */
3378__LJMP static int hlua_channel_is_resp(lua_State *L)
3379{
3380 struct channel *chn;
3381
3382 MAY_LJMP(check_args(L, 1, "is_resp"));
3383 chn = MAY_LJMP(hlua_checkchannel(L, 1));
3384
3385 lua_pushboolean(L, !!(chn->flags & CF_ISRESP));
3386 return 1;
3387}
3388
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003389/* Just returns the number of bytes available in the output
3390 * side of the buffer. This function never fails.
3391 */
3392__LJMP static int hlua_channel_get_out_len(lua_State *L)
3393{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003394 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003395
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003396 MAY_LJMP(check_args(L, 1, "get_out_len"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003397 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Willy Tarreaua79021a2018-06-15 18:07:57 +02003398 lua_pushinteger(L, co_data(chn));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003399 return 1;
3400}
3401
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003402/*
3403 *
3404 *
3405 * Class Fetches
3406 *
3407 *
3408 */
3409
3410/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02003411 * a class stream, otherwise it throws an error.
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003412 */
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003413__LJMP static struct hlua_smp *hlua_checkfetches(lua_State *L, int ud)
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003414{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003415 return MAY_LJMP(hlua_checkudata(L, ud, class_fetches_ref));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003416}
3417
3418/* This function creates and push in the stack a fetch object according
3419 * with a current TXN.
3420 */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003421static int hlua_fetches_new(lua_State *L, struct hlua_txn *txn, unsigned int flags)
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003422{
Willy Tarreau7073c472015-04-06 11:15:40 +02003423 struct hlua_smp *hsmp;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003424
3425 /* Check stack size. */
3426 if (!lua_checkstack(L, 3))
3427 return 0;
3428
3429 /* Create the object: obj[0] = userdata.
3430 * Note that the base of the Fetches object is the
3431 * transaction object.
3432 */
3433 lua_newtable(L);
Willy Tarreau7073c472015-04-06 11:15:40 +02003434 hsmp = lua_newuserdata(L, sizeof(*hsmp));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003435 lua_rawseti(L, -2, 0);
3436
Willy Tarreau7073c472015-04-06 11:15:40 +02003437 hsmp->s = txn->s;
3438 hsmp->p = txn->p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01003439 hsmp->dir = txn->dir;
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003440 hsmp->flags = flags;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003441
3442 /* Pop a class sesison metatable and affect it to the userdata. */
3443 lua_rawgeti(L, LUA_REGISTRYINDEX, class_fetches_ref);
3444 lua_setmetatable(L, -2);
3445
3446 return 1;
3447}
3448
3449/* This function is an LUA binding. It is called with each sample-fetch.
3450 * It uses closure argument to store the associated sample-fetch. It
3451 * returns only one argument or throws an error. An error is thrown
3452 * only if an error is encountered during the argument parsing. If
3453 * the "sample-fetch" function fails, nil is returned.
3454 */
3455__LJMP static int hlua_run_sample_fetch(lua_State *L)
3456{
Willy Tarreaub2ccb562015-04-06 11:11:15 +02003457 struct hlua_smp *hsmp;
Willy Tarreau2ec22742015-03-10 14:27:20 +01003458 struct sample_fetch *f;
Frédéric Lécaillef874a832018-06-15 13:56:04 +02003459 struct arg args[ARGM_NBARGS + 1] = {{0}};
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003460 int i;
3461 struct sample smp;
3462
3463 /* Get closure arguments. */
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003464 f = lua_touserdata(L, lua_upvalueindex(1));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003465
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003466 /* Get traditional arguments. */
Willy Tarreaub2ccb562015-04-06 11:11:15 +02003467 hsmp = MAY_LJMP(hlua_checkfetches(L, 1));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003468
Thierry FOURNIERca988662015-12-20 18:43:03 +01003469 /* Check execution authorization. */
3470 if (f->use & SMP_USE_HTTP_ANY &&
3471 !(hsmp->flags & HLUA_F_MAY_USE_HTTP)) {
3472 lua_pushfstring(L, "the sample-fetch '%s' needs an HTTP parser which "
3473 "is not available in Lua services", f->kw);
3474 WILL_LJMP(lua_error(L));
3475 }
3476
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003477 /* Get extra arguments. */
3478 for (i = 0; i < lua_gettop(L) - 1; i++) {
3479 if (i >= ARGM_NBARGS)
3480 break;
3481 hlua_lua2arg(L, i + 2, &args[i]);
3482 }
3483 args[i].type = ARGT_STOP;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003484 args[i].data.str.area = NULL;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003485
3486 /* Check arguments. */
Willy Tarreaub2ccb562015-04-06 11:11:15 +02003487 MAY_LJMP(hlua_lua2arg_check(L, 2, args, f->arg_mask, hsmp->p));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003488
3489 /* Run the special args checker. */
Willy Tarreau2ec22742015-03-10 14:27:20 +01003490 if (f->val_args && !f->val_args(args, NULL)) {
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003491 lua_pushfstring(L, "error in arguments");
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003492 goto error;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003493 }
3494
3495 /* Initialise the sample. */
3496 memset(&smp, 0, sizeof(smp));
3497
3498 /* Run the sample fetch process. */
Willy Tarreau1777ea62016-03-10 16:15:46 +01003499 smp_set_owner(&smp, hsmp->p, hsmp->s->sess, hsmp->s, hsmp->dir & SMP_OPT_DIR);
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003500 if (!f->process(args, &smp, f->kw, f->private)) {
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003501 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003502 lua_pushstring(L, "");
3503 else
3504 lua_pushnil(L);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003505 goto end;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003506 }
3507
3508 /* Convert the returned sample in lua value. */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003509 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003510 hlua_smp2lua_str(L, &smp);
3511 else
3512 hlua_smp2lua(L, &smp);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003513
3514 end:
3515 for (i = 0; args[i].type != ARGT_STOP; i++) {
3516 if (args[i].type == ARGT_STR)
3517 chunk_destroy(&args[i].data.str);
Christopher Fauletfd2e9062020-08-06 11:10:57 +02003518 else if (args[i].type == ARGT_REG)
3519 regex_free(args[i].data.reg);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003520 }
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003521 return 1;
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003522
3523 error:
3524 for (i = 0; args[i].type != ARGT_STOP; i++) {
3525 if (args[i].type == ARGT_STR)
3526 chunk_destroy(&args[i].data.str);
Christopher Fauletfd2e9062020-08-06 11:10:57 +02003527 else if (args[i].type == ARGT_REG)
3528 regex_free(args[i].data.reg);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003529 }
3530 WILL_LJMP(lua_error(L));
3531 return 0; /* Never reached */
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003532}
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003533
3534/*
3535 *
3536 *
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003537 * Class Converters
3538 *
3539 *
3540 */
3541
3542/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02003543 * a class stream, otherwise it throws an error.
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003544 */
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003545__LJMP static struct hlua_smp *hlua_checkconverters(lua_State *L, int ud)
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003546{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003547 return MAY_LJMP(hlua_checkudata(L, ud, class_converters_ref));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003548}
3549
3550/* This function creates and push in the stack a Converters object
3551 * according with a current TXN.
3552 */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003553static int hlua_converters_new(lua_State *L, struct hlua_txn *txn, unsigned int flags)
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003554{
Willy Tarreau7073c472015-04-06 11:15:40 +02003555 struct hlua_smp *hsmp;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003556
3557 /* Check stack size. */
3558 if (!lua_checkstack(L, 3))
3559 return 0;
3560
3561 /* Create the object: obj[0] = userdata.
3562 * Note that the base of the Converters object is the
3563 * same than the TXN object.
3564 */
3565 lua_newtable(L);
Willy Tarreau7073c472015-04-06 11:15:40 +02003566 hsmp = lua_newuserdata(L, sizeof(*hsmp));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003567 lua_rawseti(L, -2, 0);
3568
Willy Tarreau7073c472015-04-06 11:15:40 +02003569 hsmp->s = txn->s;
3570 hsmp->p = txn->p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01003571 hsmp->dir = txn->dir;
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003572 hsmp->flags = flags;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003573
Willy Tarreau87b09662015-04-03 00:22:06 +02003574 /* Pop a class stream metatable and affect it to the table. */
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003575 lua_rawgeti(L, LUA_REGISTRYINDEX, class_converters_ref);
3576 lua_setmetatable(L, -2);
3577
3578 return 1;
3579}
3580
3581/* This function is an LUA binding. It is called with each converter.
3582 * It uses closure argument to store the associated converter. It
3583 * returns only one argument or throws an error. An error is thrown
3584 * only if an error is encountered during the argument parsing. If
3585 * the converter function function fails, nil is returned.
3586 */
3587__LJMP static int hlua_run_sample_conv(lua_State *L)
3588{
Willy Tarreauda5f1082015-04-06 11:17:13 +02003589 struct hlua_smp *hsmp;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003590 struct sample_conv *conv;
Frédéric Lécaillef874a832018-06-15 13:56:04 +02003591 struct arg args[ARGM_NBARGS + 1] = {{0}};
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003592 int i;
3593 struct sample smp;
3594
3595 /* Get closure arguments. */
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003596 conv = lua_touserdata(L, lua_upvalueindex(1));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003597
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003598 /* Get traditional arguments. */
Willy Tarreauda5f1082015-04-06 11:17:13 +02003599 hsmp = MAY_LJMP(hlua_checkconverters(L, 1));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003600
3601 /* Get extra arguments. */
3602 for (i = 0; i < lua_gettop(L) - 2; i++) {
3603 if (i >= ARGM_NBARGS)
3604 break;
3605 hlua_lua2arg(L, i + 3, &args[i]);
3606 }
3607 args[i].type = ARGT_STOP;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003608 args[i].data.str.area = NULL;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003609
3610 /* Check arguments. */
Willy Tarreauda5f1082015-04-06 11:17:13 +02003611 MAY_LJMP(hlua_lua2arg_check(L, 3, args, conv->arg_mask, hsmp->p));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003612
3613 /* Run the special args checker. */
3614 if (conv->val_args && !conv->val_args(args, conv, "", 0, NULL)) {
3615 hlua_pusherror(L, "error in arguments");
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003616 goto error;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003617 }
3618
3619 /* Initialise the sample. */
Amaury Denoyellebc0af6a2020-10-29 17:21:20 +01003620 memset(&smp, 0, sizeof(smp));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003621 if (!hlua_lua2smp(L, 2, &smp)) {
3622 hlua_pusherror(L, "error in the input argument");
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003623 goto error;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003624 }
3625
Willy Tarreau1777ea62016-03-10 16:15:46 +01003626 smp_set_owner(&smp, hsmp->p, hsmp->s->sess, hsmp->s, hsmp->dir & SMP_OPT_DIR);
3627
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003628 /* Apply expected cast. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003629 if (!sample_casts[smp.data.type][conv->in_type]) {
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003630 hlua_pusherror(L, "invalid input argument: cannot cast '%s' to '%s'",
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003631 smp_to_type[smp.data.type], smp_to_type[conv->in_type]);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003632 goto error;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003633 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003634 if (sample_casts[smp.data.type][conv->in_type] != c_none &&
3635 !sample_casts[smp.data.type][conv->in_type](&smp)) {
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003636 hlua_pusherror(L, "error during the input argument casting");
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003637 goto error;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003638 }
3639
3640 /* Run the sample conversion process. */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003641 if (!conv->process(args, &smp, conv->private)) {
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003642 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003643 lua_pushstring(L, "");
3644 else
Willy Tarreaua678b432015-08-28 10:14:59 +02003645 lua_pushnil(L);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003646 goto end;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003647 }
3648
3649 /* Convert the returned sample in lua value. */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003650 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003651 hlua_smp2lua_str(L, &smp);
3652 else
3653 hlua_smp2lua(L, &smp);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003654 end:
3655 for (i = 0; args[i].type != ARGT_STOP; i++) {
3656 if (args[i].type == ARGT_STR)
3657 chunk_destroy(&args[i].data.str);
Christopher Fauletfd2e9062020-08-06 11:10:57 +02003658 else if (args[i].type == ARGT_REG)
3659 regex_free(args[i].data.reg);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003660 }
Willy Tarreaua678b432015-08-28 10:14:59 +02003661 return 1;
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003662
3663 error:
3664 for (i = 0; args[i].type != ARGT_STOP; i++) {
3665 if (args[i].type == ARGT_STR)
3666 chunk_destroy(&args[i].data.str);
Christopher Fauletfd2e9062020-08-06 11:10:57 +02003667 else if (args[i].type == ARGT_REG)
3668 regex_free(args[i].data.reg);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003669 }
3670 WILL_LJMP(lua_error(L));
3671 return 0; /* Never reached */
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003672}
3673
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003674/*
3675 *
3676 *
3677 * Class AppletTCP
3678 *
3679 *
3680 */
3681
3682/* Returns a struct hlua_txn if the stack entry "ud" is
3683 * a class stream, otherwise it throws an error.
3684 */
3685__LJMP static struct hlua_appctx *hlua_checkapplet_tcp(lua_State *L, int ud)
3686{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003687 return MAY_LJMP(hlua_checkudata(L, ud, class_applet_tcp_ref));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003688}
3689
3690/* This function creates and push in the stack an Applet object
3691 * according with a current TXN.
3692 */
3693static int hlua_applet_tcp_new(lua_State *L, struct appctx *ctx)
3694{
Willy Tarreau7e702d12021-04-28 17:59:21 +02003695 struct hlua_appctx *luactx;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003696 struct stream_interface *si = ctx->owner;
3697 struct stream *s = si_strm(si);
3698 struct proxy *p = s->be;
3699
3700 /* Check stack size. */
3701 if (!lua_checkstack(L, 3))
3702 return 0;
3703
3704 /* Create the object: obj[0] = userdata.
3705 * Note that the base of the Converters object is the
3706 * same than the TXN object.
3707 */
3708 lua_newtable(L);
Willy Tarreau7e702d12021-04-28 17:59:21 +02003709 luactx = lua_newuserdata(L, sizeof(*luactx));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003710 lua_rawseti(L, -2, 0);
Willy Tarreau7e702d12021-04-28 17:59:21 +02003711 luactx->appctx = ctx;
3712 luactx->htxn.s = s;
3713 luactx->htxn.p = p;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003714
3715 /* Create the "f" field that contains a list of fetches. */
3716 lua_pushstring(L, "f");
Willy Tarreau7e702d12021-04-28 17:59:21 +02003717 if (!hlua_fetches_new(L, &luactx->htxn, 0))
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003718 return 0;
3719 lua_settable(L, -3);
3720
3721 /* Create the "sf" field that contains a list of stringsafe fetches. */
3722 lua_pushstring(L, "sf");
Willy Tarreau7e702d12021-04-28 17:59:21 +02003723 if (!hlua_fetches_new(L, &luactx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003724 return 0;
3725 lua_settable(L, -3);
3726
3727 /* Create the "c" field that contains a list of converters. */
3728 lua_pushstring(L, "c");
Willy Tarreau7e702d12021-04-28 17:59:21 +02003729 if (!hlua_converters_new(L, &luactx->htxn, 0))
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003730 return 0;
3731 lua_settable(L, -3);
3732
3733 /* Create the "sc" field that contains a list of stringsafe converters. */
3734 lua_pushstring(L, "sc");
Willy Tarreau7e702d12021-04-28 17:59:21 +02003735 if (!hlua_converters_new(L, &luactx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003736 return 0;
3737 lua_settable(L, -3);
3738
3739 /* Pop a class stream metatable and affect it to the table. */
3740 lua_rawgeti(L, LUA_REGISTRYINDEX, class_applet_tcp_ref);
3741 lua_setmetatable(L, -2);
3742
3743 return 1;
3744}
3745
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003746__LJMP static int hlua_applet_tcp_set_var(lua_State *L)
3747{
Willy Tarreau7e702d12021-04-28 17:59:21 +02003748 struct hlua_appctx *luactx;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003749 struct stream *s;
3750 const char *name;
3751 size_t len;
3752 struct sample smp;
3753
Tim Duesterhus4e172c92020-05-19 13:49:42 +02003754 if (lua_gettop(L) < 3 || lua_gettop(L) > 4)
3755 WILL_LJMP(luaL_error(L, "'set_var' needs between 3 and 4 arguments"));
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003756
3757 /* It is useles to retrieve the stream, but this function
3758 * runs only in a stream context.
3759 */
Willy Tarreau7e702d12021-04-28 17:59:21 +02003760 luactx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003761 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
Willy Tarreau7e702d12021-04-28 17:59:21 +02003762 s = luactx->htxn.s;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003763
3764 /* Converts the third argument in a sample. */
Amaury Denoyellebc0af6a2020-10-29 17:21:20 +01003765 memset(&smp, 0, sizeof(smp));
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003766 hlua_lua2smp(L, 3, &smp);
3767
3768 /* Store the sample in a variable. */
3769 smp_set_owner(&smp, s->be, s->sess, s, 0);
Tim Duesterhus4e172c92020-05-19 13:49:42 +02003770
3771 if (lua_gettop(L) == 4 && lua_toboolean(L, 4))
3772 lua_pushboolean(L, vars_set_by_name_ifexist(name, len, &smp) != 0);
3773 else
3774 lua_pushboolean(L, vars_set_by_name(name, len, &smp) != 0);
3775
Tim Duesterhus84ebc132020-05-19 13:49:41 +02003776 return 1;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003777}
3778
3779__LJMP static int hlua_applet_tcp_unset_var(lua_State *L)
3780{
Willy Tarreau7e702d12021-04-28 17:59:21 +02003781 struct hlua_appctx *luactx;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003782 struct stream *s;
3783 const char *name;
3784 size_t len;
3785 struct sample smp;
3786
3787 MAY_LJMP(check_args(L, 2, "unset_var"));
3788
3789 /* It is useles to retrieve the stream, but this function
3790 * runs only in a stream context.
3791 */
Willy Tarreau7e702d12021-04-28 17:59:21 +02003792 luactx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003793 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
Willy Tarreau7e702d12021-04-28 17:59:21 +02003794 s = luactx->htxn.s;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003795
3796 /* Unset the variable. */
3797 smp_set_owner(&smp, s->be, s->sess, s, 0);
Tim Duesterhus84ebc132020-05-19 13:49:41 +02003798 lua_pushboolean(L, vars_unset_by_name_ifexist(name, len, &smp) != 0);
3799 return 1;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003800}
3801
3802__LJMP static int hlua_applet_tcp_get_var(lua_State *L)
3803{
Willy Tarreau7e702d12021-04-28 17:59:21 +02003804 struct hlua_appctx *luactx;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003805 struct stream *s;
3806 const char *name;
3807 size_t len;
3808 struct sample smp;
3809
3810 MAY_LJMP(check_args(L, 2, "get_var"));
3811
3812 /* It is useles to retrieve the stream, but this function
3813 * runs only in a stream context.
3814 */
Willy Tarreau7e702d12021-04-28 17:59:21 +02003815 luactx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003816 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
Willy Tarreau7e702d12021-04-28 17:59:21 +02003817 s = luactx->htxn.s;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003818
3819 smp_set_owner(&smp, s->be, s->sess, s, 0);
3820 if (!vars_get_by_name(name, len, &smp)) {
3821 lua_pushnil(L);
3822 return 1;
3823 }
3824
3825 return hlua_smp2lua(L, &smp);
3826}
3827
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003828__LJMP static int hlua_applet_tcp_set_priv(lua_State *L)
3829{
Willy Tarreau7e702d12021-04-28 17:59:21 +02003830 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3831 struct stream *s = luactx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01003832 struct hlua *hlua;
3833
3834 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01003835 if (!s->hlua)
3836 return 0;
3837 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003838
3839 MAY_LJMP(check_args(L, 2, "set_priv"));
3840
3841 /* Remove previous value. */
Thierry FOURNIERe068b602017-04-26 13:27:05 +02003842 luaL_unref(L, LUA_REGISTRYINDEX, hlua->Mref);
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003843
3844 /* Get and store new value. */
3845 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
3846 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
3847
3848 return 0;
3849}
3850
3851__LJMP static int hlua_applet_tcp_get_priv(lua_State *L)
3852{
Willy Tarreau7e702d12021-04-28 17:59:21 +02003853 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3854 struct stream *s = luactx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01003855 struct hlua *hlua;
3856
3857 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01003858 if (!s->hlua) {
3859 lua_pushnil(L);
3860 return 1;
3861 }
3862 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003863
3864 /* Push configuration index in the stack. */
3865 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
3866
3867 return 1;
3868}
3869
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003870/* If expected data not yet available, it returns a yield. This function
3871 * consumes the data in the buffer. It returns a string containing the
3872 * data. This string can be empty.
3873 */
3874__LJMP static int hlua_applet_tcp_getline_yield(lua_State *L, int status, lua_KContext ctx)
3875{
Willy Tarreau7e702d12021-04-28 17:59:21 +02003876 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3877 struct stream_interface *si = luactx->appctx->owner;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003878 int ret;
Willy Tarreau206ba832018-06-14 15:27:31 +02003879 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003880 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02003881 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003882 size_t len2;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003883
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003884 /* Read the maximum amount of data available. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003885 ret = co_getline_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003886
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003887 /* Data not yet available. return yield. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003888 if (ret == 0) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01003889 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003890 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_getline_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003891 }
3892
3893 /* End of data: commit the total strings and return. */
3894 if (ret < 0) {
Willy Tarreau7e702d12021-04-28 17:59:21 +02003895 luaL_pushresult(&luactx->b);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003896 return 1;
3897 }
3898
3899 /* Ensure that the block 2 length is usable. */
3900 if (ret == 1)
3901 len2 = 0;
3902
Thayne McCombs8f0cc5c2021-01-07 21:35:52 -07003903 /* don't check the max length read and don't check. */
Willy Tarreau7e702d12021-04-28 17:59:21 +02003904 luaL_addlstring(&luactx->b, blk1, len1);
3905 luaL_addlstring(&luactx->b, blk2, len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003906
3907 /* Consume input channel output buffer data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003908 co_skip(si_oc(si), len1 + len2);
Willy Tarreau7e702d12021-04-28 17:59:21 +02003909 luaL_pushresult(&luactx->b);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003910 return 1;
3911}
3912
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003913/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003914__LJMP static int hlua_applet_tcp_getline(lua_State *L)
3915{
Willy Tarreau7e702d12021-04-28 17:59:21 +02003916 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003917
3918 /* Initialise the string catenation. */
Willy Tarreau7e702d12021-04-28 17:59:21 +02003919 luaL_buffinit(L, &luactx->b);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003920
3921 return MAY_LJMP(hlua_applet_tcp_getline_yield(L, 0, 0));
3922}
3923
3924/* If expected data not yet available, it returns a yield. This function
3925 * consumes the data in the buffer. It returns a string containing the
3926 * data. This string can be empty.
3927 */
3928__LJMP static int hlua_applet_tcp_recv_yield(lua_State *L, int status, lua_KContext ctx)
3929{
Willy Tarreau7e702d12021-04-28 17:59:21 +02003930 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3931 struct stream_interface *si = luactx->appctx->owner;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003932 size_t len = MAY_LJMP(luaL_checkinteger(L, 2));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003933 int ret;
Willy Tarreau206ba832018-06-14 15:27:31 +02003934 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003935 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02003936 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003937 size_t len2;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003938
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003939 /* Read the maximum amount of data available. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003940 ret = co_getblk_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003941
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003942 /* Data not yet available. return yield. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003943 if (ret == 0) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01003944 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003945 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003946 }
3947
3948 /* End of data: commit the total strings and return. */
3949 if (ret < 0) {
Willy Tarreau7e702d12021-04-28 17:59:21 +02003950 luaL_pushresult(&luactx->b);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003951 return 1;
3952 }
3953
3954 /* Ensure that the block 2 length is usable. */
3955 if (ret == 1)
3956 len2 = 0;
3957
3958 if (len == -1) {
3959
3960 /* If len == -1, catenate all the data avalaile and
3961 * yield because we want to get all the data until
3962 * the end of data stream.
3963 */
Willy Tarreau7e702d12021-04-28 17:59:21 +02003964 luaL_addlstring(&luactx->b, blk1, len1);
3965 luaL_addlstring(&luactx->b, blk2, len2);
Willy Tarreau06d80a92017-10-19 14:32:15 +02003966 co_skip(si_oc(si), len1 + len2);
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01003967 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003968 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003969
3970 } else {
3971
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05003972 /* Copy the first block caping to the length required. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003973 if (len1 > len)
3974 len1 = len;
Willy Tarreau7e702d12021-04-28 17:59:21 +02003975 luaL_addlstring(&luactx->b, blk1, len1);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003976 len -= len1;
3977
3978 /* Copy the second block. */
3979 if (len2 > len)
3980 len2 = len;
Willy Tarreau7e702d12021-04-28 17:59:21 +02003981 luaL_addlstring(&luactx->b, blk2, len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003982 len -= len2;
3983
3984 /* Consume input channel output buffer data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003985 co_skip(si_oc(si), len1 + len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003986
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003987 /* If there is no other data available, yield waiting for new data. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003988 if (len > 0) {
3989 lua_pushinteger(L, len);
3990 lua_replace(L, 2);
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01003991 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003992 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003993 }
3994
3995 /* return the result. */
Willy Tarreau7e702d12021-04-28 17:59:21 +02003996 luaL_pushresult(&luactx->b);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003997 return 1;
3998 }
3999
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004000 /* we never execute this */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02004001 hlua_pusherror(L, "Lua: internal error");
4002 WILL_LJMP(lua_error(L));
4003 return 0;
4004}
4005
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004006/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02004007__LJMP static int hlua_applet_tcp_recv(lua_State *L)
4008{
Willy Tarreau7e702d12021-04-28 17:59:21 +02004009 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02004010 int len = -1;
4011
4012 if (lua_gettop(L) > 2)
4013 WILL_LJMP(luaL_error(L, "The 'recv' function requires between 1 and 2 arguments."));
4014 if (lua_gettop(L) >= 2) {
4015 len = MAY_LJMP(luaL_checkinteger(L, 2));
4016 lua_pop(L, 1);
4017 }
4018
4019 /* Confirm or set the required length */
4020 lua_pushinteger(L, len);
4021
4022 /* Initialise the string catenation. */
Willy Tarreau7e702d12021-04-28 17:59:21 +02004023 luaL_buffinit(L, &luactx->b);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02004024
4025 return MAY_LJMP(hlua_applet_tcp_recv_yield(L, 0, 0));
4026}
4027
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004028/* Append data in the output side of the buffer. This data is immediately
4029 * sent. The function returns the amount of data written. If the buffer
4030 * cannot contain the data, the function yields. The function returns -1
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02004031 * if the channel is closed.
4032 */
4033__LJMP static int hlua_applet_tcp_send_yield(lua_State *L, int status, lua_KContext ctx)
4034{
4035 size_t len;
Willy Tarreau7e702d12021-04-28 17:59:21 +02004036 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02004037 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
4038 int l = MAY_LJMP(luaL_checkinteger(L, 3));
Willy Tarreau7e702d12021-04-28 17:59:21 +02004039 struct stream_interface *si = luactx->appctx->owner;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02004040 struct channel *chn = si_ic(si);
4041 int max;
4042
4043 /* Get the max amount of data which can write as input in the channel. */
4044 max = channel_recv_max(chn);
4045 if (max > (len - l))
4046 max = len - l;
4047
4048 /* Copy data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02004049 ci_putblk(chn, str + l, max);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02004050
4051 /* update counters. */
4052 l += max;
4053 lua_pop(L, 1);
4054 lua_pushinteger(L, l);
4055
4056 /* If some data is not send, declares the situation to the
4057 * applet, and returns a yield.
4058 */
4059 if (l < len) {
Willy Tarreaudb398432018-11-15 11:08:52 +01004060 si_rx_room_blk(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02004061 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02004062 }
4063
4064 return 1;
4065}
4066
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05004067/* Just a wrapper of "hlua_applet_tcp_send_yield". This wrapper permits
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02004068 * yield the LUA process, and resume it without checking the
4069 * input arguments.
4070 */
4071__LJMP static int hlua_applet_tcp_send(lua_State *L)
4072{
4073 MAY_LJMP(check_args(L, 2, "send"));
4074 lua_pushinteger(L, 0);
4075
4076 return MAY_LJMP(hlua_applet_tcp_send_yield(L, 0, 0));
4077}
4078
Thierry FOURNIER594afe72015-03-10 23:58:30 +01004079/*
4080 *
4081 *
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004082 * Class AppletHTTP
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004083 *
4084 *
4085 */
4086
4087/* Returns a struct hlua_txn if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02004088 * a class stream, otherwise it throws an error.
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004089 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004090__LJMP static struct hlua_appctx *hlua_checkapplet_http(lua_State *L, int ud)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004091{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02004092 return MAY_LJMP(hlua_checkudata(L, ud, class_applet_http_ref));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004093}
4094
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004095/* This function creates and push in the stack an Applet object
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004096 * according with a current TXN.
4097 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004098static int hlua_applet_http_new(lua_State *L, struct appctx *ctx)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004099{
Willy Tarreau7e702d12021-04-28 17:59:21 +02004100 struct hlua_appctx *luactx;
Thierry FOURNIER841475e2015-12-11 17:10:09 +01004101 struct hlua_txn htxn;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004102 struct stream_interface *si = ctx->owner;
4103 struct stream *s = si_strm(si);
4104 struct proxy *px = s->be;
Christopher Fauleta2097962019-07-15 16:25:33 +02004105 struct htx *htx;
4106 struct htx_blk *blk;
4107 struct htx_sl *sl;
4108 struct ist path;
4109 unsigned long long len = 0;
4110 int32_t pos;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004111
4112 /* Check stack size. */
4113 if (!lua_checkstack(L, 3))
4114 return 0;
4115
4116 /* Create the object: obj[0] = userdata.
4117 * Note that the base of the Converters object is the
4118 * same than the TXN object.
4119 */
4120 lua_newtable(L);
Willy Tarreau7e702d12021-04-28 17:59:21 +02004121 luactx = lua_newuserdata(L, sizeof(*luactx));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004122 lua_rawseti(L, -2, 0);
Willy Tarreau7e702d12021-04-28 17:59:21 +02004123 luactx->appctx = ctx;
4124 luactx->appctx->ctx.hlua_apphttp.status = 200; /* Default status code returned. */
4125 luactx->appctx->ctx.hlua_apphttp.reason = NULL; /* Use default reason based on status */
4126 luactx->htxn.s = s;
4127 luactx->htxn.p = px;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004128
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004129 /* Create the "f" field that contains a list of fetches. */
4130 lua_pushstring(L, "f");
Willy Tarreau7e702d12021-04-28 17:59:21 +02004131 if (!hlua_fetches_new(L, &luactx->htxn, 0))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004132 return 0;
4133 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004134
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004135 /* Create the "sf" field that contains a list of stringsafe fetches. */
4136 lua_pushstring(L, "sf");
Willy Tarreau7e702d12021-04-28 17:59:21 +02004137 if (!hlua_fetches_new(L, &luactx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004138 return 0;
4139 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004140
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004141 /* Create the "c" field that contains a list of converters. */
4142 lua_pushstring(L, "c");
Willy Tarreau7e702d12021-04-28 17:59:21 +02004143 if (!hlua_converters_new(L, &luactx->htxn, 0))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004144 return 0;
4145 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004146
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004147 /* Create the "sc" field that contains a list of stringsafe converters. */
4148 lua_pushstring(L, "sc");
Willy Tarreau7e702d12021-04-28 17:59:21 +02004149 if (!hlua_converters_new(L, &luactx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004150 return 0;
4151 lua_settable(L, -3);
Willy Tarreaueee5b512015-04-03 23:46:31 +02004152
Christopher Fauleta2097962019-07-15 16:25:33 +02004153 htx = htxbuf(&s->req.buf);
4154 blk = htx_get_first_blk(htx);
Christopher Fauletea009732019-11-18 15:50:25 +01004155 BUG_ON(!blk || htx_get_blk_type(blk) != HTX_BLK_REQ_SL);
Christopher Fauleta2097962019-07-15 16:25:33 +02004156 sl = htx_get_blk_ptr(htx, blk);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004157
Christopher Fauleta2097962019-07-15 16:25:33 +02004158 /* Stores the request method. */
4159 lua_pushstring(L, "method");
4160 lua_pushlstring(L, HTX_SL_REQ_MPTR(sl), HTX_SL_REQ_MLEN(sl));
4161 lua_settable(L, -3);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004162
Christopher Fauleta2097962019-07-15 16:25:33 +02004163 /* Stores the http version. */
4164 lua_pushstring(L, "version");
4165 lua_pushlstring(L, HTX_SL_REQ_VPTR(sl), HTX_SL_REQ_VLEN(sl));
4166 lua_settable(L, -3);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004167
Christopher Fauleta2097962019-07-15 16:25:33 +02004168 /* creates an array of headers. hlua_http_get_headers() crates and push
4169 * the array on the top of the stack.
4170 */
4171 lua_pushstring(L, "headers");
4172 htxn.s = s;
4173 htxn.p = px;
4174 htxn.dir = SMP_OPT_DIR_REQ;
Christopher Faulet9d1332b2020-02-24 16:46:16 +01004175 if (!hlua_http_get_headers(L, &htxn.s->txn->req))
Christopher Fauleta2097962019-07-15 16:25:33 +02004176 return 0;
4177 lua_settable(L, -3);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004178
Christopher Fauleta2097962019-07-15 16:25:33 +02004179 path = http_get_path(htx_sl_req_uri(sl));
Tim Duesterhused526372020-03-05 17:56:33 +01004180 if (isttest(path)) {
Christopher Fauleta2097962019-07-15 16:25:33 +02004181 char *p, *q, *end;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004182
Christopher Fauleta2097962019-07-15 16:25:33 +02004183 p = path.ptr;
4184 end = path.ptr + path.len;
4185 q = p;
4186 while (q < end && *q != '?')
4187 q++;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004188
Thierry FOURNIER7d388632017-02-22 02:06:16 +01004189 /* Stores the request path. */
Christopher Fauleta2097962019-07-15 16:25:33 +02004190 lua_pushstring(L, "path");
4191 lua_pushlstring(L, p, q - p);
Thierry FOURNIER7d388632017-02-22 02:06:16 +01004192 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01004193
Christopher Fauleta2097962019-07-15 16:25:33 +02004194 /* Stores the query string. */
4195 lua_pushstring(L, "qs");
4196 if (*q == '?')
4197 q++;
4198 lua_pushlstring(L, q, end - q);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004199 lua_settable(L, -3);
Christopher Fauleta2097962019-07-15 16:25:33 +02004200 }
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004201
Christopher Fauleta2097962019-07-15 16:25:33 +02004202 for (pos = htx_get_first(htx); pos != -1; pos = htx_get_next(htx, pos)) {
4203 struct htx_blk *blk = htx_get_blk(htx, pos);
4204 enum htx_blk_type type = htx_get_blk_type(blk);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004205
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01004206 if (type == HTX_BLK_TLR || type == HTX_BLK_EOT)
Christopher Fauleta2097962019-07-15 16:25:33 +02004207 break;
4208 if (type == HTX_BLK_DATA)
4209 len += htx_get_blksz(blk);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004210 }
Christopher Fauleta2097962019-07-15 16:25:33 +02004211 if (htx->extra != ULLONG_MAX)
4212 len += htx->extra;
4213
4214 /* Stores the request path. */
4215 lua_pushstring(L, "length");
4216 lua_pushinteger(L, len);
4217 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01004218
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004219 /* Create an empty array of HTTP request headers. */
4220 lua_pushstring(L, "response");
4221 lua_newtable(L);
4222 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01004223
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004224 /* Pop a class stream metatable and affect it to the table. */
4225 lua_rawgeti(L, LUA_REGISTRYINDEX, class_applet_http_ref);
4226 lua_setmetatable(L, -2);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004227
4228 return 1;
4229}
4230
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004231__LJMP static int hlua_applet_http_set_var(lua_State *L)
4232{
Willy Tarreau7e702d12021-04-28 17:59:21 +02004233 struct hlua_appctx *luactx;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004234 struct stream *s;
4235 const char *name;
4236 size_t len;
4237 struct sample smp;
4238
Tim Duesterhus4e172c92020-05-19 13:49:42 +02004239 if (lua_gettop(L) < 3 || lua_gettop(L) > 4)
4240 WILL_LJMP(luaL_error(L, "'set_var' needs between 3 and 4 arguments"));
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004241
4242 /* It is useles to retrieve the stream, but this function
4243 * runs only in a stream context.
4244 */
Willy Tarreau7e702d12021-04-28 17:59:21 +02004245 luactx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004246 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
Willy Tarreau7e702d12021-04-28 17:59:21 +02004247 s = luactx->htxn.s;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004248
4249 /* Converts the third argument in a sample. */
Amaury Denoyellebc0af6a2020-10-29 17:21:20 +01004250 memset(&smp, 0, sizeof(smp));
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004251 hlua_lua2smp(L, 3, &smp);
4252
4253 /* Store the sample in a variable. */
4254 smp_set_owner(&smp, s->be, s->sess, s, 0);
Tim Duesterhus4e172c92020-05-19 13:49:42 +02004255
4256 if (lua_gettop(L) == 4 && lua_toboolean(L, 4))
4257 lua_pushboolean(L, vars_set_by_name_ifexist(name, len, &smp) != 0);
4258 else
4259 lua_pushboolean(L, vars_set_by_name(name, len, &smp) != 0);
4260
Tim Duesterhus84ebc132020-05-19 13:49:41 +02004261 return 1;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004262}
4263
4264__LJMP static int hlua_applet_http_unset_var(lua_State *L)
4265{
Willy Tarreau7e702d12021-04-28 17:59:21 +02004266 struct hlua_appctx *luactx;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004267 struct stream *s;
4268 const char *name;
4269 size_t len;
4270 struct sample smp;
4271
4272 MAY_LJMP(check_args(L, 2, "unset_var"));
4273
4274 /* It is useles to retrieve the stream, but this function
4275 * runs only in a stream context.
4276 */
Willy Tarreau7e702d12021-04-28 17:59:21 +02004277 luactx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004278 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
Willy Tarreau7e702d12021-04-28 17:59:21 +02004279 s = luactx->htxn.s;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004280
4281 /* Unset the variable. */
4282 smp_set_owner(&smp, s->be, s->sess, s, 0);
Tim Duesterhus84ebc132020-05-19 13:49:41 +02004283 lua_pushboolean(L, vars_unset_by_name_ifexist(name, len, &smp) != 0);
4284 return 1;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004285}
4286
4287__LJMP static int hlua_applet_http_get_var(lua_State *L)
4288{
Willy Tarreau7e702d12021-04-28 17:59:21 +02004289 struct hlua_appctx *luactx;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004290 struct stream *s;
4291 const char *name;
4292 size_t len;
4293 struct sample smp;
4294
4295 MAY_LJMP(check_args(L, 2, "get_var"));
4296
4297 /* It is useles to retrieve the stream, but this function
4298 * runs only in a stream context.
4299 */
Willy Tarreau7e702d12021-04-28 17:59:21 +02004300 luactx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004301 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
Willy Tarreau7e702d12021-04-28 17:59:21 +02004302 s = luactx->htxn.s;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004303
4304 smp_set_owner(&smp, s->be, s->sess, s, 0);
4305 if (!vars_get_by_name(name, len, &smp)) {
4306 lua_pushnil(L);
4307 return 1;
4308 }
4309
4310 return hlua_smp2lua(L, &smp);
4311}
4312
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01004313__LJMP static int hlua_applet_http_set_priv(lua_State *L)
4314{
Willy Tarreau7e702d12021-04-28 17:59:21 +02004315 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4316 struct stream *s = luactx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01004317 struct hlua *hlua;
4318
4319 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01004320 if (!s->hlua)
4321 return 0;
4322 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01004323
4324 MAY_LJMP(check_args(L, 2, "set_priv"));
4325
4326 /* Remove previous value. */
Thierry FOURNIERe068b602017-04-26 13:27:05 +02004327 luaL_unref(L, LUA_REGISTRYINDEX, hlua->Mref);
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01004328
4329 /* Get and store new value. */
4330 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
4331 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
4332
4333 return 0;
4334}
4335
4336__LJMP static int hlua_applet_http_get_priv(lua_State *L)
4337{
Willy Tarreau7e702d12021-04-28 17:59:21 +02004338 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4339 struct stream *s = luactx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01004340 struct hlua *hlua;
4341
4342 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01004343 if (!s->hlua) {
4344 lua_pushnil(L);
4345 return 1;
4346 }
4347 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01004348
4349 /* Push configuration index in the stack. */
4350 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
4351
4352 return 1;
4353}
4354
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004355/* If expected data not yet available, it returns a yield. This function
4356 * consumes the data in the buffer. It returns a string containing the
4357 * data. This string can be empty.
4358 */
Christopher Fauleta2097962019-07-15 16:25:33 +02004359__LJMP static int hlua_applet_http_getline_yield(lua_State *L, int status, lua_KContext ctx)
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004360{
Willy Tarreau7e702d12021-04-28 17:59:21 +02004361 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4362 struct stream_interface *si = luactx->appctx->owner;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004363 struct channel *req = si_oc(si);
4364 struct htx *htx;
4365 struct htx_blk *blk;
4366 size_t count;
4367 int stop = 0;
4368
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004369 htx = htx_from_buf(&req->buf);
4370 count = co_data(req);
Christopher Fauleta3f15502019-05-13 15:27:23 +02004371 blk = htx_get_first_blk(htx);
Christopher Fauletcc26b132018-12-18 21:20:57 +01004372
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004373 while (count && !stop && blk) {
4374 enum htx_blk_type type = htx_get_blk_type(blk);
4375 uint32_t sz = htx_get_blksz(blk);
4376 struct ist v;
4377 uint32_t vlen;
4378 char *nl;
4379
4380 vlen = sz;
4381 if (vlen > count) {
4382 if (type != HTX_BLK_DATA)
4383 break;
4384 vlen = count;
4385 }
4386
4387 switch (type) {
4388 case HTX_BLK_UNUSED:
4389 break;
4390
4391 case HTX_BLK_DATA:
4392 v = htx_get_blk_value(htx, blk);
4393 v.len = vlen;
4394 nl = istchr(v, '\n');
4395 if (nl != NULL) {
4396 stop = 1;
4397 vlen = nl - v.ptr + 1;
4398 }
Willy Tarreau7e702d12021-04-28 17:59:21 +02004399 luaL_addlstring(&luactx->b, v.ptr, vlen);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004400 break;
4401
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004402 case HTX_BLK_TLR:
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01004403 case HTX_BLK_EOT:
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004404 stop = 1;
4405 break;
4406
4407 default:
4408 break;
4409 }
4410
4411 co_set_data(req, co_data(req) - vlen);
4412 count -= vlen;
4413 if (sz == vlen)
4414 blk = htx_remove_blk(htx, blk);
4415 else {
4416 htx_cut_data_blk(htx, blk, vlen);
4417 break;
4418 }
4419 }
4420
Christopher Fauleteccb31c2021-04-02 14:24:56 +02004421 /* The message was fully consumed and no more data are expected
4422 * (EOM flag set).
4423 */
Christopher Fauleta5a25b12022-08-29 15:37:16 +02004424 if (htx_is_empty(htx) && (req->flags & CF_EOI))
Christopher Fauleteccb31c2021-04-02 14:24:56 +02004425 stop = 1;
4426
Christopher Faulet0ae79d02019-02-27 21:36:59 +01004427 htx_to_buf(htx, &req->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004428 if (!stop) {
4429 si_cant_get(si);
Christopher Fauleta2097962019-07-15 16:25:33 +02004430 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_getline_yield, TICK_ETERNITY, 0));
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004431 }
4432
4433 /* return the result. */
Willy Tarreau7e702d12021-04-28 17:59:21 +02004434 luaL_pushresult(&luactx->b);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004435 return 1;
4436}
4437
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004438
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004439/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004440__LJMP static int hlua_applet_http_getline(lua_State *L)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004441{
Willy Tarreau7e702d12021-04-28 17:59:21 +02004442 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004443
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004444 /* Initialise the string catenation. */
Willy Tarreau7e702d12021-04-28 17:59:21 +02004445 luaL_buffinit(L, &luactx->b);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004446
Christopher Fauleta2097962019-07-15 16:25:33 +02004447 return MAY_LJMP(hlua_applet_http_getline_yield(L, 0, 0));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004448}
4449
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004450/* If expected data not yet available, it returns a yield. This function
4451 * consumes the data in the buffer. It returns a string containing the
4452 * data. This string can be empty.
4453 */
Christopher Fauleta2097962019-07-15 16:25:33 +02004454__LJMP static int hlua_applet_http_recv_yield(lua_State *L, int status, lua_KContext ctx)
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004455{
Willy Tarreau7e702d12021-04-28 17:59:21 +02004456 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4457 struct stream_interface *si = luactx->appctx->owner;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004458 struct channel *req = si_oc(si);
4459 struct htx *htx;
4460 struct htx_blk *blk;
4461 size_t count;
4462 int len;
4463
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004464 htx = htx_from_buf(&req->buf);
4465 len = MAY_LJMP(luaL_checkinteger(L, 2));
4466 count = co_data(req);
Christopher Faulet29f17582019-05-23 11:03:26 +02004467 blk = htx_get_head_blk(htx);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004468 while (count && len && blk) {
4469 enum htx_blk_type type = htx_get_blk_type(blk);
4470 uint32_t sz = htx_get_blksz(blk);
4471 struct ist v;
4472 uint32_t vlen;
4473
4474 vlen = sz;
4475 if (len > 0 && vlen > len)
4476 vlen = len;
4477 if (vlen > count) {
4478 if (type != HTX_BLK_DATA)
4479 break;
4480 vlen = count;
4481 }
4482
4483 switch (type) {
4484 case HTX_BLK_UNUSED:
4485 break;
4486
4487 case HTX_BLK_DATA:
4488 v = htx_get_blk_value(htx, blk);
Willy Tarreau7e702d12021-04-28 17:59:21 +02004489 luaL_addlstring(&luactx->b, v.ptr, vlen);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004490 break;
4491
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004492 case HTX_BLK_TLR:
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01004493 case HTX_BLK_EOT:
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004494 len = 0;
4495 break;
4496
4497 default:
4498 break;
4499 }
4500
4501 co_set_data(req, co_data(req) - vlen);
4502 count -= vlen;
4503 if (len > 0)
4504 len -= vlen;
4505 if (sz == vlen)
4506 blk = htx_remove_blk(htx, blk);
4507 else {
4508 htx_cut_data_blk(htx, blk, vlen);
4509 break;
4510 }
4511 }
4512
Christopher Fauleteccb31c2021-04-02 14:24:56 +02004513 /* The message was fully consumed and no more data are expected
4514 * (EOM flag set).
4515 */
Christopher Fauleta5a25b12022-08-29 15:37:16 +02004516 if (htx_is_empty(htx) && (req->flags & CF_EOI))
Christopher Fauleteccb31c2021-04-02 14:24:56 +02004517 len = 0;
4518
Christopher Faulet0ae79d02019-02-27 21:36:59 +01004519 htx_to_buf(htx, &req->buf);
4520
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004521 /* If we are no other data available, yield waiting for new data. */
4522 if (len) {
4523 if (len > 0) {
4524 lua_pushinteger(L, len);
4525 lua_replace(L, 2);
4526 }
4527 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02004528 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004529 }
4530
4531 /* return the result. */
Willy Tarreau7e702d12021-04-28 17:59:21 +02004532 luaL_pushresult(&luactx->b);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004533 return 1;
4534}
4535
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004536/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004537__LJMP static int hlua_applet_http_recv(lua_State *L)
4538{
Willy Tarreau7e702d12021-04-28 17:59:21 +02004539 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004540 int len = -1;
4541
4542 /* Check arguments. */
4543 if (lua_gettop(L) > 2)
4544 WILL_LJMP(luaL_error(L, "The 'recv' function requires between 1 and 2 arguments."));
4545 if (lua_gettop(L) >= 2) {
4546 len = MAY_LJMP(luaL_checkinteger(L, 2));
4547 lua_pop(L, 1);
4548 }
4549
Christopher Fauleta2097962019-07-15 16:25:33 +02004550 lua_pushinteger(L, len);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004551
Christopher Fauleta2097962019-07-15 16:25:33 +02004552 /* Initialise the string catenation. */
Willy Tarreau7e702d12021-04-28 17:59:21 +02004553 luaL_buffinit(L, &luactx->b);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004554
Christopher Fauleta2097962019-07-15 16:25:33 +02004555 return MAY_LJMP(hlua_applet_http_recv_yield(L, 0, 0));
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004556}
4557
4558/* Append data in the output side of the buffer. This data is immediately
4559 * sent. The function returns the amount of data written. If the buffer
4560 * cannot contain the data, the function yields. The function returns -1
4561 * if the channel is closed.
4562 */
Christopher Fauleta2097962019-07-15 16:25:33 +02004563__LJMP static int hlua_applet_http_send_yield(lua_State *L, int status, lua_KContext ctx)
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004564{
Willy Tarreau7e702d12021-04-28 17:59:21 +02004565 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4566 struct stream_interface *si = luactx->appctx->owner;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004567 struct channel *res = si_ic(si);
4568 struct htx *htx = htx_from_buf(&res->buf);
4569 const char *data;
4570 size_t len;
4571 int l = MAY_LJMP(luaL_checkinteger(L, 3));
4572 int max;
4573
Christopher Faulet9060fc02019-07-03 11:39:30 +02004574 max = htx_get_max_blksz(htx, channel_htx_recv_max(res, htx));
Christopher Faulet4b0e9b22019-01-09 12:16:58 +01004575 if (!max)
4576 goto snd_yield;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004577
4578 data = MAY_LJMP(luaL_checklstring(L, 2, &len));
4579
4580 /* Get the max amount of data which can write as input in the channel. */
4581 if (max > (len - l))
4582 max = len - l;
4583
4584 /* Copy data. */
Willy Tarreau0a7ef022019-05-28 10:30:11 +02004585 max = htx_add_data(htx, ist2(data + l, max));
Christopher Fauletf6cce3f2019-02-27 21:20:09 +01004586 channel_add_input(res, max);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004587
4588 /* update counters. */
4589 l += max;
4590 lua_pop(L, 1);
4591 lua_pushinteger(L, l);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004592
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004593 /* If some data is not send, declares the situation to the
4594 * applet, and returns a yield.
4595 */
4596 if (l < len) {
Christopher Faulet4b0e9b22019-01-09 12:16:58 +01004597 snd_yield:
Christopher Faulet0ae79d02019-02-27 21:36:59 +01004598 htx_to_buf(htx, &res->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004599 si_rx_room_blk(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02004600 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004601 }
4602
Christopher Fauleta2097962019-07-15 16:25:33 +02004603 htx_to_buf(htx, &res->buf);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004604 return 1;
4605}
4606
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05004607/* Just a wrapper of "hlua_applet_send_yield". This wrapper permits
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004608 * yield the LUA process, and resume it without checking the
4609 * input arguments.
4610 */
4611__LJMP static int hlua_applet_http_send(lua_State *L)
4612{
Willy Tarreau7e702d12021-04-28 17:59:21 +02004613 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004614
4615 /* We want to send some data. Headers must be sent. */
Willy Tarreau7e702d12021-04-28 17:59:21 +02004616 if (!(luactx->appctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT)) {
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004617 hlua_pusherror(L, "Lua: 'send' you must call start_response() before sending data.");
4618 WILL_LJMP(lua_error(L));
4619 }
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004620
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05004621 /* This integer is used for followinf the amount of data sent. */
Christopher Fauleta2097962019-07-15 16:25:33 +02004622 lua_pushinteger(L, 0);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004623
Christopher Fauleta2097962019-07-15 16:25:33 +02004624 return MAY_LJMP(hlua_applet_http_send_yield(L, 0, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004625}
4626
4627__LJMP static int hlua_applet_http_addheader(lua_State *L)
4628{
4629 const char *name;
4630 int ret;
4631
4632 MAY_LJMP(hlua_checkapplet_http(L, 1));
4633 name = MAY_LJMP(luaL_checkstring(L, 2));
4634 MAY_LJMP(luaL_checkstring(L, 3));
4635
4636 /* Push in the stack the "response" entry. */
4637 ret = lua_getfield(L, 1, "response");
4638 if (ret != LUA_TTABLE) {
4639 hlua_pusherror(L, "Lua: 'add_header' internal error: AppletHTTP['response'] "
4640 "is expected as an array. %s found", lua_typename(L, ret));
4641 WILL_LJMP(lua_error(L));
4642 }
4643
4644 /* check if the header is already registered if it is not
4645 * the case, register it.
4646 */
4647 ret = lua_getfield(L, -1, name);
4648 if (ret == LUA_TNIL) {
4649
4650 /* Entry not found. */
4651 lua_pop(L, 1); /* remove the nil. The "response" table is the top of the stack. */
4652
4653 /* Insert the new header name in the array in the top of the stack.
4654 * It left the new array in the top of the stack.
4655 */
4656 lua_newtable(L);
4657 lua_pushvalue(L, 2);
4658 lua_pushvalue(L, -2);
4659 lua_settable(L, -4);
4660
4661 } else if (ret != LUA_TTABLE) {
4662
4663 /* corruption error. */
4664 hlua_pusherror(L, "Lua: 'add_header' internal error: AppletHTTP['response']['%s'] "
4665 "is expected as an array. %s found", name, lua_typename(L, ret));
4666 WILL_LJMP(lua_error(L));
4667 }
4668
Thayne McCombs8f0cc5c2021-01-07 21:35:52 -07004669 /* Now the top of thestack is an array of values. We push
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004670 * the header value as new entry.
4671 */
4672 lua_pushvalue(L, 3);
4673 ret = lua_rawlen(L, -2);
4674 lua_rawseti(L, -2, ret + 1);
4675 lua_pushboolean(L, 1);
4676 return 1;
4677}
4678
4679__LJMP static int hlua_applet_http_status(lua_State *L)
4680{
Willy Tarreau7e702d12021-04-28 17:59:21 +02004681 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004682 int status = MAY_LJMP(luaL_checkinteger(L, 2));
Robin H. Johnson52f5db22017-01-01 13:10:52 -08004683 const char *reason = MAY_LJMP(luaL_optlstring(L, 3, NULL, NULL));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004684
4685 if (status < 100 || status > 599) {
4686 lua_pushboolean(L, 0);
4687 return 1;
4688 }
4689
Willy Tarreau7e702d12021-04-28 17:59:21 +02004690 luactx->appctx->ctx.hlua_apphttp.status = status;
4691 luactx->appctx->ctx.hlua_apphttp.reason = reason;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004692 lua_pushboolean(L, 1);
4693 return 1;
4694}
4695
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004696
Christopher Fauleta2097962019-07-15 16:25:33 +02004697__LJMP static int hlua_applet_http_send_response(lua_State *L)
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004698{
Willy Tarreau7e702d12021-04-28 17:59:21 +02004699 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4700 struct stream_interface *si = luactx->appctx->owner;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004701 struct channel *res = si_ic(si);
4702 struct htx *htx;
4703 struct htx_sl *sl;
4704 struct h1m h1m;
4705 const char *status, *reason;
4706 const char *name, *value;
4707 size_t nlen, vlen;
4708 unsigned int flags;
4709
4710 /* Send the message at once. */
4711 htx = htx_from_buf(&res->buf);
4712 h1m_init_res(&h1m);
4713
4714 /* Use the same http version than the request. */
Willy Tarreau7e702d12021-04-28 17:59:21 +02004715 status = ultoa_r(luactx->appctx->ctx.hlua_apphttp.status, trash.area, trash.size);
4716 reason = luactx->appctx->ctx.hlua_apphttp.reason;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004717 if (reason == NULL)
Willy Tarreau7e702d12021-04-28 17:59:21 +02004718 reason = http_get_reason(luactx->appctx->ctx.hlua_apphttp.status);
4719 if (luactx->appctx->ctx.hlua_apphttp.flags & APPLET_HTTP11) {
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004720 flags = (HTX_SL_F_IS_RESP|HTX_SL_F_VER_11);
4721 sl = htx_add_stline(htx, HTX_BLK_RES_SL, flags, ist("HTTP/1.1"), ist(status), ist(reason));
4722 }
4723 else {
4724 flags = HTX_SL_F_IS_RESP;
4725 sl = htx_add_stline(htx, HTX_BLK_RES_SL, flags, ist("HTTP/1.0"), ist(status), ist(reason));
4726 }
4727 if (!sl) {
4728 hlua_pusherror(L, "Lua applet http '%s': Failed to create response.\n",
Willy Tarreau7e702d12021-04-28 17:59:21 +02004729 luactx->appctx->rule->arg.hlua_rule->fcn->name);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004730 WILL_LJMP(lua_error(L));
4731 }
Willy Tarreau7e702d12021-04-28 17:59:21 +02004732 sl->info.res.status = luactx->appctx->ctx.hlua_apphttp.status;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004733
4734 /* Get the array associated to the field "response" in the object AppletHTTP. */
4735 lua_pushvalue(L, 0);
4736 if (lua_getfield(L, 1, "response") != LUA_TTABLE) {
4737 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response'] missing.\n",
Willy Tarreau7e702d12021-04-28 17:59:21 +02004738 luactx->appctx->rule->arg.hlua_rule->fcn->name);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004739 WILL_LJMP(lua_error(L));
4740 }
4741
4742 /* Browse the list of headers. */
4743 lua_pushnil(L);
4744 while(lua_next(L, -2) != 0) {
4745 /* We expect a string as -2. */
4746 if (lua_type(L, -2) != LUA_TSTRING) {
4747 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response'][] element must be a string. got %s.\n",
Willy Tarreau7e702d12021-04-28 17:59:21 +02004748 luactx->appctx->rule->arg.hlua_rule->fcn->name,
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004749 lua_typename(L, lua_type(L, -2)));
4750 WILL_LJMP(lua_error(L));
4751 }
4752 name = lua_tolstring(L, -2, &nlen);
4753
4754 /* We expect an array as -1. */
4755 if (lua_type(L, -1) != LUA_TTABLE) {
4756 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'] element must be an table. got %s.\n",
Willy Tarreau7e702d12021-04-28 17:59:21 +02004757 luactx->appctx->rule->arg.hlua_rule->fcn->name,
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004758 name,
4759 lua_typename(L, lua_type(L, -1)));
4760 WILL_LJMP(lua_error(L));
4761 }
4762
4763 /* Browse the table who is on the top of the stack. */
4764 lua_pushnil(L);
4765 while(lua_next(L, -2) != 0) {
4766 int id;
4767
4768 /* We expect a number as -2. */
4769 if (lua_type(L, -2) != LUA_TNUMBER) {
4770 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'][] element must be a number. got %s.\n",
Willy Tarreau7e702d12021-04-28 17:59:21 +02004771 luactx->appctx->rule->arg.hlua_rule->fcn->name,
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004772 name,
4773 lua_typename(L, lua_type(L, -2)));
4774 WILL_LJMP(lua_error(L));
4775 }
4776 id = lua_tointeger(L, -2);
4777
4778 /* We expect a string as -2. */
4779 if (lua_type(L, -1) != LUA_TSTRING) {
4780 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'][%d] element must be a string. got %s.\n",
Willy Tarreau7e702d12021-04-28 17:59:21 +02004781 luactx->appctx->rule->arg.hlua_rule->fcn->name,
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004782 name, id,
4783 lua_typename(L, lua_type(L, -1)));
4784 WILL_LJMP(lua_error(L));
4785 }
4786 value = lua_tolstring(L, -1, &vlen);
4787
4788 /* Simple Protocol checks. */
4789 if (isteqi(ist2(name, nlen), ist("transfer-encoding")))
Christopher Faulet700d9e82020-01-31 12:21:52 +01004790 h1_parse_xfer_enc_header(&h1m, ist2(value, vlen));
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004791 else if (isteqi(ist2(name, nlen), ist("content-length"))) {
4792 struct ist v = ist2(value, vlen);
4793 int ret;
4794
4795 ret = h1_parse_cont_len_header(&h1m, &v);
4796 if (ret < 0) {
4797 hlua_pusherror(L, "Lua applet http '%s': Invalid '%s' header.\n",
Willy Tarreau7e702d12021-04-28 17:59:21 +02004798 luactx->appctx->rule->arg.hlua_rule->fcn->name,
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004799 name);
4800 WILL_LJMP(lua_error(L));
4801 }
4802 else if (ret == 0)
4803 goto next; /* Skip it */
4804 }
4805
4806 /* Add a new header */
4807 if (!htx_add_header(htx, ist2(name, nlen), ist2(value, vlen))) {
4808 hlua_pusherror(L, "Lua applet http '%s': Failed to add header '%s' in the response.\n",
Willy Tarreau7e702d12021-04-28 17:59:21 +02004809 luactx->appctx->rule->arg.hlua_rule->fcn->name,
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004810 name);
4811 WILL_LJMP(lua_error(L));
4812 }
4813 next:
4814 /* Remove the array from the stack, and get next element with a remaining string. */
4815 lua_pop(L, 1);
4816 }
4817
4818 /* Remove the array from the stack, and get next element with a remaining string. */
4819 lua_pop(L, 1);
4820 }
4821
4822 if (h1m.flags & H1_MF_CHNK)
4823 h1m.flags &= ~H1_MF_CLEN;
4824 if (h1m.flags & (H1_MF_CLEN|H1_MF_CHNK))
4825 h1m.flags |= H1_MF_XFER_LEN;
4826
4827 /* Uset HTX start-line flags */
4828 if (h1m.flags & H1_MF_XFER_ENC)
4829 flags |= HTX_SL_F_XFER_ENC;
4830 if (h1m.flags & H1_MF_XFER_LEN) {
4831 flags |= HTX_SL_F_XFER_LEN;
4832 if (h1m.flags & H1_MF_CHNK)
4833 flags |= HTX_SL_F_CHNK;
4834 else if (h1m.flags & H1_MF_CLEN)
4835 flags |= HTX_SL_F_CLEN;
4836 if (h1m.body_len == 0)
4837 flags |= HTX_SL_F_BODYLESS;
4838 }
4839 sl->flags |= flags;
4840
Thayne McCombs8f0cc5c2021-01-07 21:35:52 -07004841 /* If we don't have a content-length set, and the HTTP version is 1.1
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004842 * and the status code implies the presence of a message body, we must
4843 * announce a transfer encoding chunked. This is required by haproxy
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05004844 * for the keepalive compliance. If the applet announces a transfer-encoding
4845 * chunked itself, don't do anything.
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004846 */
4847 if ((flags & (HTX_SL_F_VER_11|HTX_SL_F_XFER_LEN)) == HTX_SL_F_VER_11 &&
Willy Tarreau7e702d12021-04-28 17:59:21 +02004848 luactx->appctx->ctx.hlua_apphttp.status >= 200 &&
4849 luactx->appctx->ctx.hlua_apphttp.status != 204 &&
4850 luactx->appctx->ctx.hlua_apphttp.status != 304) {
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004851 /* Add a new header */
4852 sl->flags |= (HTX_SL_F_XFER_ENC|H1_MF_CHNK|H1_MF_XFER_LEN);
4853 if (!htx_add_header(htx, ist("transfer-encoding"), ist("chunked"))) {
4854 hlua_pusherror(L, "Lua applet http '%s': Failed to add header 'transfer-encoding' in the response.\n",
Willy Tarreau7e702d12021-04-28 17:59:21 +02004855 luactx->appctx->rule->arg.hlua_rule->fcn->name);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004856 WILL_LJMP(lua_error(L));
4857 }
4858 }
4859
4860 /* Finalize headers. */
4861 if (!htx_add_endof(htx, HTX_BLK_EOH)) {
4862 hlua_pusherror(L, "Lua applet http '%s': Failed create the response.\n",
Willy Tarreau7e702d12021-04-28 17:59:21 +02004863 luactx->appctx->rule->arg.hlua_rule->fcn->name);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004864 WILL_LJMP(lua_error(L));
4865 }
4866
4867 if (htx_used_space(htx) > b_size(&res->buf) - global.tune.maxrewrite) {
4868 b_reset(&res->buf);
4869 hlua_pusherror(L, "Lua: 'start_response': response header block too big");
4870 WILL_LJMP(lua_error(L));
4871 }
4872
4873 htx_to_buf(htx, &res->buf);
Christopher Fauletf6cce3f2019-02-27 21:20:09 +01004874 channel_add_input(res, htx->data);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004875
4876 /* Headers sent, set the flag. */
Willy Tarreau7e702d12021-04-28 17:59:21 +02004877 luactx->appctx->ctx.hlua_apphttp.flags |= APPLET_HDR_SENT;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004878 return 0;
4879
4880}
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004881/* We will build the status line and the headers of the HTTP response.
4882 * We will try send at once if its not possible, we give back the hand
4883 * waiting for more room.
4884 */
Christopher Fauleta2097962019-07-15 16:25:33 +02004885__LJMP static int hlua_applet_http_start_response_yield(lua_State *L, int status, lua_KContext ctx)
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004886{
Willy Tarreau7e702d12021-04-28 17:59:21 +02004887 struct hlua_appctx *luactx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4888 struct stream_interface *si = luactx->appctx->owner;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004889 struct channel *res = si_ic(si);
4890
4891 if (co_data(res)) {
4892 si_rx_room_blk(si);
Christopher Fauleta2097962019-07-15 16:25:33 +02004893 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_start_response_yield, TICK_ETERNITY, 0));
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004894 }
Christopher Fauleta2097962019-07-15 16:25:33 +02004895 return MAY_LJMP(hlua_applet_http_send_response(L));
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004896}
4897
4898
Christopher Fauleta2097962019-07-15 16:25:33 +02004899__LJMP static int hlua_applet_http_start_response(lua_State *L)
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004900{
Christopher Fauleta2097962019-07-15 16:25:33 +02004901 return MAY_LJMP(hlua_applet_http_start_response_yield(L, 0, 0));
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004902}
4903
Christopher Fauleta2097962019-07-15 16:25:33 +02004904/*
4905 *
4906 *
4907 * Class HTTP
4908 *
4909 *
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004910 */
Christopher Fauleta2097962019-07-15 16:25:33 +02004911
4912/* Returns a struct hlua_txn if the stack entry "ud" is
4913 * a class stream, otherwise it throws an error.
4914 */
4915__LJMP static struct hlua_txn *hlua_checkhttp(lua_State *L, int ud)
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004916{
Christopher Fauleta2097962019-07-15 16:25:33 +02004917 return MAY_LJMP(hlua_checkudata(L, ud, class_http_ref));
4918}
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004919
Christopher Fauleta2097962019-07-15 16:25:33 +02004920/* This function creates and push in the stack a HTTP object
4921 * according with a current TXN.
4922 */
4923static int hlua_http_new(lua_State *L, struct hlua_txn *txn)
4924{
4925 struct hlua_txn *htxn;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004926
Christopher Fauleta2097962019-07-15 16:25:33 +02004927 /* Check stack size. */
4928 if (!lua_checkstack(L, 3))
4929 return 0;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004930
Christopher Fauleta2097962019-07-15 16:25:33 +02004931 /* Create the object: obj[0] = userdata.
4932 * Note that the base of the Converters object is the
4933 * same than the TXN object.
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004934 */
Christopher Fauleta2097962019-07-15 16:25:33 +02004935 lua_newtable(L);
4936 htxn = lua_newuserdata(L, sizeof(*htxn));
4937 lua_rawseti(L, -2, 0);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004938
4939 htxn->s = txn->s;
4940 htxn->p = txn->p;
Christopher Faulet256b69a2019-05-23 11:14:21 +02004941 htxn->dir = txn->dir;
4942 htxn->flags = txn->flags;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004943
4944 /* Pop a class stream metatable and affect it to the table. */
4945 lua_rawgeti(L, LUA_REGISTRYINDEX, class_http_ref);
4946 lua_setmetatable(L, -2);
4947
4948 return 1;
4949}
4950
4951/* This function creates ans returns an array of HTTP headers.
4952 * This function does not fails. It is used as wrapper with the
4953 * 2 following functions.
4954 */
Christopher Faulet9d1332b2020-02-24 16:46:16 +01004955__LJMP static int hlua_http_get_headers(lua_State *L, struct http_msg *msg)
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004956{
Christopher Fauleta2097962019-07-15 16:25:33 +02004957 struct htx *htx;
4958 int32_t pos;
4959
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004960 /* Create the table. */
4961 lua_newtable(L);
4962
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004963
Christopher Fauleta2097962019-07-15 16:25:33 +02004964 htx = htxbuf(&msg->chn->buf);
4965 for (pos = htx_get_first(htx); pos != -1; pos = htx_get_next(htx, pos)) {
4966 struct htx_blk *blk = htx_get_blk(htx, pos);
4967 enum htx_blk_type type = htx_get_blk_type(blk);
4968 struct ist n, v;
4969 int len;
Christopher Faulet724a12c2018-12-13 22:12:15 +01004970
Christopher Fauleta2097962019-07-15 16:25:33 +02004971 if (type == HTX_BLK_HDR) {
4972 n = htx_get_blk_name(htx,blk);
4973 v = htx_get_blk_value(htx, blk);
Christopher Faulet724a12c2018-12-13 22:12:15 +01004974 }
Christopher Fauleta2097962019-07-15 16:25:33 +02004975 else if (type == HTX_BLK_EOH)
4976 break;
4977 else
4978 continue;
Christopher Faulet724a12c2018-12-13 22:12:15 +01004979
Christopher Fauleta2097962019-07-15 16:25:33 +02004980 /* Check for existing entry:
4981 * assume that the table is on the top of the stack, and
4982 * push the key in the stack, the function lua_gettable()
4983 * perform the lookup.
4984 */
4985 lua_pushlstring(L, n.ptr, n.len);
4986 lua_gettable(L, -2);
Christopher Faulet724a12c2018-12-13 22:12:15 +01004987
Christopher Fauleta2097962019-07-15 16:25:33 +02004988 switch (lua_type(L, -1)) {
4989 case LUA_TNIL:
4990 /* Table not found, create it. */
4991 lua_pop(L, 1); /* remove the nil value. */
4992 lua_pushlstring(L, n.ptr, n.len); /* push the header name as key. */
4993 lua_newtable(L); /* create and push empty table. */
4994 lua_pushlstring(L, v.ptr, v.len); /* push header value. */
4995 lua_rawseti(L, -2, 0); /* index header value (pop it). */
4996 lua_rawset(L, -3); /* index new table with header name (pop the values). */
Christopher Faulet724a12c2018-12-13 22:12:15 +01004997 break;
Christopher Faulet724a12c2018-12-13 22:12:15 +01004998
Christopher Fauleta2097962019-07-15 16:25:33 +02004999 case LUA_TTABLE:
5000 /* Entry found: push the value in the table. */
5001 len = lua_rawlen(L, -1);
5002 lua_pushlstring(L, v.ptr, v.len); /* push header value. */
5003 lua_rawseti(L, -2, len+1); /* index header value (pop it). */
5004 lua_pop(L, 1); /* remove the table (it is stored in the main table). */
5005 break;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005006
Christopher Fauleta2097962019-07-15 16:25:33 +02005007 default:
5008 /* Other cases are errors. */
5009 hlua_pusherror(L, "internal error during the parsing of headers.");
5010 WILL_LJMP(lua_error(L));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005011 }
5012 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005013 return 1;
5014}
5015
5016__LJMP static int hlua_http_req_get_headers(lua_State *L)
5017{
5018 struct hlua_txn *htxn;
5019
5020 MAY_LJMP(check_args(L, 1, "req_get_headers"));
5021 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5022
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005023 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005024 WILL_LJMP(lua_error(L));
5025
Christopher Faulet9d1332b2020-02-24 16:46:16 +01005026 return hlua_http_get_headers(L, &htxn->s->txn->req);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005027}
5028
5029__LJMP static int hlua_http_res_get_headers(lua_State *L)
5030{
5031 struct hlua_txn *htxn;
5032
5033 MAY_LJMP(check_args(L, 1, "res_get_headers"));
5034 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5035
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005036 if (htxn->dir != SMP_OPT_DIR_RES || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005037 WILL_LJMP(lua_error(L));
5038
Christopher Faulet9d1332b2020-02-24 16:46:16 +01005039 return hlua_http_get_headers(L, &htxn->s->txn->rsp);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005040}
5041
5042/* This function replace full header, or just a value in
5043 * the request or in the response. It is a wrapper fir the
5044 * 4 following functions.
5045 */
Christopher Fauletd1914aa2020-02-24 16:52:46 +01005046__LJMP static inline int hlua_http_rep_hdr(lua_State *L, struct http_msg *msg, int full)
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005047{
5048 size_t name_len;
5049 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
5050 const char *reg = MAY_LJMP(luaL_checkstring(L, 3));
5051 const char *value = MAY_LJMP(luaL_checkstring(L, 4));
Christopher Fauleta2097962019-07-15 16:25:33 +02005052 struct htx *htx;
Dragan Dosen26743032019-04-30 15:54:36 +02005053 struct my_regex *re;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005054
Dragan Dosen26743032019-04-30 15:54:36 +02005055 if (!(re = regex_comp(reg, 1, 1, NULL)))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005056 WILL_LJMP(luaL_argerror(L, 3, "invalid regex"));
5057
Christopher Fauleta2097962019-07-15 16:25:33 +02005058 htx = htxbuf(&msg->chn->buf);
Christopher Fauletd1914aa2020-02-24 16:52:46 +01005059 http_replace_hdrs(chn_strm(msg->chn), htx, ist2(name, name_len), value, re, full);
Dragan Dosen26743032019-04-30 15:54:36 +02005060 regex_free(re);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005061 return 0;
5062}
5063
5064__LJMP static int hlua_http_req_rep_hdr(lua_State *L)
5065{
5066 struct hlua_txn *htxn;
5067
5068 MAY_LJMP(check_args(L, 4, "req_rep_hdr"));
5069 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5070
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005071 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005072 WILL_LJMP(lua_error(L));
5073
Christopher Fauletd1914aa2020-02-24 16:52:46 +01005074 return MAY_LJMP(hlua_http_rep_hdr(L, &htxn->s->txn->req, 1));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005075}
5076
5077__LJMP static int hlua_http_res_rep_hdr(lua_State *L)
5078{
5079 struct hlua_txn *htxn;
5080
5081 MAY_LJMP(check_args(L, 4, "res_rep_hdr"));
5082 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5083
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005084 if (htxn->dir != SMP_OPT_DIR_RES || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005085 WILL_LJMP(lua_error(L));
5086
Christopher Fauletd1914aa2020-02-24 16:52:46 +01005087 return MAY_LJMP(hlua_http_rep_hdr(L, &htxn->s->txn->rsp, 1));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005088}
5089
5090__LJMP static int hlua_http_req_rep_val(lua_State *L)
5091{
5092 struct hlua_txn *htxn;
5093
5094 MAY_LJMP(check_args(L, 4, "req_rep_hdr"));
5095 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5096
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005097 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005098 WILL_LJMP(lua_error(L));
5099
Christopher Fauletd1914aa2020-02-24 16:52:46 +01005100 return MAY_LJMP(hlua_http_rep_hdr(L, &htxn->s->txn->req, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005101}
5102
5103__LJMP static int hlua_http_res_rep_val(lua_State *L)
5104{
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005105 struct hlua_txn *htxn;
5106
5107 MAY_LJMP(check_args(L, 4, "res_rep_val"));
5108 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5109
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005110 if (htxn->dir != SMP_OPT_DIR_RES || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005111 WILL_LJMP(lua_error(L));
5112
Christopher Fauletd1914aa2020-02-24 16:52:46 +01005113 return MAY_LJMP(hlua_http_rep_hdr(L, &htxn->s->txn->rsp, 0));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005114}
5115
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08005116/* This function deletes all the occurrences of an header.
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005117 * It is a wrapper for the 2 following functions.
5118 */
Christopher Fauletd31c7b32020-02-25 09:37:57 +01005119__LJMP static inline int hlua_http_del_hdr(lua_State *L, struct http_msg *msg)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005120{
5121 size_t len;
5122 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &len));
Christopher Fauleta2097962019-07-15 16:25:33 +02005123 struct htx *htx = htxbuf(&msg->chn->buf);
5124 struct http_hdr_ctx ctx;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005125
Christopher Fauleta2097962019-07-15 16:25:33 +02005126 ctx.blk = NULL;
5127 while (http_find_header(htx, ist2(name, len), &ctx, 1))
5128 http_remove_header(htx, &ctx);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005129 return 0;
5130}
5131
5132__LJMP static int hlua_http_req_del_hdr(lua_State *L)
5133{
5134 struct hlua_txn *htxn;
5135
5136 MAY_LJMP(check_args(L, 2, "req_del_hdr"));
5137 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5138
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005139 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005140 WILL_LJMP(lua_error(L));
5141
Christopher Fauletd31c7b32020-02-25 09:37:57 +01005142 return hlua_http_del_hdr(L, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005143}
5144
5145__LJMP static int hlua_http_res_del_hdr(lua_State *L)
5146{
5147 struct hlua_txn *htxn;
5148
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005149 MAY_LJMP(check_args(L, 2, "res_del_hdr"));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005150 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5151
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005152 if (htxn->dir != SMP_OPT_DIR_RES || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005153 WILL_LJMP(lua_error(L));
5154
Christopher Fauletd31c7b32020-02-25 09:37:57 +01005155 return hlua_http_del_hdr(L, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005156}
5157
5158/* This function adds an header. It is a wrapper used by
5159 * the 2 following functions.
5160 */
Christopher Fauletd31c7b32020-02-25 09:37:57 +01005161__LJMP static inline int hlua_http_add_hdr(lua_State *L, struct http_msg *msg)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005162{
5163 size_t name_len;
5164 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
5165 size_t value_len;
5166 const char *value = MAY_LJMP(luaL_checklstring(L, 3, &value_len));
Christopher Fauleta2097962019-07-15 16:25:33 +02005167 struct htx *htx = htxbuf(&msg->chn->buf);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005168
Christopher Fauleta2097962019-07-15 16:25:33 +02005169 lua_pushboolean(L, http_add_header(htx, ist2(name, name_len),
5170 ist2(value, value_len)));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005171 return 0;
5172}
5173
5174__LJMP static int hlua_http_req_add_hdr(lua_State *L)
5175{
5176 struct hlua_txn *htxn;
5177
5178 MAY_LJMP(check_args(L, 3, "req_add_hdr"));
5179 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5180
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005181 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005182 WILL_LJMP(lua_error(L));
5183
Christopher Fauletd31c7b32020-02-25 09:37:57 +01005184 return hlua_http_add_hdr(L, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005185}
5186
5187__LJMP static int hlua_http_res_add_hdr(lua_State *L)
5188{
5189 struct hlua_txn *htxn;
5190
5191 MAY_LJMP(check_args(L, 3, "res_add_hdr"));
5192 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5193
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005194 if (htxn->dir != SMP_OPT_DIR_RES || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005195 WILL_LJMP(lua_error(L));
5196
Christopher Fauletd31c7b32020-02-25 09:37:57 +01005197 return hlua_http_add_hdr(L, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005198}
5199
5200static int hlua_http_req_set_hdr(lua_State *L)
5201{
5202 struct hlua_txn *htxn;
5203
5204 MAY_LJMP(check_args(L, 3, "req_set_hdr"));
5205 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5206
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005207 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005208 WILL_LJMP(lua_error(L));
5209
Christopher Fauletd31c7b32020-02-25 09:37:57 +01005210 hlua_http_del_hdr(L, &htxn->s->txn->req);
5211 return hlua_http_add_hdr(L, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005212}
5213
5214static int hlua_http_res_set_hdr(lua_State *L)
5215{
5216 struct hlua_txn *htxn;
5217
5218 MAY_LJMP(check_args(L, 3, "res_set_hdr"));
5219 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5220
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005221 if (htxn->dir != SMP_OPT_DIR_RES || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005222 WILL_LJMP(lua_error(L));
5223
Christopher Fauletd31c7b32020-02-25 09:37:57 +01005224 hlua_http_del_hdr(L, &htxn->s->txn->rsp);
5225 return hlua_http_add_hdr(L, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005226}
5227
5228/* This function set the method. */
5229static int hlua_http_req_set_meth(lua_State *L)
5230{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02005231 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005232 size_t name_len;
5233 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005234
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005235 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005236 WILL_LJMP(lua_error(L));
5237
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02005238 lua_pushboolean(L, http_req_replace_stline(0, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005239 return 1;
5240}
5241
5242/* This function set the method. */
5243static int hlua_http_req_set_path(lua_State *L)
5244{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02005245 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005246 size_t name_len;
5247 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER / OZON.IOb84ae922016-08-02 23:44:58 +02005248
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005249 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005250 WILL_LJMP(lua_error(L));
5251
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02005252 lua_pushboolean(L, http_req_replace_stline(1, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005253 return 1;
5254}
5255
5256/* This function set the query-string. */
5257static int hlua_http_req_set_query(lua_State *L)
5258{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02005259 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005260 size_t name_len;
5261 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005262
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005263 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005264 WILL_LJMP(lua_error(L));
5265
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005266 /* Check length. */
5267 if (name_len > trash.size - 1) {
5268 lua_pushboolean(L, 0);
5269 return 1;
5270 }
5271
5272 /* Add the mark question as prefix. */
5273 chunk_reset(&trash);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005274 trash.area[trash.data++] = '?';
5275 memcpy(trash.area + trash.data, name, name_len);
5276 trash.data += name_len;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005277
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005278 lua_pushboolean(L,
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02005279 http_req_replace_stline(2, trash.area, trash.data, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005280 return 1;
5281}
5282
5283/* This function set the uri. */
5284static int hlua_http_req_set_uri(lua_State *L)
5285{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02005286 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005287 size_t name_len;
5288 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005289
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005290 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005291 WILL_LJMP(lua_error(L));
5292
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02005293 lua_pushboolean(L, http_req_replace_stline(3, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005294 return 1;
5295}
5296
Robin H. Johnson52f5db22017-01-01 13:10:52 -08005297/* This function set the response code & optionally reason. */
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02005298static int hlua_http_res_set_status(lua_State *L)
5299{
5300 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5301 unsigned int code = MAY_LJMP(luaL_checkinteger(L, 2));
Christopher Faulet96bff762019-12-17 13:46:18 +01005302 const char *str = MAY_LJMP(luaL_optlstring(L, 3, NULL, NULL));
5303 const struct ist reason = ist2(str, (str ? strlen(str) : 0));
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02005304
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005305 if (htxn->dir != SMP_OPT_DIR_RES || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005306 WILL_LJMP(lua_error(L));
5307
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02005308 http_res_set_status(code, reason, htxn->s);
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02005309 return 0;
5310}
5311
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005312/*
5313 *
5314 *
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005315 * Class TXN
5316 *
5317 *
5318 */
5319
5320/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02005321 * a class stream, otherwise it throws an error.
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005322 */
5323__LJMP static struct hlua_txn *hlua_checktxn(lua_State *L, int ud)
5324{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02005325 return MAY_LJMP(hlua_checkudata(L, ud, class_txn_ref));
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005326}
5327
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005328__LJMP static int hlua_set_var(lua_State *L)
5329{
5330 struct hlua_txn *htxn;
5331 const char *name;
5332 size_t len;
5333 struct sample smp;
5334
Tim Duesterhus4e172c92020-05-19 13:49:42 +02005335 if (lua_gettop(L) < 3 || lua_gettop(L) > 4)
5336 WILL_LJMP(luaL_error(L, "'set_var' needs between 3 and 4 arguments"));
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005337
5338 /* It is useles to retrieve the stream, but this function
5339 * runs only in a stream context.
5340 */
5341 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5342 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
5343
5344 /* Converts the third argument in a sample. */
Amaury Denoyellebc0af6a2020-10-29 17:21:20 +01005345 memset(&smp, 0, sizeof(smp));
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005346 hlua_lua2smp(L, 3, &smp);
5347
5348 /* Store the sample in a variable. */
Willy Tarreau7560dd42016-03-10 16:28:58 +01005349 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
Tim Duesterhus4e172c92020-05-19 13:49:42 +02005350
5351 if (lua_gettop(L) == 4 && lua_toboolean(L, 4))
5352 lua_pushboolean(L, vars_set_by_name_ifexist(name, len, &smp) != 0);
5353 else
5354 lua_pushboolean(L, vars_set_by_name(name, len, &smp) != 0);
5355
Tim Duesterhus84ebc132020-05-19 13:49:41 +02005356 return 1;
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005357}
5358
Christopher Faulet85d79c92016-11-09 16:54:56 +01005359__LJMP static int hlua_unset_var(lua_State *L)
5360{
5361 struct hlua_txn *htxn;
5362 const char *name;
5363 size_t len;
5364 struct sample smp;
5365
5366 MAY_LJMP(check_args(L, 2, "unset_var"));
5367
5368 /* It is useles to retrieve the stream, but this function
5369 * runs only in a stream context.
5370 */
5371 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5372 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
5373
5374 /* Unset the variable. */
5375 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
Tim Duesterhus84ebc132020-05-19 13:49:41 +02005376 lua_pushboolean(L, vars_unset_by_name_ifexist(name, len, &smp) != 0);
5377 return 1;
Christopher Faulet85d79c92016-11-09 16:54:56 +01005378}
5379
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005380__LJMP static int hlua_get_var(lua_State *L)
5381{
5382 struct hlua_txn *htxn;
5383 const char *name;
5384 size_t len;
5385 struct sample smp;
5386
5387 MAY_LJMP(check_args(L, 2, "get_var"));
5388
5389 /* It is useles to retrieve the stream, but this function
5390 * runs only in a stream context.
5391 */
5392 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5393 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
5394
Willy Tarreau7560dd42016-03-10 16:28:58 +01005395 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
Willy Tarreau6204cd92016-03-10 16:33:04 +01005396 if (!vars_get_by_name(name, len, &smp)) {
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005397 lua_pushnil(L);
5398 return 1;
5399 }
5400
5401 return hlua_smp2lua(L, &smp);
5402}
5403
Willy Tarreau59551662015-03-10 14:23:13 +01005404__LJMP static int hlua_set_priv(lua_State *L)
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005405{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005406 struct hlua *hlua;
5407
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005408 MAY_LJMP(check_args(L, 2, "set_priv"));
5409
Willy Tarreau87b09662015-04-03 00:22:06 +02005410 /* It is useles to retrieve the stream, but this function
5411 * runs only in a stream context.
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005412 */
5413 MAY_LJMP(hlua_checktxn(L, 1));
Thierry Fournier4234dbd2020-11-28 13:18:23 +01005414
5415 /* Get hlua struct, or NULL if we execute from main lua state */
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005416 hlua = hlua_gethlua(L);
Thierry Fournier4234dbd2020-11-28 13:18:23 +01005417 if (!hlua)
5418 return 0;
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005419
5420 /* Remove previous value. */
Thierry FOURNIERe068b602017-04-26 13:27:05 +02005421 luaL_unref(L, LUA_REGISTRYINDEX, hlua->Mref);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005422
5423 /* Get and store new value. */
5424 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
5425 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
5426
5427 return 0;
5428}
5429
Willy Tarreau59551662015-03-10 14:23:13 +01005430__LJMP static int hlua_get_priv(lua_State *L)
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005431{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005432 struct hlua *hlua;
5433
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005434 MAY_LJMP(check_args(L, 1, "get_priv"));
5435
Willy Tarreau87b09662015-04-03 00:22:06 +02005436 /* It is useles to retrieve the stream, but this function
5437 * runs only in a stream context.
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005438 */
5439 MAY_LJMP(hlua_checktxn(L, 1));
Thierry Fournier4234dbd2020-11-28 13:18:23 +01005440
5441 /* Get hlua struct, or NULL if we execute from main lua state */
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005442 hlua = hlua_gethlua(L);
Thierry Fournier4234dbd2020-11-28 13:18:23 +01005443 if (!hlua) {
5444 lua_pushnil(L);
5445 return 1;
5446 }
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005447
5448 /* Push configuration index in the stack. */
5449 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
5450
5451 return 1;
5452}
5453
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005454/* Create stack entry containing a class TXN. This function
5455 * return 0 if the stack does not contains free slots,
5456 * otherwise it returns 1.
5457 */
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005458static int hlua_txn_new(lua_State *L, struct stream *s, struct proxy *p, int dir, int flags)
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005459{
Willy Tarreaude491382015-04-06 11:04:28 +02005460 struct hlua_txn *htxn;
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005461
5462 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01005463 if (!lua_checkstack(L, 3))
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005464 return 0;
5465
5466 /* NOTE: The allocation never fails. The failure
5467 * throw an error, and the function never returns.
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08005468 * if the throw is not available, the process is aborted.
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005469 */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01005470 /* Create the object: obj[0] = userdata. */
5471 lua_newtable(L);
Willy Tarreaude491382015-04-06 11:04:28 +02005472 htxn = lua_newuserdata(L, sizeof(*htxn));
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01005473 lua_rawseti(L, -2, 0);
5474
Willy Tarreaude491382015-04-06 11:04:28 +02005475 htxn->s = s;
5476 htxn->p = p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01005477 htxn->dir = dir;
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005478 htxn->flags = flags;
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005479
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01005480 /* Create the "f" field that contains a list of fetches. */
5481 lua_pushstring(L, "f");
Thierry FOURNIERca988662015-12-20 18:43:03 +01005482 if (!hlua_fetches_new(L, htxn, HLUA_F_MAY_USE_HTTP))
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01005483 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005484 lua_rawset(L, -3);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01005485
5486 /* Create the "sf" field that contains a list of stringsafe fetches. */
5487 lua_pushstring(L, "sf");
Thierry FOURNIERca988662015-12-20 18:43:03 +01005488 if (!hlua_fetches_new(L, htxn, HLUA_F_MAY_USE_HTTP | HLUA_F_AS_STRING))
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01005489 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005490 lua_rawset(L, -3);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01005491
Thierry FOURNIER594afe72015-03-10 23:58:30 +01005492 /* Create the "c" field that contains a list of converters. */
5493 lua_pushstring(L, "c");
Willy Tarreaude491382015-04-06 11:04:28 +02005494 if (!hlua_converters_new(L, htxn, 0))
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01005495 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005496 lua_rawset(L, -3);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01005497
5498 /* Create the "sc" field that contains a list of stringsafe converters. */
5499 lua_pushstring(L, "sc");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01005500 if (!hlua_converters_new(L, htxn, HLUA_F_AS_STRING))
Thierry FOURNIER594afe72015-03-10 23:58:30 +01005501 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005502 lua_rawset(L, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01005503
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005504 /* Create the "req" field that contains the request channel object. */
5505 lua_pushstring(L, "req");
Willy Tarreau2a71af42015-03-10 13:51:50 +01005506 if (!hlua_channel_new(L, &s->req))
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005507 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005508 lua_rawset(L, -3);
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005509
5510 /* Create the "res" field that contains the response channel object. */
5511 lua_pushstring(L, "res");
Willy Tarreau2a71af42015-03-10 13:51:50 +01005512 if (!hlua_channel_new(L, &s->res))
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005513 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005514 lua_rawset(L, -3);
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005515
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005516 /* Creates the HTTP object is the current proxy allows http. */
5517 lua_pushstring(L, "http");
Christopher Faulet1bb6afa2021-03-08 17:57:53 +01005518 if (IS_HTX_STRM(s)) {
Willy Tarreaude491382015-04-06 11:04:28 +02005519 if (!hlua_http_new(L, htxn))
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005520 return 0;
5521 }
5522 else
5523 lua_pushnil(L);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005524 lua_rawset(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005525
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005526 /* Pop a class sesison metatable and affect it to the userdata. */
5527 lua_rawgeti(L, LUA_REGISTRYINDEX, class_txn_ref);
5528 lua_setmetatable(L, -2);
5529
5530 return 1;
5531}
5532
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01005533__LJMP static int hlua_txn_deflog(lua_State *L)
5534{
5535 const char *msg;
5536 struct hlua_txn *htxn;
5537
5538 MAY_LJMP(check_args(L, 2, "deflog"));
5539 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5540 msg = MAY_LJMP(luaL_checkstring(L, 2));
5541
5542 hlua_sendlog(htxn->s->be, htxn->s->logs.level, msg);
5543 return 0;
5544}
5545
5546__LJMP static int hlua_txn_log(lua_State *L)
5547{
5548 int level;
5549 const char *msg;
5550 struct hlua_txn *htxn;
5551
5552 MAY_LJMP(check_args(L, 3, "log"));
5553 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5554 level = MAY_LJMP(luaL_checkinteger(L, 2));
5555 msg = MAY_LJMP(luaL_checkstring(L, 3));
5556
5557 if (level < 0 || level >= NB_LOG_LEVELS)
5558 WILL_LJMP(luaL_argerror(L, 1, "Invalid loglevel."));
5559
5560 hlua_sendlog(htxn->s->be, level, msg);
5561 return 0;
5562}
5563
5564__LJMP static int hlua_txn_log_debug(lua_State *L)
5565{
5566 const char *msg;
5567 struct hlua_txn *htxn;
5568
5569 MAY_LJMP(check_args(L, 2, "Debug"));
5570 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5571 msg = MAY_LJMP(luaL_checkstring(L, 2));
5572 hlua_sendlog(htxn->s->be, LOG_DEBUG, msg);
5573 return 0;
5574}
5575
5576__LJMP static int hlua_txn_log_info(lua_State *L)
5577{
5578 const char *msg;
5579 struct hlua_txn *htxn;
5580
5581 MAY_LJMP(check_args(L, 2, "Info"));
5582 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5583 msg = MAY_LJMP(luaL_checkstring(L, 2));
5584 hlua_sendlog(htxn->s->be, LOG_INFO, msg);
5585 return 0;
5586}
5587
5588__LJMP static int hlua_txn_log_warning(lua_State *L)
5589{
5590 const char *msg;
5591 struct hlua_txn *htxn;
5592
5593 MAY_LJMP(check_args(L, 2, "Warning"));
5594 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5595 msg = MAY_LJMP(luaL_checkstring(L, 2));
5596 hlua_sendlog(htxn->s->be, LOG_WARNING, msg);
5597 return 0;
5598}
5599
5600__LJMP static int hlua_txn_log_alert(lua_State *L)
5601{
5602 const char *msg;
5603 struct hlua_txn *htxn;
5604
5605 MAY_LJMP(check_args(L, 2, "Alert"));
5606 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5607 msg = MAY_LJMP(luaL_checkstring(L, 2));
5608 hlua_sendlog(htxn->s->be, LOG_ALERT, msg);
5609 return 0;
5610}
5611
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005612__LJMP static int hlua_txn_set_loglevel(lua_State *L)
5613{
5614 struct hlua_txn *htxn;
5615 int ll;
5616
5617 MAY_LJMP(check_args(L, 2, "set_loglevel"));
5618 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5619 ll = MAY_LJMP(luaL_checkinteger(L, 2));
5620
5621 if (ll < 0 || ll > 7)
5622 WILL_LJMP(luaL_argerror(L, 2, "Bad log level. It must be between 0 and 7"));
5623
5624 htxn->s->logs.level = ll;
5625 return 0;
5626}
5627
5628__LJMP static int hlua_txn_set_tos(lua_State *L)
5629{
5630 struct hlua_txn *htxn;
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005631 int tos;
5632
5633 MAY_LJMP(check_args(L, 2, "set_tos"));
5634 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5635 tos = MAY_LJMP(luaL_checkinteger(L, 2));
5636
Willy Tarreau1a18b542018-12-11 16:37:42 +01005637 conn_set_tos(objt_conn(htxn->s->sess->origin), tos);
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005638 return 0;
5639}
5640
5641__LJMP static int hlua_txn_set_mark(lua_State *L)
5642{
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005643 struct hlua_txn *htxn;
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005644 int mark;
5645
5646 MAY_LJMP(check_args(L, 2, "set_mark"));
5647 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5648 mark = MAY_LJMP(luaL_checkinteger(L, 2));
5649
Lukas Tribus579e3e32019-08-11 18:03:45 +02005650 conn_set_mark(objt_conn(htxn->s->sess->origin), mark);
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005651 return 0;
5652}
5653
Patrick Hemmer268a7072018-05-11 12:52:31 -04005654__LJMP static int hlua_txn_set_priority_class(lua_State *L)
5655{
5656 struct hlua_txn *htxn;
5657
5658 MAY_LJMP(check_args(L, 2, "set_priority_class"));
5659 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5660 htxn->s->priority_class = queue_limit_class(MAY_LJMP(luaL_checkinteger(L, 2)));
5661 return 0;
5662}
5663
5664__LJMP static int hlua_txn_set_priority_offset(lua_State *L)
5665{
5666 struct hlua_txn *htxn;
5667
5668 MAY_LJMP(check_args(L, 2, "set_priority_offset"));
5669 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5670 htxn->s->priority_offset = queue_limit_offset(MAY_LJMP(luaL_checkinteger(L, 2)));
5671 return 0;
5672}
5673
Christopher Faulet700d9e82020-01-31 12:21:52 +01005674/* Forward the Reply object to the client. This function converts the reply in
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05005675 * HTX an push it to into the response channel. It is response to forward the
Christopher Faulet700d9e82020-01-31 12:21:52 +01005676 * message and terminate the transaction. It returns 1 on success and 0 on
5677 * error. The Reply must be on top of the stack.
5678 */
5679__LJMP static int hlua_txn_forward_reply(lua_State *L, struct stream *s)
5680{
5681 struct htx *htx;
5682 struct htx_sl *sl;
5683 struct h1m h1m;
5684 const char *status, *reason, *body;
5685 size_t status_len, reason_len, body_len;
5686 int ret, code, flags;
5687
5688 code = 200;
5689 status = "200";
5690 status_len = 3;
5691 ret = lua_getfield(L, -1, "status");
5692 if (ret == LUA_TNUMBER) {
5693 code = lua_tointeger(L, -1);
5694 status = lua_tolstring(L, -1, &status_len);
5695 }
5696 lua_pop(L, 1);
5697
5698 reason = http_get_reason(code);
5699 reason_len = strlen(reason);
5700 ret = lua_getfield(L, -1, "reason");
5701 if (ret == LUA_TSTRING)
5702 reason = lua_tolstring(L, -1, &reason_len);
5703 lua_pop(L, 1);
5704
5705 body = NULL;
5706 body_len = 0;
5707 ret = lua_getfield(L, -1, "body");
5708 if (ret == LUA_TSTRING)
5709 body = lua_tolstring(L, -1, &body_len);
5710 lua_pop(L, 1);
5711
5712 /* Prepare the response before inserting the headers */
5713 h1m_init_res(&h1m);
5714 htx = htx_from_buf(&s->res.buf);
5715 channel_htx_truncate(&s->res, htx);
5716 if (s->txn->req.flags & HTTP_MSGF_VER_11) {
5717 flags = (HTX_SL_F_IS_RESP|HTX_SL_F_VER_11);
5718 sl = htx_add_stline(htx, HTX_BLK_RES_SL, flags, ist("HTTP/1.1"),
5719 ist2(status, status_len), ist2(reason, reason_len));
5720 }
5721 else {
5722 flags = HTX_SL_F_IS_RESP;
5723 sl = htx_add_stline(htx, HTX_BLK_RES_SL, flags, ist("HTTP/1.0"),
5724 ist2(status, status_len), ist2(reason, reason_len));
5725 }
5726 if (!sl)
5727 goto fail;
5728 sl->info.res.status = code;
5729
5730 /* Push in the stack the "headers" entry. */
5731 ret = lua_getfield(L, -1, "headers");
5732 if (ret != LUA_TTABLE)
5733 goto skip_headers;
5734
5735 lua_pushnil(L);
5736 while (lua_next(L, -2) != 0) {
5737 struct ist name, value;
5738 const char *n, *v;
5739 size_t nlen, vlen;
5740
5741 if (!lua_isstring(L, -2) || !lua_istable(L, -1)) {
5742 /* Skip element if the key is not a string or if the value is not a table */
5743 goto next_hdr;
5744 }
5745
5746 n = lua_tolstring(L, -2, &nlen);
5747 name = ist2(n, nlen);
5748 if (isteqi(name, ist("content-length"))) {
5749 /* Always skip content-length header. It will be added
5750 * later with the correct len
5751 */
5752 goto next_hdr;
5753 }
5754
5755 /* Loop on header's values */
5756 lua_pushnil(L);
5757 while (lua_next(L, -2)) {
5758 if (!lua_isstring(L, -1)) {
5759 /* Skip the value if it is not a string */
5760 goto next_value;
5761 }
5762
5763 v = lua_tolstring(L, -1, &vlen);
5764 value = ist2(v, vlen);
5765
5766 if (isteqi(name, ist("transfer-encoding")))
5767 h1_parse_xfer_enc_header(&h1m, value);
5768 if (!htx_add_header(htx, ist2(n, nlen), ist2(v, vlen)))
5769 goto fail;
5770
5771 next_value:
5772 lua_pop(L, 1);
5773 }
5774
5775 next_hdr:
5776 lua_pop(L, 1);
5777 }
5778 skip_headers:
5779 lua_pop(L, 1);
5780
5781 /* Update h1m flags: CLEN is set if CHNK is not present */
5782 if (!(h1m.flags & H1_MF_CHNK)) {
5783 const char *clen = ultoa(body_len);
5784
5785 h1m.flags |= H1_MF_CLEN;
5786 if (!htx_add_header(htx, ist("content-length"), ist(clen)))
5787 goto fail;
5788 }
5789 if (h1m.flags & (H1_MF_CLEN|H1_MF_CHNK))
5790 h1m.flags |= H1_MF_XFER_LEN;
5791
5792 /* Update HTX start-line flags */
5793 if (h1m.flags & H1_MF_XFER_ENC)
5794 flags |= HTX_SL_F_XFER_ENC;
5795 if (h1m.flags & H1_MF_XFER_LEN) {
5796 flags |= HTX_SL_F_XFER_LEN;
5797 if (h1m.flags & H1_MF_CHNK)
5798 flags |= HTX_SL_F_CHNK;
5799 else if (h1m.flags & H1_MF_CLEN)
5800 flags |= HTX_SL_F_CLEN;
5801 if (h1m.body_len == 0)
5802 flags |= HTX_SL_F_BODYLESS;
5803 }
5804 sl->flags |= flags;
5805
5806
5807 if (!htx_add_endof(htx, HTX_BLK_EOH) ||
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01005808 (body_len && !htx_add_data_atonce(htx, ist2(body, body_len))))
Christopher Faulet700d9e82020-01-31 12:21:52 +01005809 goto fail;
5810
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01005811 htx->flags |= HTX_FL_EOM;
5812
Christopher Faulet700d9e82020-01-31 12:21:52 +01005813 /* Now, forward the response and terminate the transaction */
5814 s->txn->status = code;
5815 htx_to_buf(htx, &s->res.buf);
5816 if (!http_forward_proxy_resp(s, 1))
5817 goto fail;
5818
5819 return 1;
5820
5821 fail:
5822 channel_htx_truncate(&s->res, htx);
5823 return 0;
5824}
5825
5826/* Terminate a transaction if called from a lua action. For TCP streams,
5827 * processing is just aborted. Nothing is returned to the client and all
5828 * arguments are ignored. For HTTP streams, if a reply is passed as argument, it
5829 * is forwarded to the client before terminating the transaction. On success,
5830 * the function exits with ACT_RET_DONE code. If an error occurred, it exits
5831 * with ACT_RET_ERR code. If this function is not called from a lua action, it
5832 * just exits without any processing.
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005833 */
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02005834__LJMP static int hlua_txn_done(lua_State *L)
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005835{
Willy Tarreaub2ccb562015-04-06 11:11:15 +02005836 struct hlua_txn *htxn;
Christopher Faulet700d9e82020-01-31 12:21:52 +01005837 struct stream *s;
5838 int finst;
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005839
Willy Tarreaub2ccb562015-04-06 11:11:15 +02005840 htxn = MAY_LJMP(hlua_checktxn(L, 1));
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005841
Christopher Faulet700d9e82020-01-31 12:21:52 +01005842 /* If the flags NOTERM is set, we cannot terminate the session, so we
5843 * just end the execution of the current lua code. */
5844 if (htxn->flags & HLUA_TXN_NOTERM)
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005845 WILL_LJMP(hlua_done(L));
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005846
Christopher Faulet700d9e82020-01-31 12:21:52 +01005847 s = htxn->s;
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005848 if (!IS_HTX_STRM(htxn->s)) {
Christopher Faulet700d9e82020-01-31 12:21:52 +01005849 struct channel *req = &s->req;
5850 struct channel *res = &s->res;
Willy Tarreau81389672015-03-10 12:03:52 +01005851
Christopher Faulet700d9e82020-01-31 12:21:52 +01005852 channel_auto_read(req);
5853 channel_abort(req);
5854 channel_auto_close(req);
5855 channel_erase(req);
5856
5857 res->wex = tick_add_ifset(now_ms, res->wto);
5858 channel_auto_read(res);
5859 channel_auto_close(res);
5860 channel_shutr_now(res);
5861
5862 finst = ((htxn->dir == SMP_OPT_DIR_REQ) ? SF_FINST_R : SF_FINST_D);
5863 goto done;
Christopher Fauletfe6a71b2019-07-26 16:40:24 +02005864 }
Thierry FOURNIER10ec2142015-08-24 17:23:45 +02005865
Christopher Faulet700d9e82020-01-31 12:21:52 +01005866 if (lua_gettop(L) == 1 || !lua_istable(L, 2)) {
5867 /* No reply or invalid reply */
5868 s->txn->status = 0;
5869 http_reply_and_close(s, 0, NULL);
5870 }
5871 else {
5872 /* Remove extra args to have the reply on top of the stack */
5873 if (lua_gettop(L) > 2)
5874 lua_pop(L, lua_gettop(L) - 2);
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005875
Christopher Faulet700d9e82020-01-31 12:21:52 +01005876 if (!hlua_txn_forward_reply(L, s)) {
5877 if (!(s->flags & SF_ERR_MASK))
5878 s->flags |= SF_ERR_PRXCOND;
5879 lua_pushinteger(L, ACT_RET_ERR);
5880 WILL_LJMP(hlua_done(L));
5881 return 0; /* Never reached */
5882 }
Christopher Faulet4d0e2632019-07-16 10:52:40 +02005883 }
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02005884
Christopher Faulet700d9e82020-01-31 12:21:52 +01005885 finst = ((htxn->dir == SMP_OPT_DIR_REQ) ? SF_FINST_R : SF_FINST_H);
5886 if (htxn->dir == SMP_OPT_DIR_REQ) {
5887 /* let's log the request time */
5888 s->logs.tv_request = now;
5889 if (s->sess->fe == s->be) /* report it if the request was intercepted by the frontend */
Willy Tarreau4781b152021-04-06 13:53:36 +02005890 _HA_ATOMIC_INC(&s->sess->fe->fe_counters.intercepted_req);
Christopher Faulet700d9e82020-01-31 12:21:52 +01005891 }
Christopher Fauletfe6a71b2019-07-26 16:40:24 +02005892
Christopher Faulet700d9e82020-01-31 12:21:52 +01005893 done:
5894 if (!(s->flags & SF_ERR_MASK))
5895 s->flags |= SF_ERR_LOCAL;
5896 if (!(s->flags & SF_FINST_MASK))
5897 s->flags |= finst;
Christopher Fauletfe6a71b2019-07-26 16:40:24 +02005898
Christopher Faulet4ad73102020-03-05 11:07:31 +01005899 lua_pushinteger(L, ACT_RET_ABRT);
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02005900 WILL_LJMP(hlua_done(L));
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01005901 return 0;
5902}
5903
Christopher Faulet700d9e82020-01-31 12:21:52 +01005904/*
5905 *
5906 *
5907 * Class REPLY
5908 *
5909 *
5910 */
5911
5912/* Pushes the TXN reply onto the top of the stack. If the stask does not have a
5913 * free slots, the function fails and returns 0;
5914 */
5915static int hlua_txn_reply_new(lua_State *L)
5916{
5917 struct hlua_txn *htxn;
5918 const char *reason, *body = NULL;
5919 int ret, status;
5920
5921 htxn = MAY_LJMP(hlua_checktxn(L, 1));
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005922 if (!IS_HTX_STRM(htxn->s)) {
Christopher Faulet700d9e82020-01-31 12:21:52 +01005923 hlua_pusherror(L, "txn object is not an HTTP transaction.");
5924 WILL_LJMP(lua_error(L));
5925 }
5926
5927 /* Default value */
5928 status = 200;
5929 reason = http_get_reason(status);
5930
5931 if (lua_istable(L, 2)) {
5932 /* load status and reason from the table argument at index 2 */
5933 ret = lua_getfield(L, 2, "status");
5934 if (ret == LUA_TNIL)
5935 goto reason;
5936 else if (ret != LUA_TNUMBER) {
5937 /* invalid status: ignore the reason */
5938 goto body;
5939 }
5940 status = lua_tointeger(L, -1);
5941
5942 reason:
5943 lua_pop(L, 1); /* restore the stack: remove status */
5944 ret = lua_getfield(L, 2, "reason");
5945 if (ret == LUA_TSTRING)
5946 reason = lua_tostring(L, -1);
5947
5948 body:
5949 lua_pop(L, 1); /* restore the stack: remove invalid status or reason */
5950 ret = lua_getfield(L, 2, "body");
5951 if (ret == LUA_TSTRING)
5952 body = lua_tostring(L, -1);
5953 lua_pop(L, 1); /* restore the stack: remove body */
5954 }
5955
5956 /* Create the Reply table */
5957 lua_newtable(L);
5958
5959 /* Add status element */
5960 lua_pushstring(L, "status");
5961 lua_pushinteger(L, status);
5962 lua_settable(L, -3);
5963
5964 /* Add reason element */
5965 reason = http_get_reason(status);
5966 lua_pushstring(L, "reason");
5967 lua_pushstring(L, reason);
5968 lua_settable(L, -3);
5969
5970 /* Add body element, nil if undefined */
5971 lua_pushstring(L, "body");
5972 if (body)
5973 lua_pushstring(L, body);
5974 else
5975 lua_pushnil(L);
5976 lua_settable(L, -3);
5977
5978 /* Add headers element */
5979 lua_pushstring(L, "headers");
5980 lua_newtable(L);
5981
5982 /* stack: [ txn, <Arg:table>, <Reply:table>, "headers", <headers:table> ] */
5983 if (lua_istable(L, 2)) {
5984 /* load headers from the table argument at index 2. If it is a table, copy it. */
5985 ret = lua_getfield(L, 2, "headers");
5986 if (ret == LUA_TTABLE) {
5987 /* stack: [ ... <headers:table>, <table> ] */
5988 lua_pushnil(L);
5989 while (lua_next(L, -2) != 0) {
5990 /* stack: [ ... <headers:table>, <table>, k, v] */
5991 if (!lua_isstring(L, -1) && !lua_istable(L, -1)) {
5992 /* invalid value type, skip it */
5993 lua_pop(L, 1);
5994 continue;
5995 }
5996
5997
5998 /* Duplicate the key and swap it with the value. */
5999 lua_pushvalue(L, -2);
6000 lua_insert(L, -2);
6001 /* stack: [ ... <headers:table>, <table>, k, k, v ] */
6002
6003 lua_newtable(L);
6004 lua_insert(L, -2);
6005 /* stack: [ ... <headers:table>, <table>, k, k, <inner:table>, v ] */
6006
6007 if (lua_isstring(L, -1)) {
6008 /* push the value in the inner table */
6009 lua_rawseti(L, -2, 1);
6010 }
6011 else { /* table */
6012 lua_pushnil(L);
6013 while (lua_next(L, -2) != 0) {
6014 /* stack: [ ... <headers:table>, <table>, k, k, <inner:table>, <v:table>, k2, v2 ] */
6015 if (!lua_isstring(L, -1)) {
6016 /* invalid value type, skip it*/
6017 lua_pop(L, 1);
6018 continue;
6019 }
6020 /* push the value in the inner table */
6021 lua_rawseti(L, -4, lua_rawlen(L, -4) + 1);
6022 /* stack: [ ... <headers:table>, <table>, k, k, <inner:table>, <v:table>, k2 ] */
6023 }
6024 lua_pop(L, 1);
6025 /* stack: [ ... <headers:table>, <table>, k, k, <inner:table> ] */
6026 }
6027
6028 /* push (k,v) on the stack in the headers table:
6029 * stack: [ ... <headers:table>, <table>, k, k, v ]
6030 */
6031 lua_settable(L, -5);
6032 /* stack: [ ... <headers:table>, <table>, k ] */
6033 }
6034 }
6035 lua_pop(L, 1);
6036 }
6037 /* stack: [ txn, <Arg:table>, <Reply:table>, "headers", <headers:table> ] */
6038 lua_settable(L, -3);
6039 /* stack: [ txn, <Arg:table>, <Reply:table> ] */
6040
6041 /* Pop a class sesison metatable and affect it to the userdata. */
6042 lua_rawgeti(L, LUA_REGISTRYINDEX, class_txn_reply_ref);
6043 lua_setmetatable(L, -2);
6044 return 1;
6045}
6046
6047/* Set the reply status code, and optionally the reason. If no reason is
6048 * provided, the default one corresponding to the status code is used.
6049 */
6050__LJMP static int hlua_txn_reply_set_status(lua_State *L)
6051{
6052 int status = MAY_LJMP(luaL_checkinteger(L, 2));
6053 const char *reason = MAY_LJMP(luaL_optlstring(L, 3, NULL, NULL));
6054
6055 /* First argument (self) must be a table */
6056 luaL_checktype(L, 1, LUA_TTABLE);
6057
6058 if (status < 100 || status > 599) {
6059 lua_pushboolean(L, 0);
6060 return 1;
6061 }
6062 if (!reason)
6063 reason = http_get_reason(status);
6064
6065 lua_pushinteger(L, status);
6066 lua_setfield(L, 1, "status");
6067
6068 lua_pushstring(L, reason);
6069 lua_setfield(L, 1, "reason");
6070
6071 lua_pushboolean(L, 1);
6072 return 1;
6073}
6074
6075/* Add a header into the reply object. Each header name is associated to an
6076 * array of values in the "headers" table. If the header name is not found, a
6077 * new entry is created.
6078 */
6079__LJMP static int hlua_txn_reply_add_header(lua_State *L)
6080{
6081 const char *name = MAY_LJMP(luaL_checkstring(L, 2));
6082 const char *value = MAY_LJMP(luaL_checkstring(L, 3));
6083 int ret;
6084
6085 /* First argument (self) must be a table */
6086 luaL_checktype(L, 1, LUA_TTABLE);
6087
6088 /* Push in the stack the "headers" entry. */
6089 ret = lua_getfield(L, 1, "headers");
6090 if (ret != LUA_TTABLE) {
6091 hlua_pusherror(L, "Reply['headers'] is expected to a an array. %s found", lua_typename(L, ret));
6092 WILL_LJMP(lua_error(L));
6093 }
6094
6095 /* check if the header is already registered. If not, register it. */
6096 ret = lua_getfield(L, -1, name);
6097 if (ret == LUA_TNIL) {
6098 /* Entry not found. */
6099 lua_pop(L, 1); /* remove the nil. The "headers" table is the top of the stack. */
6100
6101 /* Insert the new header name in the array in the top of the stack.
6102 * It left the new array in the top of the stack.
6103 */
6104 lua_newtable(L);
6105 lua_pushstring(L, name);
6106 lua_pushvalue(L, -2);
6107 lua_settable(L, -4);
6108 }
6109 else if (ret != LUA_TTABLE) {
6110 hlua_pusherror(L, "Reply['headers']['%s'] is expected to be an array. %s found", name, lua_typename(L, ret));
6111 WILL_LJMP(lua_error(L));
6112 }
6113
Thayne McCombs8f0cc5c2021-01-07 21:35:52 -07006114 /* Now the top of thestack is an array of values. We push
Christopher Faulet700d9e82020-01-31 12:21:52 +01006115 * the header value as new entry.
6116 */
6117 lua_pushstring(L, value);
6118 ret = lua_rawlen(L, -2);
6119 lua_rawseti(L, -2, ret + 1);
6120
6121 lua_pushboolean(L, 1);
6122 return 1;
6123}
6124
6125/* Remove all occurrences of a given header name. */
6126__LJMP static int hlua_txn_reply_del_header(lua_State *L)
6127{
6128 const char *name = MAY_LJMP(luaL_checkstring(L, 2));
6129 int ret;
6130
6131 /* First argument (self) must be a table */
6132 luaL_checktype(L, 1, LUA_TTABLE);
6133
6134 /* Push in the stack the "headers" entry. */
6135 ret = lua_getfield(L, 1, "headers");
6136 if (ret != LUA_TTABLE) {
6137 hlua_pusherror(L, "Reply['headers'] is expected to be an array. %s found", lua_typename(L, ret));
6138 WILL_LJMP(lua_error(L));
6139 }
6140
6141 lua_pushstring(L, name);
6142 lua_pushnil(L);
6143 lua_settable(L, -3);
6144
6145 lua_pushboolean(L, 1);
6146 return 1;
6147}
6148
6149/* Set the reply's body. Overwrite any existing entry. */
6150__LJMP static int hlua_txn_reply_set_body(lua_State *L)
6151{
6152 const char *payload = MAY_LJMP(luaL_checkstring(L, 2));
6153
6154 /* First argument (self) must be a table */
6155 luaL_checktype(L, 1, LUA_TTABLE);
6156
6157 lua_pushstring(L, payload);
6158 lua_setfield(L, 1, "body");
6159
6160 lua_pushboolean(L, 1);
6161 return 1;
6162}
6163
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01006164__LJMP static int hlua_log(lua_State *L)
6165{
6166 int level;
6167 const char *msg;
6168
6169 MAY_LJMP(check_args(L, 2, "log"));
6170 level = MAY_LJMP(luaL_checkinteger(L, 1));
6171 msg = MAY_LJMP(luaL_checkstring(L, 2));
6172
6173 if (level < 0 || level >= NB_LOG_LEVELS)
6174 WILL_LJMP(luaL_argerror(L, 1, "Invalid loglevel."));
6175
6176 hlua_sendlog(NULL, level, msg);
6177 return 0;
6178}
6179
6180__LJMP static int hlua_log_debug(lua_State *L)
6181{
6182 const char *msg;
6183
6184 MAY_LJMP(check_args(L, 1, "debug"));
6185 msg = MAY_LJMP(luaL_checkstring(L, 1));
6186 hlua_sendlog(NULL, LOG_DEBUG, msg);
6187 return 0;
6188}
6189
6190__LJMP static int hlua_log_info(lua_State *L)
6191{
6192 const char *msg;
6193
6194 MAY_LJMP(check_args(L, 1, "info"));
6195 msg = MAY_LJMP(luaL_checkstring(L, 1));
6196 hlua_sendlog(NULL, LOG_INFO, msg);
6197 return 0;
6198}
6199
6200__LJMP static int hlua_log_warning(lua_State *L)
6201{
6202 const char *msg;
6203
6204 MAY_LJMP(check_args(L, 1, "warning"));
6205 msg = MAY_LJMP(luaL_checkstring(L, 1));
6206 hlua_sendlog(NULL, LOG_WARNING, msg);
6207 return 0;
6208}
6209
6210__LJMP static int hlua_log_alert(lua_State *L)
6211{
6212 const char *msg;
6213
6214 MAY_LJMP(check_args(L, 1, "alert"));
6215 msg = MAY_LJMP(luaL_checkstring(L, 1));
6216 hlua_sendlog(NULL, LOG_ALERT, msg);
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01006217 return 0;
6218}
6219
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01006220__LJMP static int hlua_sleep_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006221{
6222 int wakeup_ms = lua_tointeger(L, -1);
Willy Tarreau9cc2e4c2021-09-30 16:12:31 +02006223 if (!tick_is_expired(wakeup_ms, now_ms))
Willy Tarreau9635e032018-10-16 17:52:55 +02006224 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006225 return 0;
6226}
6227
6228__LJMP static int hlua_sleep(lua_State *L)
6229{
6230 unsigned int delay;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006231 unsigned int wakeup_ms;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006232
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006233 MAY_LJMP(check_args(L, 1, "sleep"));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006234
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01006235 delay = MAY_LJMP(luaL_checkinteger(L, 1)) * 1000;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006236 wakeup_ms = tick_add(now_ms, delay);
6237 lua_pushinteger(L, wakeup_ms);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006238
Willy Tarreau9635e032018-10-16 17:52:55 +02006239 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006240 return 0;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006241}
6242
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006243__LJMP static int hlua_msleep(lua_State *L)
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006244{
6245 unsigned int delay;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006246 unsigned int wakeup_ms;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006247
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006248 MAY_LJMP(check_args(L, 1, "msleep"));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006249
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01006250 delay = MAY_LJMP(luaL_checkinteger(L, 1));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006251 wakeup_ms = tick_add(now_ms, delay);
6252 lua_pushinteger(L, wakeup_ms);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006253
Willy Tarreau9635e032018-10-16 17:52:55 +02006254 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006255 return 0;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006256}
6257
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01006258/* This functionis an LUA binding. it permits to give back
6259 * the hand at the HAProxy scheduler. It is used when the
6260 * LUA processing consumes a lot of time.
6261 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01006262__LJMP static int hlua_yield_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006263{
6264 return 0;
6265}
6266
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01006267__LJMP static int hlua_yield(lua_State *L)
6268{
Willy Tarreau9635e032018-10-16 17:52:55 +02006269 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_yield_yield, TICK_ETERNITY, HLUA_CTRLYIELD));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006270 return 0;
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01006271}
6272
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006273/* This function change the nice of the currently executed
6274 * task. It is used set low or high priority at the current
6275 * task.
6276 */
Willy Tarreau59551662015-03-10 14:23:13 +01006277__LJMP static int hlua_set_nice(lua_State *L)
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006278{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006279 struct hlua *hlua;
6280 int nice;
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006281
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006282 MAY_LJMP(check_args(L, 1, "set_nice"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006283 nice = MAY_LJMP(luaL_checkinteger(L, 1));
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006284
Thierry Fournier4234dbd2020-11-28 13:18:23 +01006285 /* Get hlua struct, or NULL if we execute from main lua state */
6286 hlua = hlua_gethlua(L);
6287
6288 /* If the task is not set, I'm in a start mode. */
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006289 if (!hlua || !hlua->task)
6290 return 0;
6291
6292 if (nice < -1024)
6293 nice = -1024;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006294 else if (nice > 1024)
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006295 nice = 1024;
6296
6297 hlua->task->nice = nice;
6298 return 0;
6299}
6300
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08006301/* This function is used as a callback of a task. It is called by the
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006302 * HAProxy task subsystem when the task is awaked. The LUA runtime can
6303 * return an E_AGAIN signal, the emmiter of this signal must set a
6304 * signal to wake the task.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006305 *
6306 * Task wrapper are longjmp safe because the only one Lua code
6307 * executed is the safe hlua_ctx_resume();
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006308 */
Willy Tarreau144f84a2021-03-02 16:09:26 +01006309struct task *hlua_process_task(struct task *task, void *context, unsigned int state)
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006310{
Olivier Houchard9f6af332018-05-25 14:04:04 +02006311 struct hlua *hlua = context;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006312 enum hlua_exec status;
6313
Christopher Faulet5bc99722018-04-25 10:34:45 +02006314 if (task->thread_mask == MAX_THREADS_MASK)
6315 task_set_affinity(task, tid_bit);
6316
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006317 /* If it is the first call to the task, we must initialize the
6318 * execution timeouts.
6319 */
6320 if (!HLUA_IS_RUNNING(hlua))
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02006321 hlua->max_time = hlua_timeout_task;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006322
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006323 /* Execute the Lua code. */
6324 status = hlua_ctx_resume(hlua, 1);
6325
6326 switch (status) {
6327 /* finished or yield */
6328 case HLUA_E_OK:
6329 hlua_ctx_destroy(hlua);
Olivier Houchard3f795f72019-04-17 22:51:06 +02006330 task_destroy(task);
Tim Duesterhuscd235c62018-04-24 13:56:01 +02006331 task = NULL;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006332 break;
6333
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01006334 case HLUA_E_AGAIN: /* co process or timeout wake me later. */
Thierry FOURNIERcb146882017-12-10 17:10:57 +01006335 notification_gc(&hlua->com);
PiBa-NLfe971b32018-05-02 22:27:14 +02006336 task->expire = hlua->wake_time;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006337 break;
6338
6339 /* finished with error. */
6340 case HLUA_E_ERRMSG:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006341 SEND_ERR(NULL, "Lua task: %s.\n", lua_tostring(hlua->T, -1));
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006342 hlua_ctx_destroy(hlua);
Olivier Houchard3f795f72019-04-17 22:51:06 +02006343 task_destroy(task);
Emeric Brun253e53e2017-10-17 18:58:40 +02006344 task = NULL;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006345 break;
6346
6347 case HLUA_E_ERR:
6348 default:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006349 SEND_ERR(NULL, "Lua task: unknown error.\n");
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006350 hlua_ctx_destroy(hlua);
Olivier Houchard3f795f72019-04-17 22:51:06 +02006351 task_destroy(task);
Emeric Brun253e53e2017-10-17 18:58:40 +02006352 task = NULL;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006353 break;
6354 }
Emeric Brun253e53e2017-10-17 18:58:40 +02006355 return task;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006356}
6357
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006358/* This function is an LUA binding that register LUA function to be
6359 * executed after the HAProxy configuration parsing and before the
6360 * HAProxy scheduler starts. This function expect only one LUA
6361 * argument that is a function. This function returns nothing, but
6362 * throws if an error is encountered.
6363 */
6364__LJMP static int hlua_register_init(lua_State *L)
6365{
6366 struct hlua_init_function *init;
6367 int ref;
6368
6369 MAY_LJMP(check_args(L, 1, "register_init"));
6370
6371 ref = MAY_LJMP(hlua_checkfunction(L, 1));
6372
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006373 init = calloc(1, sizeof(*init));
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006374 if (!init)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006375 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006376
6377 init->function_ref = ref;
Willy Tarreau2b718102021-04-21 07:32:39 +02006378 LIST_APPEND(&hlua_init_functions[hlua_state_id], &init->l);
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006379 return 0;
6380}
6381
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006382/* This functio is an LUA binding. It permits to register a task
6383 * executed in parallel of the main HAroxy activity. The task is
6384 * created and it is set in the HAProxy scheduler. It can be called
6385 * from the "init" section, "post init" or during the runtime.
6386 *
6387 * Lua prototype:
6388 *
6389 * <none> core.register_task(<function>)
6390 */
6391static int hlua_register_task(lua_State *L)
6392{
Christopher Faulet5294ec02021-04-12 12:24:47 +02006393 struct hlua *hlua = NULL;
6394 struct task *task = NULL;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006395 int ref;
Thierry Fournier021d9862020-11-28 23:42:03 +01006396 int state_id;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006397
6398 MAY_LJMP(check_args(L, 1, "register_task"));
6399
6400 ref = MAY_LJMP(hlua_checkfunction(L, 1));
6401
Thierry Fournier75fc0292020-11-28 13:18:56 +01006402 /* Get the reference state. If the reference is NULL, L is the master
6403 * state, otherwise hlua->T is.
6404 */
6405 hlua = hlua_gethlua(L);
6406 if (hlua)
Thierry Fournier021d9862020-11-28 23:42:03 +01006407 /* we are in runtime processing */
6408 state_id = hlua->state_id;
Thierry Fournier75fc0292020-11-28 13:18:56 +01006409 else
Thierry Fournier021d9862020-11-28 23:42:03 +01006410 /* we are in initialization mode */
Thierry Fournierc7492592020-11-28 23:57:24 +01006411 state_id = hlua_state_id;
Thierry Fournier75fc0292020-11-28 13:18:56 +01006412
Willy Tarreaubafbe012017-11-24 17:34:44 +01006413 hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006414 if (!hlua)
Christopher Faulet5294ec02021-04-12 12:24:47 +02006415 goto alloc_error;
Christopher Faulet1e8433f2021-03-24 15:03:01 +01006416 HLUA_INIT(hlua);
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006417
Thierry Fournier59f11be2020-11-29 00:37:41 +01006418 /* We are in the common lua state, execute the task anywhere,
6419 * otherwise, inherit the current thread identifier
6420 */
6421 if (state_id == 0)
6422 task = task_new(MAX_THREADS_MASK);
6423 else
6424 task = task_new(tid_bit);
Willy Tarreaue09101e2018-10-16 17:37:12 +02006425 if (!task)
Christopher Faulet5294ec02021-04-12 12:24:47 +02006426 goto alloc_error;
Willy Tarreaue09101e2018-10-16 17:37:12 +02006427
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006428 task->context = hlua;
6429 task->process = hlua_process_task;
6430
Thierry Fournier021d9862020-11-28 23:42:03 +01006431 if (!hlua_ctx_init(hlua, state_id, task, 1))
Christopher Faulet5294ec02021-04-12 12:24:47 +02006432 goto alloc_error;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006433
6434 /* Restore the function in the stack. */
6435 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ref);
6436 hlua->nargs = 0;
6437
6438 /* Schedule task. */
Willy Tarreau790810f2021-09-30 16:17:37 +02006439 task_wakeup(task, TASK_WOKEN_INIT);
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006440
6441 return 0;
Christopher Faulet5294ec02021-04-12 12:24:47 +02006442
6443 alloc_error:
6444 task_destroy(task);
6445 hlua_ctx_destroy(hlua);
6446 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
6447 return 0; /* Never reached */
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006448}
6449
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006450/* Wrapper called by HAProxy to execute an LUA converter. This wrapper
6451 * doesn't allow "yield" functions because the HAProxy engine cannot
6452 * resume converters.
6453 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006454static int hlua_sample_conv_wrapper(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006455{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02006456 struct hlua_function *fcn = private;
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006457 struct stream *stream = smp->strm;
Thierry Fournierfd107a22016-02-19 19:57:23 +01006458 const char *error;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006459
Willy Tarreaube508f12016-03-10 11:47:01 +01006460 if (!stream)
6461 return 0;
6462
Willy Tarreau87b09662015-04-03 00:22:06 +02006463 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006464 * Lua context can be not initialized. This behavior
6465 * permits to save performances because a systematic
6466 * Lua initialization cause 5% performances loss.
6467 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006468 if (!stream->hlua) {
Christopher Faulet1e8433f2021-03-24 15:03:01 +01006469 struct hlua *hlua;
6470
6471 hlua = pool_alloc(pool_head_hlua);
6472 if (!hlua) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006473 SEND_ERR(stream->be, "Lua converter '%s': can't initialize Lua context.\n", fcn->name);
6474 return 0;
6475 }
Christopher Faulet1e8433f2021-03-24 15:03:01 +01006476 HLUA_INIT(hlua);
6477 stream->hlua = hlua;
Thierry Fournierc7492592020-11-28 23:57:24 +01006478 if (!hlua_ctx_init(stream->hlua, fcn_ref_to_stack_id(fcn), stream->task, 0)) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006479 SEND_ERR(stream->be, "Lua converter '%s': can't initialize Lua context.\n", fcn->name);
6480 return 0;
6481 }
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006482 }
6483
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006484 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006485 if (!HLUA_IS_RUNNING(stream->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006486
6487 /* The following Lua calls can fail. */
Thierry Fournier7cbe5042020-11-28 17:02:21 +01006488 if (!SET_SAFE_LJMP(stream->hlua)) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006489 if (lua_type(stream->hlua->T, -1) == LUA_TSTRING)
6490 error = lua_tostring(stream->hlua->T, -1);
Thierry Fournierfd107a22016-02-19 19:57:23 +01006491 else
6492 error = "critical error";
6493 SEND_ERR(stream->be, "Lua converter '%s': %s.\n", fcn->name, error);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006494 return 0;
6495 }
6496
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006497 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006498 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006499 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01006500 RESET_SAFE_LJMP(stream->hlua);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006501 return 0;
6502 }
6503
6504 /* Restore the function in the stack. */
Thierry Fournierc7492592020-11-28 23:57:24 +01006505 lua_rawgeti(stream->hlua->T, LUA_REGISTRYINDEX, fcn->function_ref[stream->hlua->state_id]);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006506
6507 /* convert input sample and pust-it in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006508 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006509 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01006510 RESET_SAFE_LJMP(stream->hlua);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006511 return 0;
6512 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006513 hlua_smp2lua(stream->hlua->T, smp);
6514 stream->hlua->nargs = 1;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006515
6516 /* push keywords in the stack. */
6517 if (arg_p) {
6518 for (; arg_p->type != ARGT_STOP; arg_p++) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006519 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006520 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01006521 RESET_SAFE_LJMP(stream->hlua);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006522 return 0;
6523 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006524 hlua_arg2lua(stream->hlua->T, arg_p);
6525 stream->hlua->nargs++;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006526 }
6527 }
6528
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006529 /* We must initialize the execution timeouts. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006530 stream->hlua->max_time = hlua_timeout_session;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006531
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006532 /* At this point the execution is safe. */
Thierry Fournier7cbe5042020-11-28 17:02:21 +01006533 RESET_SAFE_LJMP(stream->hlua);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006534 }
6535
6536 /* Execute the function. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006537 switch (hlua_ctx_resume(stream->hlua, 0)) {
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006538 /* finished. */
6539 case HLUA_E_OK:
Thierry FOURNIERfd80df12017-05-12 16:32:20 +02006540 /* If the stack is empty, the function fails. */
6541 if (lua_gettop(stream->hlua->T) <= 0)
6542 return 0;
6543
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006544 /* Convert the returned value in sample. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006545 hlua_lua2smp(stream->hlua->T, -1, smp);
6546 lua_pop(stream->hlua->T, 1);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006547 return 1;
6548
6549 /* yield. */
6550 case HLUA_E_AGAIN:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006551 SEND_ERR(stream->be, "Lua converter '%s': cannot use yielded functions.\n", fcn->name);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006552 return 0;
6553
6554 /* finished with error. */
6555 case HLUA_E_ERRMSG:
6556 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006557 SEND_ERR(stream->be, "Lua converter '%s': %s.\n",
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006558 fcn->name, lua_tostring(stream->hlua->T, -1));
6559 lua_pop(stream->hlua->T, 1);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006560 return 0;
6561
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006562 case HLUA_E_ETMOUT:
6563 SEND_ERR(stream->be, "Lua converter '%s': execution timeout.\n", fcn->name);
6564 return 0;
6565
6566 case HLUA_E_NOMEM:
6567 SEND_ERR(stream->be, "Lua converter '%s': out of memory error.\n", fcn->name);
6568 return 0;
6569
6570 case HLUA_E_YIELD:
6571 SEND_ERR(stream->be, "Lua converter '%s': yield functions like core.tcp() or core.sleep() are not allowed.\n", fcn->name);
6572 return 0;
6573
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006574 case HLUA_E_ERR:
6575 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006576 SEND_ERR(stream->be, "Lua converter '%s' returns an unknown error.\n", fcn->name);
Tim Duesterhus588b3142020-05-29 14:35:51 +02006577 /* fall through */
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006578
6579 default:
6580 return 0;
6581 }
6582}
6583
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006584/* Wrapper called by HAProxy to execute a sample-fetch. this wrapper
6585 * doesn't allow "yield" functions because the HAProxy engine cannot
Willy Tarreaube508f12016-03-10 11:47:01 +01006586 * resume sample-fetches. This function will be called by the sample
6587 * fetch engine to call lua-based fetch operations.
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006588 */
Thierry FOURNIER0786d052015-05-11 15:42:45 +02006589static int hlua_sample_fetch_wrapper(const struct arg *arg_p, struct sample *smp,
6590 const char *kw, void *private)
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006591{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02006592 struct hlua_function *fcn = private;
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006593 struct stream *stream = smp->strm;
Thierry Fournierfd107a22016-02-19 19:57:23 +01006594 const char *error;
Christopher Fauletbfab2dd2019-07-26 15:09:53 +02006595 unsigned int hflags = HLUA_TXN_NOTERM;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006596
Willy Tarreaube508f12016-03-10 11:47:01 +01006597 if (!stream)
6598 return 0;
Christopher Fauletafd8f102018-11-08 11:34:21 +01006599
Willy Tarreau87b09662015-04-03 00:22:06 +02006600 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006601 * Lua context can be not initialized. This behavior
6602 * permits to save performances because a systematic
6603 * Lua initialization cause 5% performances loss.
6604 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006605 if (!stream->hlua) {
Christopher Faulet1e8433f2021-03-24 15:03:01 +01006606 struct hlua *hlua;
6607
6608 hlua = pool_alloc(pool_head_hlua);
6609 if (!hlua) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006610 SEND_ERR(stream->be, "Lua sample-fetch '%s': can't initialize Lua context.\n", fcn->name);
6611 return 0;
6612 }
Christopher Faulet1e8433f2021-03-24 15:03:01 +01006613 hlua->T = NULL;
6614 stream->hlua = hlua;
Thierry Fournierc7492592020-11-28 23:57:24 +01006615 if (!hlua_ctx_init(stream->hlua, fcn_ref_to_stack_id(fcn), stream->task, 0)) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006616 SEND_ERR(stream->be, "Lua sample-fetch '%s': can't initialize Lua context.\n", fcn->name);
6617 return 0;
6618 }
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006619 }
6620
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006621 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006622 if (!HLUA_IS_RUNNING(stream->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006623
6624 /* The following Lua calls can fail. */
Thierry Fournier7cbe5042020-11-28 17:02:21 +01006625 if (!SET_SAFE_LJMP(stream->hlua)) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006626 if (lua_type(stream->hlua->T, -1) == LUA_TSTRING)
6627 error = lua_tostring(stream->hlua->T, -1);
Thierry Fournierfd107a22016-02-19 19:57:23 +01006628 else
6629 error = "critical error";
6630 SEND_ERR(smp->px, "Lua sample-fetch '%s': %s.\n", fcn->name, error);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006631 return 0;
6632 }
6633
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006634 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006635 if (!lua_checkstack(stream->hlua->T, 2)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006636 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01006637 RESET_SAFE_LJMP(stream->hlua);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006638 return 0;
6639 }
6640
6641 /* Restore the function in the stack. */
Thierry Fournierc7492592020-11-28 23:57:24 +01006642 lua_rawgeti(stream->hlua->T, LUA_REGISTRYINDEX, fcn->function_ref[stream->hlua->state_id]);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006643
6644 /* push arguments in the stack. */
Christopher Fauletbfab2dd2019-07-26 15:09:53 +02006645 if (!hlua_txn_new(stream->hlua->T, stream, smp->px, smp->opt & SMP_OPT_DIR, hflags)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006646 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01006647 RESET_SAFE_LJMP(stream->hlua);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006648 return 0;
6649 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006650 stream->hlua->nargs = 1;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006651
6652 /* push keywords in the stack. */
6653 for (; arg_p && arg_p->type != ARGT_STOP; arg_p++) {
6654 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006655 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006656 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01006657 RESET_SAFE_LJMP(stream->hlua);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006658 return 0;
6659 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006660 hlua_arg2lua(stream->hlua->T, arg_p);
6661 stream->hlua->nargs++;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006662 }
6663
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006664 /* We must initialize the execution timeouts. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006665 stream->hlua->max_time = hlua_timeout_session;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006666
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006667 /* At this point the execution is safe. */
Thierry Fournier7cbe5042020-11-28 17:02:21 +01006668 RESET_SAFE_LJMP(stream->hlua);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006669 }
6670
6671 /* Execute the function. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006672 switch (hlua_ctx_resume(stream->hlua, 0)) {
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006673 /* finished. */
6674 case HLUA_E_OK:
Thierry FOURNIERfd80df12017-05-12 16:32:20 +02006675 /* If the stack is empty, the function fails. */
6676 if (lua_gettop(stream->hlua->T) <= 0)
6677 return 0;
6678
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006679 /* Convert the returned value in sample. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006680 hlua_lua2smp(stream->hlua->T, -1, smp);
6681 lua_pop(stream->hlua->T, 1);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006682
6683 /* Set the end of execution flag. */
6684 smp->flags &= ~SMP_F_MAY_CHANGE;
6685 return 1;
6686
6687 /* yield. */
6688 case HLUA_E_AGAIN:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006689 SEND_ERR(smp->px, "Lua sample-fetch '%s': cannot use yielded functions.\n", fcn->name);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006690 return 0;
6691
6692 /* finished with error. */
6693 case HLUA_E_ERRMSG:
6694 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006695 SEND_ERR(smp->px, "Lua sample-fetch '%s': %s.\n",
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006696 fcn->name, lua_tostring(stream->hlua->T, -1));
6697 lua_pop(stream->hlua->T, 1);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006698 return 0;
6699
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006700 case HLUA_E_ETMOUT:
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006701 SEND_ERR(smp->px, "Lua sample-fetch '%s': execution timeout.\n", fcn->name);
6702 return 0;
6703
6704 case HLUA_E_NOMEM:
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006705 SEND_ERR(smp->px, "Lua sample-fetch '%s': out of memory error.\n", fcn->name);
6706 return 0;
6707
6708 case HLUA_E_YIELD:
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006709 SEND_ERR(smp->px, "Lua sample-fetch '%s': yield not allowed.\n", fcn->name);
6710 return 0;
6711
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006712 case HLUA_E_ERR:
6713 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006714 SEND_ERR(smp->px, "Lua sample-fetch '%s' returns an unknown error.\n", fcn->name);
Tim Duesterhus588b3142020-05-29 14:35:51 +02006715 /* fall through */
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006716
6717 default:
6718 return 0;
6719 }
6720}
6721
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006722/* This function is an LUA binding used for registering
6723 * "sample-conv" functions. It expects a converter name used
6724 * in the haproxy configuration file, and an LUA function.
6725 */
6726__LJMP static int hlua_register_converters(lua_State *L)
6727{
6728 struct sample_conv_kw_list *sck;
6729 const char *name;
6730 int ref;
6731 int len;
Christopher Fauletaa224302021-04-12 14:08:21 +02006732 struct hlua_function *fcn = NULL;
Thierry Fournierf67442e2020-11-28 20:41:07 +01006733 struct sample_conv *sc;
6734 struct buffer *trash;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006735
6736 MAY_LJMP(check_args(L, 2, "register_converters"));
6737
6738 /* First argument : converter name. */
6739 name = MAY_LJMP(luaL_checkstring(L, 1));
6740
6741 /* Second argument : lua function. */
6742 ref = MAY_LJMP(hlua_checkfunction(L, 2));
6743
Thierry Fournierf67442e2020-11-28 20:41:07 +01006744 /* Check if the converter is already registered */
6745 trash = get_trash_chunk();
6746 chunk_printf(trash, "lua.%s", name);
6747 sc = find_sample_conv(trash->area, trash->data);
6748 if (sc != NULL) {
Thierry Fournier59f11be2020-11-29 00:37:41 +01006749 fcn = sc->private;
6750 if (fcn->function_ref[hlua_state_id] != -1) {
6751 ha_warning("Trying to register converter 'lua.%s' more than once. "
6752 "This will become a hard error in version 2.5.\n", name);
6753 }
6754 fcn->function_ref[hlua_state_id] = ref;
6755 return 0;
Thierry Fournierf67442e2020-11-28 20:41:07 +01006756 }
6757
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006758 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006759 sck = calloc(1, sizeof(*sck) + sizeof(struct sample_conv) * 2);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006760 if (!sck)
Christopher Fauletaa224302021-04-12 14:08:21 +02006761 goto alloc_error;
Thierry Fournier62a22aa2020-11-28 21:06:35 +01006762 fcn = new_hlua_function();
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006763 if (!fcn)
Christopher Fauletaa224302021-04-12 14:08:21 +02006764 goto alloc_error;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006765
6766 /* Fill fcn. */
6767 fcn->name = strdup(name);
6768 if (!fcn->name)
Christopher Fauletaa224302021-04-12 14:08:21 +02006769 goto alloc_error;
Thierry Fournierc7492592020-11-28 23:57:24 +01006770 fcn->function_ref[hlua_state_id] = ref;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006771
6772 /* List head */
6773 sck->list.n = sck->list.p = NULL;
6774
6775 /* converter keyword. */
6776 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006777 sck->kw[0].kw = calloc(1, len);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006778 if (!sck->kw[0].kw)
Christopher Fauletaa224302021-04-12 14:08:21 +02006779 goto alloc_error;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006780
6781 snprintf((char *)sck->kw[0].kw, len, "lua.%s", name);
6782 sck->kw[0].process = hlua_sample_conv_wrapper;
David Carlier0c437f42016-04-27 16:21:56 +01006783 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 +01006784 sck->kw[0].val_args = NULL;
6785 sck->kw[0].in_type = SMP_T_STR;
6786 sck->kw[0].out_type = SMP_T_STR;
6787 sck->kw[0].private = fcn;
6788
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006789 /* Register this new converter */
6790 sample_register_convs(sck);
6791
6792 return 0;
Christopher Fauletaa224302021-04-12 14:08:21 +02006793
6794 alloc_error:
6795 release_hlua_function(fcn);
6796 ha_free(&sck);
6797 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
6798 return 0; /* Never reached */
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006799}
6800
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08006801/* This function is an LUA binding used for registering
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006802 * "sample-fetch" functions. It expects a converter name used
6803 * in the haproxy configuration file, and an LUA function.
6804 */
6805__LJMP static int hlua_register_fetches(lua_State *L)
6806{
6807 const char *name;
6808 int ref;
6809 int len;
6810 struct sample_fetch_kw_list *sfk;
Christopher Faulet2567f182021-04-12 14:11:50 +02006811 struct hlua_function *fcn = NULL;
Thierry Fournierf67442e2020-11-28 20:41:07 +01006812 struct sample_fetch *sf;
6813 struct buffer *trash;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006814
6815 MAY_LJMP(check_args(L, 2, "register_fetches"));
6816
6817 /* First argument : sample-fetch name. */
6818 name = MAY_LJMP(luaL_checkstring(L, 1));
6819
6820 /* Second argument : lua function. */
6821 ref = MAY_LJMP(hlua_checkfunction(L, 2));
6822
Thierry Fournierf67442e2020-11-28 20:41:07 +01006823 /* Check if the sample-fetch is already registered */
6824 trash = get_trash_chunk();
6825 chunk_printf(trash, "lua.%s", name);
6826 sf = find_sample_fetch(trash->area, trash->data);
6827 if (sf != NULL) {
Thierry Fournier59f11be2020-11-29 00:37:41 +01006828 fcn = sf->private;
6829 if (fcn->function_ref[hlua_state_id] != -1) {
6830 ha_warning("Trying to register sample-fetch 'lua.%s' more than once. "
6831 "This will become a hard error in version 2.5.\n", name);
6832 }
6833 fcn->function_ref[hlua_state_id] = ref;
6834 return 0;
Thierry Fournierf67442e2020-11-28 20:41:07 +01006835 }
6836
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006837 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006838 sfk = calloc(1, sizeof(*sfk) + sizeof(struct sample_fetch) * 2);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006839 if (!sfk)
Christopher Faulet2567f182021-04-12 14:11:50 +02006840 goto alloc_error;
Thierry Fournier62a22aa2020-11-28 21:06:35 +01006841 fcn = new_hlua_function();
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006842 if (!fcn)
Christopher Faulet2567f182021-04-12 14:11:50 +02006843 goto alloc_error;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006844
6845 /* Fill fcn. */
6846 fcn->name = strdup(name);
6847 if (!fcn->name)
Christopher Faulet2567f182021-04-12 14:11:50 +02006848 goto alloc_error;
Thierry Fournierc7492592020-11-28 23:57:24 +01006849 fcn->function_ref[hlua_state_id] = ref;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006850
6851 /* List head */
6852 sfk->list.n = sfk->list.p = NULL;
6853
6854 /* sample-fetch keyword. */
6855 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006856 sfk->kw[0].kw = calloc(1, len);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006857 if (!sfk->kw[0].kw)
Christopher Faulet2567f182021-04-12 14:11:50 +02006858 goto alloc_error;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006859
6860 snprintf((char *)sfk->kw[0].kw, len, "lua.%s", name);
6861 sfk->kw[0].process = hlua_sample_fetch_wrapper;
David Carlier0c437f42016-04-27 16:21:56 +01006862 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 +01006863 sfk->kw[0].val_args = NULL;
6864 sfk->kw[0].out_type = SMP_T_STR;
6865 sfk->kw[0].use = SMP_USE_HTTP_ANY;
6866 sfk->kw[0].val = 0;
6867 sfk->kw[0].private = fcn;
6868
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006869 /* Register this new fetch. */
6870 sample_register_fetches(sfk);
6871
6872 return 0;
Christopher Faulet2567f182021-04-12 14:11:50 +02006873
6874 alloc_error:
6875 release_hlua_function(fcn);
6876 ha_free(&sfk);
6877 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
6878 return 0; /* Never reached */
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006879}
6880
Christopher Faulet501465d2020-02-26 14:54:16 +01006881/* This function is a lua binding to set the wake_time.
Christopher Faulet2c2c2e32020-01-31 19:07:52 +01006882 */
Christopher Faulet501465d2020-02-26 14:54:16 +01006883__LJMP static int hlua_set_wake_time(lua_State *L)
Christopher Faulet2c2c2e32020-01-31 19:07:52 +01006884{
Thierry Fournier4234dbd2020-11-28 13:18:23 +01006885 struct hlua *hlua;
Christopher Faulet2c2c2e32020-01-31 19:07:52 +01006886 unsigned int delay;
6887 unsigned int wakeup_ms;
6888
Thierry Fournier4234dbd2020-11-28 13:18:23 +01006889 /* Get hlua struct, or NULL if we execute from main lua state */
6890 hlua = hlua_gethlua(L);
6891 if (!hlua) {
6892 return 0;
6893 }
6894
Christopher Faulet2c2c2e32020-01-31 19:07:52 +01006895 MAY_LJMP(check_args(L, 1, "wake_time"));
6896
6897 delay = MAY_LJMP(luaL_checkinteger(L, 1));
6898 wakeup_ms = tick_add(now_ms, delay);
6899 hlua->wake_time = wakeup_ms;
6900 return 0;
6901}
6902
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006903/* This function is a wrapper to execute each LUA function declared as an action
6904 * wrapper during the initialisation period. This function may return any
6905 * ACT_RET_* value. On error ACT_RET_CONT is returned and the action is
6906 * ignored. If the lua action yields, ACT_RET_YIELD is returned. On success, the
6907 * return value is the first element on the stack.
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006908 */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006909static enum act_return hlua_action(struct act_rule *rule, struct proxy *px,
Willy Tarreau658b85b2015-09-27 10:00:49 +02006910 struct session *sess, struct stream *s, int flags)
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006911{
6912 char **arg;
Christopher Fauletbfab2dd2019-07-26 15:09:53 +02006913 unsigned int hflags = 0;
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006914 int dir, act_ret = ACT_RET_CONT;
Thierry Fournierfd107a22016-02-19 19:57:23 +01006915 const char *error;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006916
6917 switch (rule->from) {
Christopher Fauletd8f0e072020-02-25 09:45:51 +01006918 case ACT_F_TCP_REQ_CNT: dir = SMP_OPT_DIR_REQ; break;
6919 case ACT_F_TCP_RES_CNT: dir = SMP_OPT_DIR_RES; break;
6920 case ACT_F_HTTP_REQ: dir = SMP_OPT_DIR_REQ; break;
6921 case ACT_F_HTTP_RES: dir = SMP_OPT_DIR_RES; break;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006922 default:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006923 SEND_ERR(px, "Lua: internal error while execute action.\n");
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006924 goto end;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006925 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006926
Willy Tarreau87b09662015-04-03 00:22:06 +02006927 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006928 * Lua context can be not initialized. This behavior
6929 * permits to save performances because a systematic
6930 * Lua initialization cause 5% performances loss.
6931 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006932 if (!s->hlua) {
Christopher Faulet1e8433f2021-03-24 15:03:01 +01006933 struct hlua *hlua;
6934
6935 hlua = pool_alloc(pool_head_hlua);
6936 if (!hlua) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006937 SEND_ERR(px, "Lua action '%s': can't initialize Lua context.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01006938 rule->arg.hlua_rule->fcn->name);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006939 goto end;
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006940 }
Christopher Faulet1e8433f2021-03-24 15:03:01 +01006941 HLUA_INIT(hlua);
6942 s->hlua = hlua;
Thierry Fournierc7492592020-11-28 23:57:24 +01006943 if (!hlua_ctx_init(s->hlua, fcn_ref_to_stack_id(rule->arg.hlua_rule->fcn), s->task, 0)) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006944 SEND_ERR(px, "Lua action '%s': can't initialize Lua context.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01006945 rule->arg.hlua_rule->fcn->name);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006946 goto end;
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006947 }
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006948 }
6949
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006950 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006951 if (!HLUA_IS_RUNNING(s->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006952
6953 /* The following Lua calls can fail. */
Thierry Fournier7cbe5042020-11-28 17:02:21 +01006954 if (!SET_SAFE_LJMP(s->hlua)) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006955 if (lua_type(s->hlua->T, -1) == LUA_TSTRING)
6956 error = lua_tostring(s->hlua->T, -1);
Thierry Fournierfd107a22016-02-19 19:57:23 +01006957 else
6958 error = "critical error";
6959 SEND_ERR(px, "Lua function '%s': %s.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01006960 rule->arg.hlua_rule->fcn->name, error);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006961 goto end;
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006962 }
6963
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006964 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006965 if (!lua_checkstack(s->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006966 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01006967 rule->arg.hlua_rule->fcn->name);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01006968 RESET_SAFE_LJMP(s->hlua);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006969 goto end;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006970 }
6971
6972 /* Restore the function in the stack. */
Thierry Fournierc7492592020-11-28 23:57:24 +01006973 lua_rawgeti(s->hlua->T, LUA_REGISTRYINDEX, rule->arg.hlua_rule->fcn->function_ref[s->hlua->state_id]);
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006974
Willy Tarreau87b09662015-04-03 00:22:06 +02006975 /* Create and and push object stream in the stack. */
Christopher Fauletbfab2dd2019-07-26 15:09:53 +02006976 if (!hlua_txn_new(s->hlua->T, s, px, dir, hflags)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006977 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01006978 rule->arg.hlua_rule->fcn->name);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01006979 RESET_SAFE_LJMP(s->hlua);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006980 goto end;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006981 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006982 s->hlua->nargs = 1;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006983
6984 /* push keywords in the stack. */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006985 for (arg = rule->arg.hlua_rule->args; arg && *arg; arg++) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006986 if (!lua_checkstack(s->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006987 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01006988 rule->arg.hlua_rule->fcn->name);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01006989 RESET_SAFE_LJMP(s->hlua);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006990 goto end;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006991 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006992 lua_pushstring(s->hlua->T, *arg);
6993 s->hlua->nargs++;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006994 }
6995
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006996 /* Now the execution is safe. */
Thierry Fournier7cbe5042020-11-28 17:02:21 +01006997 RESET_SAFE_LJMP(s->hlua);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006998
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006999 /* We must initialize the execution timeouts. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01007000 s->hlua->max_time = hlua_timeout_session;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007001 }
7002
7003 /* Execute the function. */
Christopher Faulet105ba6c2019-12-18 14:41:51 +01007004 switch (hlua_ctx_resume(s->hlua, !(flags & ACT_OPT_FINAL))) {
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007005 /* finished. */
7006 case HLUA_E_OK:
Christopher Faulet7716cdf2020-01-29 11:53:30 +01007007 /* Catch the return value */
7008 if (lua_gettop(s->hlua->T) > 0)
7009 act_ret = lua_tointeger(s->hlua->T, -1);
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007010
Christopher Faulet2c2c2e32020-01-31 19:07:52 +01007011 /* Set timeout in the required channel. */
Christopher Faulet498c4832020-07-28 11:59:58 +02007012 if (act_ret == ACT_RET_YIELD) {
7013 if (flags & ACT_OPT_FINAL)
7014 goto err_yield;
7015
Christopher Faulet8f587ea2020-07-28 12:01:55 +02007016 if (dir == SMP_OPT_DIR_REQ)
7017 s->req.analyse_exp = tick_first((tick_is_expired(s->req.analyse_exp, now_ms) ? 0 : s->req.analyse_exp),
7018 s->hlua->wake_time);
7019 else
7020 s->res.analyse_exp = tick_first((tick_is_expired(s->res.analyse_exp, now_ms) ? 0 : s->res.analyse_exp),
7021 s->hlua->wake_time);
Christopher Faulet2c2c2e32020-01-31 19:07:52 +01007022 }
7023 goto end;
7024
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007025 /* yield. */
7026 case HLUA_E_AGAIN:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01007027 /* Set timeout in the required channel. */
Christopher Faulet8f587ea2020-07-28 12:01:55 +02007028 if (dir == SMP_OPT_DIR_REQ)
7029 s->req.analyse_exp = tick_first((tick_is_expired(s->req.analyse_exp, now_ms) ? 0 : s->req.analyse_exp),
7030 s->hlua->wake_time);
7031 else
7032 s->res.analyse_exp = tick_first((tick_is_expired(s->res.analyse_exp, now_ms) ? 0 : s->res.analyse_exp),
7033 s->hlua->wake_time);
7034
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007035 /* Some actions can be wake up when a "write" event
7036 * is detected on a response channel. This is useful
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08007037 * only for actions targeted on the requests.
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007038 */
Christopher Faulet51fa3582019-07-26 14:54:52 +02007039 if (HLUA_IS_WAKERESWR(s->hlua))
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01007040 s->res.flags |= CF_WAKE_WRITE;
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01007041 if (HLUA_IS_WAKEREQWR(s->hlua))
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01007042 s->req.flags |= CF_WAKE_WRITE;
Christopher Faulet7716cdf2020-01-29 11:53:30 +01007043 act_ret = ACT_RET_YIELD;
7044 goto end;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007045
7046 /* finished with error. */
7047 case HLUA_E_ERRMSG:
7048 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02007049 SEND_ERR(px, "Lua function '%s': %s.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007050 rule->arg.hlua_rule->fcn->name, lua_tostring(s->hlua->T, -1));
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01007051 lua_pop(s->hlua->T, 1);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01007052 goto end;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007053
Thierry Fournierd5b073c2018-05-21 19:42:47 +02007054 case HLUA_E_ETMOUT:
Thierry Fournierad5345f2020-11-29 02:05:57 +01007055 SEND_ERR(px, "Lua function '%s': execution timeout.\n", rule->arg.hlua_rule->fcn->name);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01007056 goto end;
Thierry Fournierd5b073c2018-05-21 19:42:47 +02007057
7058 case HLUA_E_NOMEM:
Thierry Fournierad5345f2020-11-29 02:05:57 +01007059 SEND_ERR(px, "Lua function '%s': out of memory error.\n", rule->arg.hlua_rule->fcn->name);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01007060 goto end;
Thierry Fournierd5b073c2018-05-21 19:42:47 +02007061
7062 case HLUA_E_YIELD:
Christopher Faulet498c4832020-07-28 11:59:58 +02007063 err_yield:
7064 act_ret = ACT_RET_CONT;
Thierry Fournierd5b073c2018-05-21 19:42:47 +02007065 SEND_ERR(px, "Lua function '%s': aborting Lua processing on expired timeout.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007066 rule->arg.hlua_rule->fcn->name);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01007067 goto end;
Thierry Fournierd5b073c2018-05-21 19:42:47 +02007068
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007069 case HLUA_E_ERR:
7070 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02007071 SEND_ERR(px, "Lua function '%s' return an unknown error.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007072 rule->arg.hlua_rule->fcn->name);
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007073
7074 default:
Christopher Faulet7716cdf2020-01-29 11:53:30 +01007075 goto end;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007076 }
Christopher Faulet7716cdf2020-01-29 11:53:30 +01007077
7078 end:
Christopher Faulet2361fd92020-07-30 10:40:58 +02007079 if (act_ret != ACT_RET_YIELD && s->hlua)
Christopher Faulet8f587ea2020-07-28 12:01:55 +02007080 s->hlua->wake_time = TICK_ETERNITY;
Christopher Faulet7716cdf2020-01-29 11:53:30 +01007081 return act_ret;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007082}
7083
Willy Tarreau144f84a2021-03-02 16:09:26 +01007084struct task *hlua_applet_wakeup(struct task *t, void *context, unsigned int state)
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007085{
Olivier Houchard9f6af332018-05-25 14:04:04 +02007086 struct appctx *ctx = context;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007087
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007088 appctx_wakeup(ctx);
Willy Tarreaud9587412017-08-23 16:07:33 +02007089 t->expire = TICK_ETERNITY;
Willy Tarreaud1aa41f2017-07-21 16:41:56 +02007090 return t;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007091}
7092
7093static int hlua_applet_tcp_init(struct appctx *ctx, struct proxy *px, struct stream *strm)
7094{
7095 struct stream_interface *si = ctx->owner;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007096 struct hlua *hlua;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007097 struct task *task;
7098 char **arg;
Thierry Fournierfd107a22016-02-19 19:57:23 +01007099 const char *error;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007100
Willy Tarreaubafbe012017-11-24 17:34:44 +01007101 hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007102 if (!hlua) {
7103 SEND_ERR(px, "Lua applet tcp '%s': out of memory.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007104 ctx->rule->arg.hlua_rule->fcn->name);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007105 return 0;
7106 }
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007107 HLUA_INIT(hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007108 ctx->ctx.hlua_apptcp.hlua = hlua;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007109 ctx->ctx.hlua_apptcp.flags = 0;
7110
7111 /* Create task used by signal to wakeup applets. */
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01007112 task = task_new(tid_bit);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007113 if (!task) {
7114 SEND_ERR(px, "Lua applet tcp '%s': out of memory.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007115 ctx->rule->arg.hlua_rule->fcn->name);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007116 return 0;
7117 }
7118 task->nice = 0;
7119 task->context = ctx;
7120 task->process = hlua_applet_wakeup;
7121 ctx->ctx.hlua_apptcp.task = task;
7122
7123 /* In the execution wrappers linked with a stream, the
7124 * Lua context can be not initialized. This behavior
7125 * permits to save performances because a systematic
7126 * Lua initialization cause 5% performances loss.
7127 */
Thierry Fournierc7492592020-11-28 23:57:24 +01007128 if (!hlua_ctx_init(hlua, fcn_ref_to_stack_id(ctx->rule->arg.hlua_rule->fcn), task, 0)) {
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007129 SEND_ERR(px, "Lua applet tcp '%s': can't initialize Lua context.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007130 ctx->rule->arg.hlua_rule->fcn->name);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007131 return 0;
7132 }
7133
7134 /* Set timeout according with the applet configuration. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02007135 hlua->max_time = ctx->applet->timeout;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007136
7137 /* The following Lua calls can fail. */
Thierry Fournier7cbe5042020-11-28 17:02:21 +01007138 if (!SET_SAFE_LJMP(hlua)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01007139 if (lua_type(hlua->T, -1) == LUA_TSTRING)
7140 error = lua_tostring(hlua->T, -1);
7141 else
7142 error = "critical error";
7143 SEND_ERR(px, "Lua applet tcp '%s': %s.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007144 ctx->rule->arg.hlua_rule->fcn->name, error);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007145 return 0;
7146 }
7147
7148 /* Check stack available size. */
7149 if (!lua_checkstack(hlua->T, 1)) {
7150 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007151 ctx->rule->arg.hlua_rule->fcn->name);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01007152 RESET_SAFE_LJMP(hlua);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007153 return 0;
7154 }
7155
7156 /* Restore the function in the stack. */
Thierry Fournierc7492592020-11-28 23:57:24 +01007157 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ctx->rule->arg.hlua_rule->fcn->function_ref[hlua->state_id]);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007158
7159 /* Create and and push object stream in the stack. */
7160 if (!hlua_applet_tcp_new(hlua->T, ctx)) {
7161 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007162 ctx->rule->arg.hlua_rule->fcn->name);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01007163 RESET_SAFE_LJMP(hlua);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007164 return 0;
7165 }
7166 hlua->nargs = 1;
7167
7168 /* push keywords in the stack. */
7169 for (arg = ctx->rule->arg.hlua_rule->args; arg && *arg; arg++) {
7170 if (!lua_checkstack(hlua->T, 1)) {
7171 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007172 ctx->rule->arg.hlua_rule->fcn->name);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01007173 RESET_SAFE_LJMP(hlua);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007174 return 0;
7175 }
7176 lua_pushstring(hlua->T, *arg);
7177 hlua->nargs++;
7178 }
7179
Thierry Fournier7cbe5042020-11-28 17:02:21 +01007180 RESET_SAFE_LJMP(hlua);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007181
7182 /* Wakeup the applet ASAP. */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01007183 si_cant_get(si);
Willy Tarreau3367d412018-11-15 10:57:41 +01007184 si_rx_endp_more(si);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007185
7186 return 1;
7187}
7188
Willy Tarreau60409db2019-08-21 14:14:50 +02007189void hlua_applet_tcp_fct(struct appctx *ctx)
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007190{
7191 struct stream_interface *si = ctx->owner;
7192 struct stream *strm = si_strm(si);
7193 struct channel *res = si_ic(si);
7194 struct act_rule *rule = ctx->rule;
7195 struct proxy *px = strm->be;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007196 struct hlua *hlua = ctx->ctx.hlua_apptcp.hlua;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007197
7198 /* The applet execution is already done. */
Olivier Houchard594c8c52018-08-28 14:41:31 +02007199 if (ctx->ctx.hlua_apptcp.flags & APPLET_DONE) {
7200 /* eat the whole request */
7201 co_skip(si_oc(si), co_data(si_oc(si)));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007202 return;
Olivier Houchard594c8c52018-08-28 14:41:31 +02007203 }
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007204
7205 /* If the stream is disconnect or closed, ldo nothing. */
7206 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
7207 return;
7208
7209 /* Execute the function. */
7210 switch (hlua_ctx_resume(hlua, 1)) {
7211 /* finished. */
7212 case HLUA_E_OK:
7213 ctx->ctx.hlua_apptcp.flags |= APPLET_DONE;
7214
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007215 /* eat the whole request */
Willy Tarreaua79021a2018-06-15 18:07:57 +02007216 co_skip(si_oc(si), co_data(si_oc(si)));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007217 res->flags |= CF_READ_NULL;
7218 si_shutr(si);
7219 return;
7220
7221 /* yield. */
7222 case HLUA_E_AGAIN:
Thierry Fournier0164f202016-02-20 17:47:43 +01007223 if (hlua->wake_time != TICK_ETERNITY)
7224 task_schedule(ctx->ctx.hlua_apptcp.task, hlua->wake_time);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007225 return;
7226
7227 /* finished with error. */
7228 case HLUA_E_ERRMSG:
7229 /* Display log. */
7230 SEND_ERR(px, "Lua applet tcp '%s': %s.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007231 rule->arg.hlua_rule->fcn->name, lua_tostring(hlua->T, -1));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007232 lua_pop(hlua->T, 1);
7233 goto error;
7234
Thierry Fournierd5b073c2018-05-21 19:42:47 +02007235 case HLUA_E_ETMOUT:
7236 SEND_ERR(px, "Lua applet tcp '%s': execution timeout.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007237 rule->arg.hlua_rule->fcn->name);
Thierry Fournierd5b073c2018-05-21 19:42:47 +02007238 goto error;
7239
7240 case HLUA_E_NOMEM:
7241 SEND_ERR(px, "Lua applet tcp '%s': out of memory error.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007242 rule->arg.hlua_rule->fcn->name);
Thierry Fournierd5b073c2018-05-21 19:42:47 +02007243 goto error;
7244
7245 case HLUA_E_YIELD: /* unexpected */
7246 SEND_ERR(px, "Lua applet tcp '%s': yield not allowed.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007247 rule->arg.hlua_rule->fcn->name);
Thierry Fournierd5b073c2018-05-21 19:42:47 +02007248 goto error;
7249
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007250 case HLUA_E_ERR:
7251 /* Display log. */
7252 SEND_ERR(px, "Lua applet tcp '%s' return an unknown error.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007253 rule->arg.hlua_rule->fcn->name);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007254 goto error;
7255
7256 default:
7257 goto error;
7258 }
7259
7260error:
7261
7262 /* For all other cases, just close the stream. */
7263 si_shutw(si);
7264 si_shutr(si);
7265 ctx->ctx.hlua_apptcp.flags |= APPLET_DONE;
7266}
7267
7268static void hlua_applet_tcp_release(struct appctx *ctx)
7269{
Olivier Houchard3f795f72019-04-17 22:51:06 +02007270 task_destroy(ctx->ctx.hlua_apptcp.task);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007271 ctx->ctx.hlua_apptcp.task = NULL;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007272 hlua_ctx_destroy(ctx->ctx.hlua_apptcp.hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007273 ctx->ctx.hlua_apptcp.hlua = NULL;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007274}
7275
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007276/* The function returns 1 if the initialisation is complete, 0 if
7277 * an errors occurs and -1 if more data are required for initializing
7278 * the applet.
7279 */
7280static int hlua_applet_http_init(struct appctx *ctx, struct proxy *px, struct stream *strm)
7281{
7282 struct stream_interface *si = ctx->owner;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007283 struct http_txn *txn;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007284 struct hlua *hlua;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007285 char **arg;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007286 struct task *task;
Thierry Fournierfd107a22016-02-19 19:57:23 +01007287 const char *error;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007288
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007289 txn = strm->txn;
Willy Tarreaubafbe012017-11-24 17:34:44 +01007290 hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007291 if (!hlua) {
7292 SEND_ERR(px, "Lua applet http '%s': out of memory.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007293 ctx->rule->arg.hlua_rule->fcn->name);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007294 return 0;
7295 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007296 HLUA_INIT(hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007297 ctx->ctx.hlua_apphttp.hlua = hlua;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007298 ctx->ctx.hlua_apphttp.left_bytes = -1;
7299 ctx->ctx.hlua_apphttp.flags = 0;
7300
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +01007301 if (txn->req.flags & HTTP_MSGF_VER_11)
7302 ctx->ctx.hlua_apphttp.flags |= APPLET_HTTP11;
7303
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007304 /* Create task used by signal to wakeup applets. */
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01007305 task = task_new(tid_bit);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007306 if (!task) {
7307 SEND_ERR(px, "Lua applet http '%s': out of memory.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007308 ctx->rule->arg.hlua_rule->fcn->name);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007309 return 0;
7310 }
7311 task->nice = 0;
7312 task->context = ctx;
7313 task->process = hlua_applet_wakeup;
7314 ctx->ctx.hlua_apphttp.task = task;
7315
7316 /* In the execution wrappers linked with a stream, the
7317 * Lua context can be not initialized. This behavior
7318 * permits to save performances because a systematic
7319 * Lua initialization cause 5% performances loss.
7320 */
Thierry Fournierc7492592020-11-28 23:57:24 +01007321 if (!hlua_ctx_init(hlua, fcn_ref_to_stack_id(ctx->rule->arg.hlua_rule->fcn), task, 0)) {
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007322 SEND_ERR(px, "Lua applet http '%s': can't initialize Lua context.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007323 ctx->rule->arg.hlua_rule->fcn->name);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007324 return 0;
7325 }
7326
7327 /* Set timeout according with the applet configuration. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02007328 hlua->max_time = ctx->applet->timeout;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007329
7330 /* The following Lua calls can fail. */
Thierry Fournier7cbe5042020-11-28 17:02:21 +01007331 if (!SET_SAFE_LJMP(hlua)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01007332 if (lua_type(hlua->T, -1) == LUA_TSTRING)
7333 error = lua_tostring(hlua->T, -1);
7334 else
7335 error = "critical error";
7336 SEND_ERR(px, "Lua applet http '%s': %s.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007337 ctx->rule->arg.hlua_rule->fcn->name, error);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007338 return 0;
7339 }
7340
7341 /* Check stack available size. */
7342 if (!lua_checkstack(hlua->T, 1)) {
7343 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007344 ctx->rule->arg.hlua_rule->fcn->name);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01007345 RESET_SAFE_LJMP(hlua);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007346 return 0;
7347 }
7348
7349 /* Restore the function in the stack. */
Thierry Fournierc7492592020-11-28 23:57:24 +01007350 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ctx->rule->arg.hlua_rule->fcn->function_ref[hlua->state_id]);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007351
7352 /* Create and and push object stream in the stack. */
7353 if (!hlua_applet_http_new(hlua->T, ctx)) {
7354 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007355 ctx->rule->arg.hlua_rule->fcn->name);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01007356 RESET_SAFE_LJMP(hlua);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007357 return 0;
7358 }
7359 hlua->nargs = 1;
7360
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007361 /* push keywords in the stack. */
7362 for (arg = ctx->rule->arg.hlua_rule->args; arg && *arg; arg++) {
7363 if (!lua_checkstack(hlua->T, 1)) {
7364 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007365 ctx->rule->arg.hlua_rule->fcn->name);
Thierry Fournier7cbe5042020-11-28 17:02:21 +01007366 RESET_SAFE_LJMP(hlua);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007367 return 0;
7368 }
7369 lua_pushstring(hlua->T, *arg);
7370 hlua->nargs++;
7371 }
7372
Thierry Fournier7cbe5042020-11-28 17:02:21 +01007373 RESET_SAFE_LJMP(hlua);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007374
7375 /* Wakeup the applet when data is ready for read. */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01007376 si_cant_get(si);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007377
7378 return 1;
7379}
7380
Willy Tarreau60409db2019-08-21 14:14:50 +02007381void hlua_applet_http_fct(struct appctx *ctx)
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007382{
7383 struct stream_interface *si = ctx->owner;
7384 struct stream *strm = si_strm(si);
7385 struct channel *req = si_oc(si);
7386 struct channel *res = si_ic(si);
7387 struct act_rule *rule = ctx->rule;
7388 struct proxy *px = strm->be;
7389 struct hlua *hlua = ctx->ctx.hlua_apphttp.hlua;
7390 struct htx *req_htx, *res_htx;
7391
7392 res_htx = htx_from_buf(&res->buf);
7393
7394 /* If the stream is disconnect or closed, ldo nothing. */
7395 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
7396 goto out;
7397
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05007398 /* Check if the input buffer is available. */
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007399 if (!b_size(&res->buf)) {
7400 si_rx_room_blk(si);
7401 goto out;
7402 }
7403 /* check that the output is not closed */
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007404 if (res->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_SHUTR))
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007405 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
7406
7407 /* Set the currently running flag. */
7408 if (!HLUA_IS_RUNNING(hlua) &&
7409 !(ctx->ctx.hlua_apphttp.flags & APPLET_DONE)) {
Christopher Fauletbd878d22021-04-28 10:50:21 +02007410 if (!co_data(req)) {
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007411 si_cant_get(si);
7412 goto out;
7413 }
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007414 }
7415
7416 /* Executes The applet if it is not done. */
7417 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_DONE)) {
7418
7419 /* Execute the function. */
7420 switch (hlua_ctx_resume(hlua, 1)) {
7421 /* finished. */
7422 case HLUA_E_OK:
7423 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
7424 break;
7425
7426 /* yield. */
7427 case HLUA_E_AGAIN:
7428 if (hlua->wake_time != TICK_ETERNITY)
7429 task_schedule(ctx->ctx.hlua_apphttp.task, hlua->wake_time);
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007430 goto out;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007431
7432 /* finished with error. */
7433 case HLUA_E_ERRMSG:
7434 /* Display log. */
7435 SEND_ERR(px, "Lua applet http '%s': %s.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007436 rule->arg.hlua_rule->fcn->name, lua_tostring(hlua->T, -1));
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007437 lua_pop(hlua->T, 1);
7438 goto error;
7439
7440 case HLUA_E_ETMOUT:
7441 SEND_ERR(px, "Lua applet http '%s': execution timeout.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007442 rule->arg.hlua_rule->fcn->name);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007443 goto error;
7444
7445 case HLUA_E_NOMEM:
7446 SEND_ERR(px, "Lua applet http '%s': out of memory error.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007447 rule->arg.hlua_rule->fcn->name);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007448 goto error;
7449
7450 case HLUA_E_YIELD: /* unexpected */
7451 SEND_ERR(px, "Lua applet http '%s': yield not allowed.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007452 rule->arg.hlua_rule->fcn->name);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007453 goto error;
7454
7455 case HLUA_E_ERR:
7456 /* Display log. */
7457 SEND_ERR(px, "Lua applet http '%s' return an unknown error.\n",
Thierry Fournierad5345f2020-11-29 02:05:57 +01007458 rule->arg.hlua_rule->fcn->name);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007459 goto error;
7460
7461 default:
7462 goto error;
7463 }
7464 }
7465
7466 if (ctx->ctx.hlua_apphttp.flags & APPLET_DONE) {
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007467 if (ctx->ctx.hlua_apphttp.flags & APPLET_RSP_SENT)
7468 goto done;
7469
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007470 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT))
7471 goto error;
7472
Christopher Faulet868b3b12022-04-07 10:07:18 +02007473 /* no more data are expected. If the response buffer is empty
7474 * for a chunked message, be sure to add something (EOT block in
7475 * this case) to have something to send. It is important to be
7476 * sure the EOM flags will be handled by the endpoint.
7477 */
7478 if (htx_is_empty(res_htx) && (strm->txn->rsp.flags & (HTTP_MSGF_XFER_LEN|HTTP_MSGF_CNT_LEN)) == HTTP_MSGF_XFER_LEN) {
7479 if (!htx_add_endof(res_htx, HTX_BLK_EOT)) {
7480 si_rx_room_blk(si);
7481 goto out;
7482 }
7483 channel_add_input(res, 1);
7484 }
7485
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01007486 res_htx->flags |= HTX_FL_EOM;
Christopher Faulet79c0fc72022-03-07 15:50:54 +01007487 res->flags |= CF_EOI;
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007488 strm->txn->status = ctx->ctx.hlua_apphttp.status;
7489 ctx->ctx.hlua_apphttp.flags |= APPLET_RSP_SENT;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007490 }
7491
7492 done:
7493 if (ctx->ctx.hlua_apphttp.flags & APPLET_DONE) {
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007494 if (!(res->flags & CF_SHUTR)) {
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007495 res->flags |= CF_READ_NULL;
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007496 si_shutr(si);
7497 }
7498
7499 /* eat the whole request */
7500 if (co_data(req)) {
7501 req_htx = htx_from_buf(&req->buf);
7502 co_htx_skip(req, req_htx, co_data(req));
7503 htx_to_buf(req_htx, &req->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007504 }
7505 }
7506
7507 out:
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007508 htx_to_buf(res_htx, &res->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007509 return;
7510
7511 error:
7512
7513 /* If we are in HTTP mode, and we are not send any
7514 * data, return a 500 server error in best effort:
7515 * if there is no room available in the buffer,
7516 * just close the connection.
7517 */
7518 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT)) {
Christopher Fauletf7346382019-07-17 22:02:08 +02007519 struct buffer *err = &http_err_chunks[HTTP_ERR_500];
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007520
7521 channel_erase(res);
7522 res->buf.data = b_data(err);
7523 memcpy(res->buf.area, b_head(err), b_data(err));
7524 res_htx = htx_from_buf(&res->buf);
Christopher Fauletf6cce3f2019-02-27 21:20:09 +01007525 channel_add_input(res, res_htx->data);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007526 }
7527 if (!(strm->flags & SF_ERR_MASK))
7528 strm->flags |= SF_ERR_RESOURCE;
7529 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
7530 goto done;
7531}
7532
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007533static void hlua_applet_http_release(struct appctx *ctx)
7534{
Olivier Houchard3f795f72019-04-17 22:51:06 +02007535 task_destroy(ctx->ctx.hlua_apphttp.task);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007536 ctx->ctx.hlua_apphttp.task = NULL;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007537 hlua_ctx_destroy(ctx->ctx.hlua_apphttp.hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007538 ctx->ctx.hlua_apphttp.hlua = NULL;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007539}
7540
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007541/* global {tcp|http}-request parser. Return ACT_RET_PRS_OK in
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05007542 * success case, else return ACT_RET_PRS_ERR.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02007543 *
7544 * This function can fail with an abort() due to an Lua critical error.
7545 * We are in the configuration parsing process of HAProxy, this abort() is
7546 * tolerated.
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007547 */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007548static enum act_parse_ret action_register_lua(const char **args, int *cur_arg, struct proxy *px,
7549 struct act_rule *rule, char **err)
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007550{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02007551 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007552 int i;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007553
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007554 /* Memory for the rule. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02007555 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007556 if (!rule->arg.hlua_rule) {
7557 memprintf(err, "out of memory error");
Christopher Faulet528526f2021-04-12 14:37:32 +02007558 goto error;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007559 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007560
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007561 /* Memory for arguments. */
Tim Duesterhuse52b6e52020-09-12 20:26:43 +02007562 rule->arg.hlua_rule->args = calloc(fcn->nargs + 1,
7563 sizeof(*rule->arg.hlua_rule->args));
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007564 if (!rule->arg.hlua_rule->args) {
7565 memprintf(err, "out of memory error");
Christopher Faulet528526f2021-04-12 14:37:32 +02007566 goto error;
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007567 }
7568
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007569 /* Reference the Lua function and store the reference. */
Thierry Fournierad5345f2020-11-29 02:05:57 +01007570 rule->arg.hlua_rule->fcn = fcn;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007571
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007572 /* Expect some arguments */
7573 for (i = 0; i < fcn->nargs; i++) {
Thierry FOURNIER1725c2e2019-01-06 19:38:49 +01007574 if (*args[*cur_arg] == '\0') {
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007575 memprintf(err, "expect %d arguments", fcn->nargs);
Christopher Faulet528526f2021-04-12 14:37:32 +02007576 goto error;
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007577 }
Thierry FOURNIER1725c2e2019-01-06 19:38:49 +01007578 rule->arg.hlua_rule->args[i] = strdup(args[*cur_arg]);
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007579 if (!rule->arg.hlua_rule->args[i]) {
7580 memprintf(err, "out of memory error");
Christopher Faulet528526f2021-04-12 14:37:32 +02007581 goto error;
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007582 }
7583 (*cur_arg)++;
7584 }
7585 rule->arg.hlua_rule->args[i] = NULL;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007586
Thierry FOURNIER42148732015-09-02 17:17:33 +02007587 rule->action = ACT_CUSTOM;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007588 rule->action_ptr = hlua_action;
Thierry FOURNIERafa80492015-08-19 09:04:15 +02007589 return ACT_RET_PRS_OK;
Christopher Faulet528526f2021-04-12 14:37:32 +02007590
7591 error:
7592 if (rule->arg.hlua_rule) {
7593 if (rule->arg.hlua_rule->args) {
7594 for (i = 0; i < fcn->nargs; i++)
7595 ha_free(&rule->arg.hlua_rule->args[i]);
7596 ha_free(&rule->arg.hlua_rule->args);
7597 }
7598 ha_free(&rule->arg.hlua_rule);
7599 }
7600 return ACT_RET_PRS_ERR;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007601}
7602
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007603static enum act_parse_ret action_register_service_http(const char **args, int *cur_arg, struct proxy *px,
7604 struct act_rule *rule, char **err)
7605{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02007606 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007607
Thierry FOURNIER718e2a72015-12-20 20:13:14 +01007608 /* HTTP applets are forbidden in tcp-request rules.
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05007609 * HTTP applet request requires everything initialized by
Thierry FOURNIER718e2a72015-12-20 20:13:14 +01007610 * "http_process_request" (analyzer flag AN_REQ_HTTP_INNER).
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05007611 * The applet will be immediately initialized, but its before
Thierry FOURNIER718e2a72015-12-20 20:13:14 +01007612 * the call of this analyzer.
7613 */
7614 if (rule->from != ACT_F_HTTP_REQ) {
7615 memprintf(err, "HTTP applets are forbidden from 'tcp-request' rulesets");
7616 return ACT_RET_PRS_ERR;
7617 }
7618
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007619 /* Memory for the rule. */
7620 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
7621 if (!rule->arg.hlua_rule) {
7622 memprintf(err, "out of memory error");
7623 return ACT_RET_PRS_ERR;
7624 }
7625
7626 /* Reference the Lua function and store the reference. */
Thierry Fournierad5345f2020-11-29 02:05:57 +01007627 rule->arg.hlua_rule->fcn = fcn;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007628
7629 /* TODO: later accept arguments. */
7630 rule->arg.hlua_rule->args = NULL;
7631
7632 /* Add applet pointer in the rule. */
7633 rule->applet.obj_type = OBJ_TYPE_APPLET;
7634 rule->applet.name = fcn->name;
7635 rule->applet.init = hlua_applet_http_init;
7636 rule->applet.fct = hlua_applet_http_fct;
7637 rule->applet.release = hlua_applet_http_release;
7638 rule->applet.timeout = hlua_timeout_applet;
7639
7640 return ACT_RET_PRS_OK;
7641}
7642
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007643/* This function is an LUA binding used for registering
7644 * "sample-conv" functions. It expects a converter name used
7645 * in the haproxy configuration file, and an LUA function.
7646 */
7647__LJMP static int hlua_register_action(lua_State *L)
7648{
Christopher Faulet4fc9da02021-04-12 15:08:12 +02007649 struct action_kw_list *akl = NULL;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007650 const char *name;
7651 int ref;
7652 int len;
Christopher Faulet4fc9da02021-04-12 15:08:12 +02007653 struct hlua_function *fcn = NULL;
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007654 int nargs;
Thierry Fournierf67442e2020-11-28 20:41:07 +01007655 struct buffer *trash;
7656 struct action_kw *akw;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007657
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007658 /* Initialise the number of expected arguments at 0. */
7659 nargs = 0;
7660
7661 if (lua_gettop(L) < 3 || lua_gettop(L) > 4)
7662 WILL_LJMP(luaL_error(L, "'register_action' needs between 3 and 4 arguments"));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007663
7664 /* First argument : converter name. */
7665 name = MAY_LJMP(luaL_checkstring(L, 1));
7666
7667 /* Second argument : environment. */
7668 if (lua_type(L, 2) != LUA_TTABLE)
7669 WILL_LJMP(luaL_error(L, "register_action: second argument must be a table of strings"));
7670
7671 /* Third argument : lua function. */
7672 ref = MAY_LJMP(hlua_checkfunction(L, 3));
7673
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08007674 /* Fourth argument : number of mandatory arguments expected on the configuration line. */
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007675 if (lua_gettop(L) >= 4)
7676 nargs = MAY_LJMP(luaL_checkinteger(L, 4));
7677
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08007678 /* browse the second argument as an array. */
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007679 lua_pushnil(L);
7680 while (lua_next(L, 2) != 0) {
7681 if (lua_type(L, -1) != LUA_TSTRING)
7682 WILL_LJMP(luaL_error(L, "register_action: second argument must be a table of strings"));
7683
Thierry Fournierf67442e2020-11-28 20:41:07 +01007684 /* Check if action exists */
7685 trash = get_trash_chunk();
7686 chunk_printf(trash, "lua.%s", name);
7687 if (strcmp(lua_tostring(L, -1), "tcp-req") == 0) {
7688 akw = tcp_req_cont_action(trash->area);
7689 } else if (strcmp(lua_tostring(L, -1), "tcp-res") == 0) {
7690 akw = tcp_res_cont_action(trash->area);
7691 } else if (strcmp(lua_tostring(L, -1), "http-req") == 0) {
7692 akw = action_http_req_custom(trash->area);
7693 } else if (strcmp(lua_tostring(L, -1), "http-res") == 0) {
7694 akw = action_http_res_custom(trash->area);
7695 } else {
7696 akw = NULL;
7697 }
7698 if (akw != NULL) {
Thierry Fournier59f11be2020-11-29 00:37:41 +01007699 fcn = akw->private;
7700 if (fcn->function_ref[hlua_state_id] != -1) {
7701 ha_warning("Trying to register action 'lua.%s' more than once. "
7702 "This will become a hard error in version 2.5.\n", name);
7703 }
7704 fcn->function_ref[hlua_state_id] = ref;
7705
7706 /* pop the environment string. */
7707 lua_pop(L, 1);
7708 continue;
Thierry Fournierf67442e2020-11-28 20:41:07 +01007709 }
7710
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007711 /* Check required environment. Only accepted "http" or "tcp". */
7712 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02007713 akl = calloc(1, sizeof(*akl) + sizeof(struct action_kw) * 2);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007714 if (!akl)
Christopher Faulet4fc9da02021-04-12 15:08:12 +02007715 goto alloc_error;;
Thierry Fournier62a22aa2020-11-28 21:06:35 +01007716 fcn = new_hlua_function();
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007717 if (!fcn)
Christopher Faulet4fc9da02021-04-12 15:08:12 +02007718 goto alloc_error;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007719
7720 /* Fill fcn. */
7721 fcn->name = strdup(name);
7722 if (!fcn->name)
Christopher Faulet4fc9da02021-04-12 15:08:12 +02007723 goto alloc_error;
Thierry Fournierc7492592020-11-28 23:57:24 +01007724 fcn->function_ref[hlua_state_id] = ref;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007725
Thayne McCombs8f0cc5c2021-01-07 21:35:52 -07007726 /* Set the expected number of arguments. */
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007727 fcn->nargs = nargs;
7728
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007729 /* List head */
7730 akl->list.n = akl->list.p = NULL;
7731
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007732 /* action keyword. */
7733 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02007734 akl->kw[0].kw = calloc(1, len);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007735 if (!akl->kw[0].kw)
Christopher Faulet4fc9da02021-04-12 15:08:12 +02007736 goto alloc_error;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007737
7738 snprintf((char *)akl->kw[0].kw, len, "lua.%s", name);
7739
Amaury Denoyellee4a617c2021-05-06 15:33:09 +02007740 akl->kw[0].flags = 0;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007741 akl->kw[0].private = fcn;
7742 akl->kw[0].parse = action_register_lua;
7743
7744 /* select the action registering point. */
7745 if (strcmp(lua_tostring(L, -1), "tcp-req") == 0)
7746 tcp_req_cont_keywords_register(akl);
7747 else if (strcmp(lua_tostring(L, -1), "tcp-res") == 0)
7748 tcp_res_cont_keywords_register(akl);
7749 else if (strcmp(lua_tostring(L, -1), "http-req") == 0)
7750 http_req_keywords_register(akl);
7751 else if (strcmp(lua_tostring(L, -1), "http-res") == 0)
7752 http_res_keywords_register(akl);
Christopher Faulet4fc9da02021-04-12 15:08:12 +02007753 else {
7754 release_hlua_function(fcn);
7755 if (akl)
7756 ha_free((char **)&(akl->kw[0].kw));
7757 ha_free(&akl);
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007758 WILL_LJMP(luaL_error(L, "Lua action environment '%s' is unknown. "
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007759 "'tcp-req', 'tcp-res', 'http-req' or 'http-res' "
7760 "are expected.", lua_tostring(L, -1)));
Christopher Faulet4fc9da02021-04-12 15:08:12 +02007761 }
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007762
7763 /* pop the environment string. */
7764 lua_pop(L, 1);
Christopher Faulet4fc9da02021-04-12 15:08:12 +02007765
7766 /* reset for next loop */
7767 akl = NULL;
7768 fcn = NULL;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007769 }
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007770 return ACT_RET_PRS_OK;
Christopher Faulet4fc9da02021-04-12 15:08:12 +02007771
7772 alloc_error:
7773 release_hlua_function(fcn);
7774 ha_free(&akl);
7775 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
7776 return 0; /* Never reached */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007777}
7778
7779static enum act_parse_ret action_register_service_tcp(const char **args, int *cur_arg, struct proxy *px,
7780 struct act_rule *rule, char **err)
7781{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02007782 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007783
Christopher Faulet280f85b2019-07-15 15:02:04 +02007784 if (px->mode == PR_MODE_HTTP) {
7785 memprintf(err, "Lua TCP services cannot be used on HTTP proxies");
Christopher Fauletafd8f102018-11-08 11:34:21 +01007786 return ACT_RET_PRS_ERR;
7787 }
7788
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007789 /* Memory for the rule. */
7790 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
7791 if (!rule->arg.hlua_rule) {
7792 memprintf(err, "out of memory error");
7793 return ACT_RET_PRS_ERR;
7794 }
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007795
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007796 /* Reference the Lua function and store the reference. */
Thierry Fournierad5345f2020-11-29 02:05:57 +01007797 rule->arg.hlua_rule->fcn = fcn;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007798
7799 /* TODO: later accept arguments. */
7800 rule->arg.hlua_rule->args = NULL;
7801
7802 /* Add applet pointer in the rule. */
7803 rule->applet.obj_type = OBJ_TYPE_APPLET;
7804 rule->applet.name = fcn->name;
7805 rule->applet.init = hlua_applet_tcp_init;
7806 rule->applet.fct = hlua_applet_tcp_fct;
7807 rule->applet.release = hlua_applet_tcp_release;
7808 rule->applet.timeout = hlua_timeout_applet;
7809
7810 return 0;
7811}
7812
7813/* This function is an LUA binding used for registering
7814 * "sample-conv" functions. It expects a converter name used
7815 * in the haproxy configuration file, and an LUA function.
7816 */
7817__LJMP static int hlua_register_service(lua_State *L)
7818{
7819 struct action_kw_list *akl;
7820 const char *name;
7821 const char *env;
7822 int ref;
7823 int len;
Christopher Faulet5c028d72021-04-12 15:11:44 +02007824 struct hlua_function *fcn = NULL;
Thierry Fournierf67442e2020-11-28 20:41:07 +01007825 struct buffer *trash;
7826 struct action_kw *akw;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007827
7828 MAY_LJMP(check_args(L, 3, "register_service"));
7829
7830 /* First argument : converter name. */
7831 name = MAY_LJMP(luaL_checkstring(L, 1));
7832
7833 /* Second argument : environment. */
7834 env = MAY_LJMP(luaL_checkstring(L, 2));
7835
7836 /* Third argument : lua function. */
7837 ref = MAY_LJMP(hlua_checkfunction(L, 3));
7838
Thierry Fournierf67442e2020-11-28 20:41:07 +01007839 /* Check for service already registered */
7840 trash = get_trash_chunk();
7841 chunk_printf(trash, "lua.%s", name);
7842 akw = service_find(trash->area);
7843 if (akw != NULL) {
Thierry Fournier59f11be2020-11-29 00:37:41 +01007844 fcn = akw->private;
7845 if (fcn->function_ref[hlua_state_id] != -1) {
7846 ha_warning("Trying to register service 'lua.%s' more than once. "
7847 "This will become a hard error in version 2.5.\n", name);
7848 }
7849 fcn->function_ref[hlua_state_id] = ref;
7850 return 0;
Thierry Fournierf67442e2020-11-28 20:41:07 +01007851 }
7852
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007853 /* Allocate and fill the sample fetch keyword struct. */
7854 akl = calloc(1, sizeof(*akl) + sizeof(struct action_kw) * 2);
7855 if (!akl)
Christopher Faulet5c028d72021-04-12 15:11:44 +02007856 goto alloc_error;
Thierry Fournier62a22aa2020-11-28 21:06:35 +01007857 fcn = new_hlua_function();
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007858 if (!fcn)
Christopher Faulet5c028d72021-04-12 15:11:44 +02007859 goto alloc_error;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007860
7861 /* Fill fcn. */
7862 len = strlen("<lua.>") + strlen(name) + 1;
7863 fcn->name = calloc(1, len);
7864 if (!fcn->name)
Christopher Faulet5c028d72021-04-12 15:11:44 +02007865 goto alloc_error;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007866 snprintf((char *)fcn->name, len, "<lua.%s>", name);
Thierry Fournierc7492592020-11-28 23:57:24 +01007867 fcn->function_ref[hlua_state_id] = ref;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007868
7869 /* List head */
7870 akl->list.n = akl->list.p = NULL;
7871
7872 /* converter keyword. */
7873 len = strlen("lua.") + strlen(name) + 1;
7874 akl->kw[0].kw = calloc(1, len);
7875 if (!akl->kw[0].kw)
Christopher Faulet5c028d72021-04-12 15:11:44 +02007876 goto alloc_error;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007877
7878 snprintf((char *)akl->kw[0].kw, len, "lua.%s", name);
7879
Thierry FOURNIER / OZON.IO02564fd2016-11-12 11:07:05 +01007880 /* Check required environment. Only accepted "http" or "tcp". */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007881 if (strcmp(env, "tcp") == 0)
7882 akl->kw[0].parse = action_register_service_tcp;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007883 else if (strcmp(env, "http") == 0)
7884 akl->kw[0].parse = action_register_service_http;
Christopher Faulet5c028d72021-04-12 15:11:44 +02007885 else {
7886 release_hlua_function(fcn);
7887 if (akl)
7888 ha_free((char **)&(akl->kw[0].kw));
7889 ha_free(&akl);
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007890 WILL_LJMP(luaL_error(L, "Lua service environment '%s' is unknown. "
Eric Salamafe7456f2017-12-21 14:30:07 +01007891 "'tcp' or 'http' are expected.", env));
Christopher Faulet5c028d72021-04-12 15:11:44 +02007892 }
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007893
Amaury Denoyellee4a617c2021-05-06 15:33:09 +02007894 akl->kw[0].flags = 0;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007895 akl->kw[0].private = fcn;
7896
7897 /* End of array. */
7898 memset(&akl->kw[1], 0, sizeof(*akl->kw));
7899
7900 /* Register this new converter */
7901 service_keywords_register(akl);
7902
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007903 return 0;
Christopher Faulet5c028d72021-04-12 15:11:44 +02007904
7905 alloc_error:
7906 release_hlua_function(fcn);
7907 ha_free(&akl);
7908 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
7909 return 0; /* Never reached */
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007910}
7911
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007912/* This function initialises Lua cli handler. It copies the
7913 * arguments in the Lua stack and create channel IO objects.
7914 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02007915static int hlua_cli_parse_fct(char **args, char *payload, struct appctx *appctx, void *private)
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007916{
7917 struct hlua *hlua;
7918 struct hlua_function *fcn;
7919 int i;
7920 const char *error;
7921
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007922 fcn = private;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007923 appctx->ctx.hlua_cli.fcn = private;
7924
Willy Tarreaubafbe012017-11-24 17:34:44 +01007925 hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007926 if (!hlua) {
7927 SEND_ERR(NULL, "Lua cli '%s': out of memory.\n", fcn->name);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01007928 return 1;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007929 }
7930 HLUA_INIT(hlua);
7931 appctx->ctx.hlua_cli.hlua = hlua;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007932
7933 /* Create task used by signal to wakeup applets.
Ilya Shipitsind4259502020-04-08 01:07:56 +05007934 * We use the same wakeup function than the Lua applet_tcp and
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007935 * applet_http. It is absolutely compatible.
7936 */
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01007937 appctx->ctx.hlua_cli.task = task_new(tid_bit);
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007938 if (!appctx->ctx.hlua_cli.task) {
Thierry FOURNIERffbf5692016-12-16 11:14:06 +01007939 SEND_ERR(NULL, "Lua cli '%s': out of memory.\n", fcn->name);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01007940 goto error;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007941 }
7942 appctx->ctx.hlua_cli.task->nice = 0;
7943 appctx->ctx.hlua_cli.task->context = appctx;
7944 appctx->ctx.hlua_cli.task->process = hlua_applet_wakeup;
7945
7946 /* Initialises the Lua context */
Thierry Fournierc7492592020-11-28 23:57:24 +01007947 if (!hlua_ctx_init(hlua, fcn_ref_to_stack_id(fcn), appctx->ctx.hlua_cli.task, 0)) {
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007948 SEND_ERR(NULL, "Lua cli '%s': can't initialize Lua context.\n", fcn->name);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01007949 goto error;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007950 }
7951
7952 /* The following Lua calls can fail. */
Thierry Fournier7cbe5042020-11-28 17:02:21 +01007953 if (!SET_SAFE_LJMP(hlua)) {
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007954 if (lua_type(hlua->T, -1) == LUA_TSTRING)
7955 error = lua_tostring(hlua->T, -1);
7956 else
7957 error = "critical error";
7958 SEND_ERR(NULL, "Lua cli '%s': %s.\n", fcn->name, error);
7959 goto error;
7960 }
7961
7962 /* Check stack available size. */
7963 if (!lua_checkstack(hlua->T, 2)) {
7964 SEND_ERR(NULL, "Lua cli '%s': full stack.\n", fcn->name);
7965 goto error;
7966 }
7967
7968 /* Restore the function in the stack. */
Thierry Fournierc7492592020-11-28 23:57:24 +01007969 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, fcn->function_ref[hlua->state_id]);
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007970
7971 /* Once the arguments parsed, the CLI is like an AppletTCP,
7972 * so push AppletTCP in the stack.
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007973 */
7974 if (!hlua_applet_tcp_new(hlua->T, appctx)) {
7975 SEND_ERR(NULL, "Lua cli '%s': full stack.\n", fcn->name);
7976 goto error;
7977 }
7978 hlua->nargs = 1;
7979
7980 /* push keywords in the stack. */
7981 for (i = 0; *args[i]; i++) {
7982 /* Check stack available size. */
7983 if (!lua_checkstack(hlua->T, 1)) {
7984 SEND_ERR(NULL, "Lua cli '%s': full stack.\n", fcn->name);
7985 goto error;
7986 }
7987 lua_pushstring(hlua->T, args[i]);
7988 hlua->nargs++;
7989 }
7990
7991 /* We must initialize the execution timeouts. */
7992 hlua->max_time = hlua_timeout_session;
7993
7994 /* At this point the execution is safe. */
Thierry Fournier7cbe5042020-11-28 17:02:21 +01007995 RESET_SAFE_LJMP(hlua);
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007996
7997 /* It's ok */
7998 return 0;
7999
8000 /* It's not ok. */
8001error:
Thierry Fournier7cbe5042020-11-28 17:02:21 +01008002 RESET_SAFE_LJMP(hlua);
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008003 hlua_ctx_destroy(hlua);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01008004 appctx->ctx.hlua_cli.hlua = NULL;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008005 return 1;
8006}
8007
8008static int hlua_cli_io_handler_fct(struct appctx *appctx)
8009{
8010 struct hlua *hlua;
8011 struct stream_interface *si;
8012 struct hlua_function *fcn;
8013
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01008014 hlua = appctx->ctx.hlua_cli.hlua;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008015 si = appctx->owner;
Willy Tarreau8ae4f752016-12-14 15:41:45 +01008016 fcn = appctx->ctx.hlua_cli.fcn;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008017
8018 /* If the stream is disconnect or closed, ldo nothing. */
8019 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
8020 return 1;
8021
8022 /* Execute the function. */
8023 switch (hlua_ctx_resume(hlua, 1)) {
8024
8025 /* finished. */
8026 case HLUA_E_OK:
8027 return 1;
8028
8029 /* yield. */
8030 case HLUA_E_AGAIN:
8031 /* We want write. */
8032 if (HLUA_IS_WAKERESWR(hlua))
Willy Tarreaudb398432018-11-15 11:08:52 +01008033 si_rx_room_blk(si);
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008034 /* Set the timeout. */
8035 if (hlua->wake_time != TICK_ETERNITY)
8036 task_schedule(hlua->task, hlua->wake_time);
8037 return 0;
8038
8039 /* finished with error. */
8040 case HLUA_E_ERRMSG:
8041 /* Display log. */
8042 SEND_ERR(NULL, "Lua cli '%s': %s.\n",
8043 fcn->name, lua_tostring(hlua->T, -1));
8044 lua_pop(hlua->T, 1);
8045 return 1;
8046
Thierry Fournierd5b073c2018-05-21 19:42:47 +02008047 case HLUA_E_ETMOUT:
8048 SEND_ERR(NULL, "Lua converter '%s': execution timeout.\n",
8049 fcn->name);
8050 return 1;
8051
8052 case HLUA_E_NOMEM:
8053 SEND_ERR(NULL, "Lua converter '%s': out of memory error.\n",
8054 fcn->name);
8055 return 1;
8056
8057 case HLUA_E_YIELD: /* unexpected */
8058 SEND_ERR(NULL, "Lua converter '%s': yield not allowed.\n",
8059 fcn->name);
8060 return 1;
8061
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008062 case HLUA_E_ERR:
8063 /* Display log. */
8064 SEND_ERR(NULL, "Lua cli '%s' return an unknown error.\n",
8065 fcn->name);
8066 return 1;
8067
8068 default:
8069 return 1;
8070 }
8071
8072 return 1;
8073}
8074
8075static void hlua_cli_io_release_fct(struct appctx *appctx)
8076{
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01008077 hlua_ctx_destroy(appctx->ctx.hlua_cli.hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01008078 appctx->ctx.hlua_cli.hlua = NULL;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008079}
8080
8081/* This function is an LUA binding used for registering
8082 * new keywords in the cli. It expects a list of keywords
8083 * which are the "path". It is limited to 5 keywords. A
8084 * description of the command, a function to be executed
8085 * for the parsing and a function for io handlers.
8086 */
8087__LJMP static int hlua_register_cli(lua_State *L)
8088{
8089 struct cli_kw_list *cli_kws;
8090 const char *message;
8091 int ref_io;
8092 int len;
Christopher Faulet3a9a12b2021-04-12 15:31:29 +02008093 struct hlua_function *fcn = NULL;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008094 int index;
8095 int i;
Thierry Fournierf67442e2020-11-28 20:41:07 +01008096 struct buffer *trash;
8097 const char *kw[5];
8098 struct cli_kw *cli_kw;
Christopher Faulet3a9a12b2021-04-12 15:31:29 +02008099 const char *errmsg;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008100
8101 MAY_LJMP(check_args(L, 3, "register_cli"));
8102
8103 /* First argument : an array of maximum 5 keywords. */
8104 if (!lua_istable(L, 1))
8105 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table"));
8106
8107 /* Second argument : string with contextual message. */
8108 message = MAY_LJMP(luaL_checkstring(L, 2));
8109
8110 /* Third and fourth argument : lua function. */
8111 ref_io = MAY_LJMP(hlua_checkfunction(L, 3));
8112
Thierry Fournierf67442e2020-11-28 20:41:07 +01008113 /* Check for CLI service already registered */
8114 trash = get_trash_chunk();
8115 index = 0;
8116 lua_pushnil(L);
8117 memset(kw, 0, sizeof(kw));
8118 while (lua_next(L, 1) != 0) {
8119 if (index >= CLI_PREFIX_KW_NB)
8120 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table with a maximum of 5 entries"));
8121 if (lua_type(L, -1) != LUA_TSTRING)
8122 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table filled with strings"));
8123 kw[index] = lua_tostring(L, -1);
8124 if (index == 0)
8125 chunk_printf(trash, "%s", kw[index]);
8126 else
8127 chunk_appendf(trash, " %s", kw[index]);
8128 index++;
8129 lua_pop(L, 1);
8130 }
8131 cli_kw = cli_find_kw_exact((char **)kw);
8132 if (cli_kw != NULL) {
Thierry Fournier59f11be2020-11-29 00:37:41 +01008133 fcn = cli_kw->private;
8134 if (fcn->function_ref[hlua_state_id] != -1) {
8135 ha_warning("Trying to register CLI keyword 'lua.%s' more than once. "
8136 "This will become a hard error in version 2.5.\n", trash->area);
8137 }
8138 fcn->function_ref[hlua_state_id] = ref_io;
8139 return 0;
Thierry Fournierf67442e2020-11-28 20:41:07 +01008140 }
8141
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008142 /* Allocate and fill the sample fetch keyword struct. */
8143 cli_kws = calloc(1, sizeof(*cli_kws) + sizeof(struct cli_kw) * 2);
Christopher Faulet3a9a12b2021-04-12 15:31:29 +02008144 if (!cli_kws) {
8145 errmsg = "Lua out of memory error.";
8146 goto error;
8147 }
Thierry Fournier62a22aa2020-11-28 21:06:35 +01008148 fcn = new_hlua_function();
Christopher Faulet3a9a12b2021-04-12 15:31:29 +02008149 if (!fcn) {
8150 errmsg = "Lua out of memory error.";
8151 goto error;
8152 }
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008153
8154 /* Fill path. */
8155 index = 0;
8156 lua_pushnil(L);
8157 while(lua_next(L, 1) != 0) {
Christopher Faulet3a9a12b2021-04-12 15:31:29 +02008158 if (index >= 5) {
8159 errmsg = "1st argument must be a table with a maximum of 5 entries";
8160 goto error;
8161 }
8162 if (lua_type(L, -1) != LUA_TSTRING) {
8163 errmsg = "1st argument must be a table filled with strings";
8164 goto error;
8165 }
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008166 cli_kws->kw[0].str_kw[index] = strdup(lua_tostring(L, -1));
Christopher Faulet3a9a12b2021-04-12 15:31:29 +02008167 if (!cli_kws->kw[0].str_kw[index]) {
8168 errmsg = "Lua out of memory error.";
8169 goto error;
8170 }
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008171 index++;
8172 lua_pop(L, 1);
8173 }
8174
8175 /* Copy help message. */
8176 cli_kws->kw[0].usage = strdup(message);
Christopher Faulet3a9a12b2021-04-12 15:31:29 +02008177 if (!cli_kws->kw[0].usage) {
8178 errmsg = "Lua out of memory error.";
8179 goto error;
8180 }
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008181
8182 /* Fill fcn io handler. */
8183 len = strlen("<lua.cli>") + 1;
8184 for (i = 0; i < index; i++)
8185 len += strlen(cli_kws->kw[0].str_kw[i]) + 1;
8186 fcn->name = calloc(1, len);
Christopher Faulet3a9a12b2021-04-12 15:31:29 +02008187 if (!fcn->name) {
8188 errmsg = "Lua out of memory error.";
8189 goto error;
8190 }
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008191 strncat((char *)fcn->name, "<lua.cli", len);
8192 for (i = 0; i < index; i++) {
8193 strncat((char *)fcn->name, ".", len);
8194 strncat((char *)fcn->name, cli_kws->kw[0].str_kw[i], len);
8195 }
8196 strncat((char *)fcn->name, ">", len);
Thierry Fournierc7492592020-11-28 23:57:24 +01008197 fcn->function_ref[hlua_state_id] = ref_io;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008198
8199 /* Fill last entries. */
8200 cli_kws->kw[0].private = fcn;
8201 cli_kws->kw[0].parse = hlua_cli_parse_fct;
8202 cli_kws->kw[0].io_handler = hlua_cli_io_handler_fct;
8203 cli_kws->kw[0].io_release = hlua_cli_io_release_fct;
8204
8205 /* Register this new converter */
8206 cli_register_kw(cli_kws);
8207
8208 return 0;
Christopher Faulet3a9a12b2021-04-12 15:31:29 +02008209
8210 error:
8211 release_hlua_function(fcn);
8212 if (cli_kws) {
8213 for (i = 0; i < index; i++)
8214 ha_free((char **)&(cli_kws->kw[0].str_kw[i]));
8215 ha_free((char **)&(cli_kws->kw[0].usage));
8216 }
8217 ha_free(&cli_kws);
8218 WILL_LJMP(luaL_error(L, errmsg));
8219 return 0; /* Never reached */
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008220}
8221
Thierry FOURNIERbd413492015-03-03 16:52:26 +01008222static int hlua_read_timeout(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01008223 const struct proxy *defpx, const char *file, int line,
Thierry FOURNIERbd413492015-03-03 16:52:26 +01008224 char **err, unsigned int *timeout)
8225{
8226 const char *error;
8227
8228 error = parse_time_err(args[1], timeout, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02008229 if (error == PARSE_TIME_OVER) {
8230 memprintf(err, "timer overflow in argument <%s> to <%s> (maximum value is 2147483647 ms or ~24.8 days)",
8231 args[1], args[0]);
8232 return -1;
8233 }
8234 else if (error == PARSE_TIME_UNDER) {
8235 memprintf(err, "timer underflow in argument <%s> to <%s> (minimum non-null value is 1 ms)",
8236 args[1], args[0]);
8237 return -1;
8238 }
8239 else if (error) {
Thierry FOURNIERbd413492015-03-03 16:52:26 +01008240 memprintf(err, "%s: invalid timeout", args[0]);
8241 return -1;
8242 }
8243 return 0;
8244}
8245
8246static int hlua_session_timeout(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01008247 const struct proxy *defpx, const char *file, int line,
Thierry FOURNIERbd413492015-03-03 16:52:26 +01008248 char **err)
8249{
8250 return hlua_read_timeout(args, section_type, curpx, defpx,
8251 file, line, err, &hlua_timeout_session);
8252}
8253
8254static int hlua_task_timeout(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01008255 const struct proxy *defpx, const char *file, int line,
Thierry FOURNIERbd413492015-03-03 16:52:26 +01008256 char **err)
8257{
8258 return hlua_read_timeout(args, section_type, curpx, defpx,
8259 file, line, err, &hlua_timeout_task);
8260}
8261
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008262static int hlua_applet_timeout(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01008263 const struct proxy *defpx, const char *file, int line,
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008264 char **err)
8265{
8266 return hlua_read_timeout(args, section_type, curpx, defpx,
8267 file, line, err, &hlua_timeout_applet);
8268}
8269
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01008270static int hlua_forced_yield(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01008271 const struct proxy *defpx, const char *file, int line,
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01008272 char **err)
8273{
8274 char *error;
8275
8276 hlua_nb_instruction = strtoll(args[1], &error, 10);
8277 if (*error != '\0') {
8278 memprintf(err, "%s: invalid number", args[0]);
8279 return -1;
8280 }
8281 return 0;
8282}
8283
Willy Tarreau32f61e22015-03-18 17:54:59 +01008284static int hlua_parse_maxmem(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01008285 const struct proxy *defpx, const char *file, int line,
Willy Tarreau32f61e22015-03-18 17:54:59 +01008286 char **err)
8287{
8288 char *error;
8289
8290 if (*(args[1]) == 0) {
8291 memprintf(err, "'%s' expects an integer argument (Lua memory size in MB).\n", args[0]);
8292 return -1;
8293 }
8294 hlua_global_allocator.limit = strtoll(args[1], &error, 10) * 1024L * 1024L;
8295 if (*error != '\0') {
8296 memprintf(err, "%s: invalid number %s (error at '%c')", args[0], args[1], *error);
8297 return -1;
8298 }
8299 return 0;
8300}
8301
8302
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008303/* This function is called by the main configuration key "lua-load". It loads and
8304 * execute an lua file during the parsing of the HAProxy configuration file. It is
8305 * the main lua entry point.
8306 *
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08008307 * This function runs with the HAProxy keywords API. It returns -1 if an error
8308 * occurs, otherwise it returns 0.
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008309 *
8310 * In some error case, LUA set an error message in top of the stack. This function
8311 * returns this error message in the HAProxy logs and pop it from the stack.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02008312 *
8313 * This function can fail with an abort() due to an Lua critical error.
8314 * We are in the configuration parsing process of HAProxy, this abort() is
8315 * tolerated.
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008316 */
Thierry Fournierc93c15c2020-11-28 15:02:13 +01008317static int hlua_load_state(char *filename, lua_State *L, char **err)
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008318{
8319 int error;
8320
8321 /* Just load and compile the file. */
Thierry Fournierc93c15c2020-11-28 15:02:13 +01008322 error = luaL_loadfile(L, filename);
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008323 if (error) {
Thierry Fournierc93c15c2020-11-28 15:02:13 +01008324 memprintf(err, "error in Lua file '%s': %s", filename, lua_tostring(L, -1));
8325 lua_pop(L, 1);
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008326 return -1;
8327 }
8328
8329 /* If no syntax error where detected, execute the code. */
Thierry Fournierc93c15c2020-11-28 15:02:13 +01008330 error = lua_pcall(L, 0, LUA_MULTRET, 0);
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008331 switch (error) {
8332 case LUA_OK:
8333 break;
8334 case LUA_ERRRUN:
Thierry Fournierc93c15c2020-11-28 15:02:13 +01008335 memprintf(err, "Lua runtime error: %s\n", lua_tostring(L, -1));
8336 lua_pop(L, 1);
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008337 return -1;
8338 case LUA_ERRMEM:
Thierry Fournierde6145f2020-11-29 00:55:53 +01008339 memprintf(err, "Lua out of memory error\n");
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008340 return -1;
8341 case LUA_ERRERR:
Thierry Fournierc93c15c2020-11-28 15:02:13 +01008342 memprintf(err, "Lua message handler error: %s\n", lua_tostring(L, -1));
8343 lua_pop(L, 1);
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008344 return -1;
Christopher Faulet08ed98f2020-07-28 10:33:25 +02008345#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM <= 503
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008346 case LUA_ERRGCMM:
Thierry Fournierc93c15c2020-11-28 15:02:13 +01008347 memprintf(err, "Lua garbage collector error: %s\n", lua_tostring(L, -1));
8348 lua_pop(L, 1);
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008349 return -1;
Christopher Faulet08ed98f2020-07-28 10:33:25 +02008350#endif
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008351 default:
Thierry Fournierc93c15c2020-11-28 15:02:13 +01008352 memprintf(err, "Lua unknown error: %s\n", lua_tostring(L, -1));
8353 lua_pop(L, 1);
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008354 return -1;
8355 }
8356
8357 return 0;
8358}
8359
Thierry Fournierc93c15c2020-11-28 15:02:13 +01008360static int hlua_load(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01008361 const struct proxy *defpx, const char *file, int line,
Thierry Fournierc93c15c2020-11-28 15:02:13 +01008362 char **err)
8363{
8364 if (*(args[1]) == 0) {
8365 memprintf(err, "'%s' expects a file name as parameter.\n", args[0]);
8366 return -1;
8367 }
8368
Thierry Fournier59f11be2020-11-29 00:37:41 +01008369 /* loading for global state */
Thierry Fournierc7492592020-11-28 23:57:24 +01008370 hlua_state_id = 0;
Thierry Fournier59f11be2020-11-29 00:37:41 +01008371 ha_set_tid(0);
Thierry Fournierafc63e22020-11-28 17:06:51 +01008372 return hlua_load_state(args[1], hlua_states[0], err);
Thierry Fournierc93c15c2020-11-28 15:02:13 +01008373}
8374
Thierry Fournier59f11be2020-11-29 00:37:41 +01008375static int hlua_load_per_thread(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01008376 const struct proxy *defpx, const char *file, int line,
Thierry Fournier59f11be2020-11-29 00:37:41 +01008377 char **err)
8378{
8379 int len;
8380
8381 if (*(args[1]) == 0) {
8382 memprintf(err, "'%s' expects a file as parameter.\n", args[0]);
8383 return -1;
8384 }
8385
8386 if (per_thread_load == NULL) {
8387 /* allocate the first entry large enough to store the final NULL */
8388 per_thread_load = calloc(1, sizeof(*per_thread_load));
8389 if (per_thread_load == NULL) {
8390 memprintf(err, "out of memory error");
8391 return -1;
8392 }
8393 }
8394
8395 /* count used entries */
8396 for (len = 0; per_thread_load[len] != NULL; len++)
8397 ;
8398
8399 per_thread_load = realloc(per_thread_load, (len + 2) * sizeof(*per_thread_load));
8400 if (per_thread_load == NULL) {
8401 memprintf(err, "out of memory error");
8402 return -1;
8403 }
8404
8405 per_thread_load[len] = strdup(args[1]);
8406 per_thread_load[len + 1] = NULL;
8407
8408 if (per_thread_load[len] == NULL) {
8409 memprintf(err, "out of memory error");
8410 return -1;
8411 }
8412
8413 /* loading for thread 1 only */
8414 hlua_state_id = 1;
8415 ha_set_tid(0);
8416 return hlua_load_state(args[1], hlua_states[1], err);
8417}
8418
Tim Duesterhusc9fc9f22020-01-12 13:55:39 +01008419/* Prepend the given <path> followed by a semicolon to the `package.<type>` variable
8420 * in the given <ctx>.
8421 */
Thierry Fournier3fb9e512020-11-28 10:13:12 +01008422static int hlua_prepend_path(lua_State *L, char *type, char *path)
Tim Duesterhusc9fc9f22020-01-12 13:55:39 +01008423{
Thierry Fournier3fb9e512020-11-28 10:13:12 +01008424 lua_getglobal(L, "package"); /* push package variable */
8425 lua_pushstring(L, path); /* push given path */
8426 lua_pushstring(L, ";"); /* push semicolon */
8427 lua_getfield(L, -3, type); /* push old path */
8428 lua_concat(L, 3); /* concatenate to new path */
8429 lua_setfield(L, -2, type); /* store new path */
8430 lua_pop(L, 1); /* pop package variable */
Tim Duesterhusc9fc9f22020-01-12 13:55:39 +01008431
8432 return 0;
8433}
8434
Tim Duesterhusdd74b5f2020-01-12 13:55:40 +01008435static int hlua_config_prepend_path(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +01008436 const struct proxy *defpx, const char *file, int line,
Tim Duesterhusdd74b5f2020-01-12 13:55:40 +01008437 char **err)
8438{
8439 char *path;
8440 char *type = "path";
Tim Duesterhus621e74a2021-01-03 20:04:36 +01008441 struct prepend_path *p = NULL;
Thierry Fournier59f11be2020-11-29 00:37:41 +01008442
Tim Duesterhusdd74b5f2020-01-12 13:55:40 +01008443 if (too_many_args(2, args, err, NULL)) {
Tim Duesterhus621e74a2021-01-03 20:04:36 +01008444 goto err;
Tim Duesterhusdd74b5f2020-01-12 13:55:40 +01008445 }
8446
8447 if (!(*args[1])) {
8448 memprintf(err, "'%s' expects to receive a <path> as argument", args[0]);
Tim Duesterhus621e74a2021-01-03 20:04:36 +01008449 goto err;
Tim Duesterhusdd74b5f2020-01-12 13:55:40 +01008450 }
8451 path = args[1];
8452
8453 if (*args[2]) {
8454 if (strcmp(args[2], "path") != 0 && strcmp(args[2], "cpath") != 0) {
8455 memprintf(err, "'%s' expects <type> to either be 'path' or 'cpath'", args[0]);
Tim Duesterhus621e74a2021-01-03 20:04:36 +01008456 goto err;
Tim Duesterhusdd74b5f2020-01-12 13:55:40 +01008457 }
8458 type = args[2];
8459 }
8460
Thierry Fournier59f11be2020-11-29 00:37:41 +01008461 p = calloc(1, sizeof(*p));
8462 if (p == NULL) {
Tim Duesterhusf89d43a2021-01-03 20:04:37 +01008463 memprintf(err, "memory allocation failed");
Tim Duesterhus621e74a2021-01-03 20:04:36 +01008464 goto err;
Thierry Fournier59f11be2020-11-29 00:37:41 +01008465 }
8466 p->path = strdup(path);
8467 if (p->path == NULL) {
Tim Duesterhusf89d43a2021-01-03 20:04:37 +01008468 memprintf(err, "memory allocation failed");
Tim Duesterhus621e74a2021-01-03 20:04:36 +01008469 goto err2;
Thierry Fournier59f11be2020-11-29 00:37:41 +01008470 }
8471 p->type = strdup(type);
8472 if (p->type == NULL) {
Tim Duesterhusf89d43a2021-01-03 20:04:37 +01008473 memprintf(err, "memory allocation failed");
Tim Duesterhus621e74a2021-01-03 20:04:36 +01008474 goto err2;
Thierry Fournier59f11be2020-11-29 00:37:41 +01008475 }
Willy Tarreau2b718102021-04-21 07:32:39 +02008476 LIST_APPEND(&prepend_path_list, &p->l);
Thierry Fournier59f11be2020-11-29 00:37:41 +01008477
8478 hlua_prepend_path(hlua_states[0], type, path);
8479 hlua_prepend_path(hlua_states[1], type, path);
8480 return 0;
Tim Duesterhus621e74a2021-01-03 20:04:36 +01008481
8482err2:
8483 free(p->type);
8484 free(p->path);
8485err:
8486 free(p);
8487 return -1;
Tim Duesterhusdd74b5f2020-01-12 13:55:40 +01008488}
8489
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008490/* configuration keywords declaration */
8491static struct cfg_kw_list cfg_kws = {{ },{
Tim Duesterhusdd74b5f2020-01-12 13:55:40 +01008492 { CFG_GLOBAL, "lua-prepend-path", hlua_config_prepend_path },
Thierry FOURNIERbd413492015-03-03 16:52:26 +01008493 { CFG_GLOBAL, "lua-load", hlua_load },
Thierry Fournier59f11be2020-11-29 00:37:41 +01008494 { CFG_GLOBAL, "lua-load-per-thread", hlua_load_per_thread },
Thierry FOURNIERbd413492015-03-03 16:52:26 +01008495 { CFG_GLOBAL, "tune.lua.session-timeout", hlua_session_timeout },
8496 { CFG_GLOBAL, "tune.lua.task-timeout", hlua_task_timeout },
Thierry FOURNIER56da1012015-10-01 08:42:31 +02008497 { CFG_GLOBAL, "tune.lua.service-timeout", hlua_applet_timeout },
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01008498 { CFG_GLOBAL, "tune.lua.forced-yield", hlua_forced_yield },
Willy Tarreau32f61e22015-03-18 17:54:59 +01008499 { CFG_GLOBAL, "tune.lua.maxmem", hlua_parse_maxmem },
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008500 { 0, NULL, NULL },
8501}};
8502
Willy Tarreau0108d902018-11-25 19:14:37 +01008503INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
8504
Christopher Fauletafd8f102018-11-08 11:34:21 +01008505
Thierry FOURNIERbabae282015-09-17 11:36:37 +02008506/* This function can fail with an abort() due to an Lua critical error.
8507 * We are in the initialisation process of HAProxy, this abort() is
8508 * tolerated.
8509 */
Thierry Fournierb8cef172020-11-28 15:37:17 +01008510int hlua_post_init_state(lua_State *L)
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008511{
8512 struct hlua_init_function *init;
8513 const char *msg;
8514 enum hlua_exec ret;
Thierry Fournierfd107a22016-02-19 19:57:23 +01008515 const char *error;
Thierry Fournier670db242020-11-28 10:49:59 +01008516 const char *kind;
8517 const char *trace;
8518 int return_status = 1;
8519#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 504
8520 int nres;
8521#endif
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008522
Willy Tarreaucdb53462020-12-02 12:12:00 +01008523 /* disable memory limit checks if limit is not set */
8524 if (!hlua_global_allocator.limit)
8525 hlua_global_allocator.limit = ~hlua_global_allocator.limit;
8526
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05008527 /* Call post initialisation function in safe environment. */
Thierry Fournier3c539322020-11-28 16:05:05 +01008528 if (setjmp(safe_ljmp_env) != 0) {
8529 lua_atpanic(L, hlua_panic_safe);
Thierry Fournierb8cef172020-11-28 15:37:17 +01008530 if (lua_type(L, -1) == LUA_TSTRING)
8531 error = lua_tostring(L, -1);
Thierry Fournier3d4a6752016-02-19 20:53:30 +01008532 else
8533 error = "critical error";
8534 fprintf(stderr, "Lua post-init: %s.\n", error);
8535 exit(1);
Thierry Fournier3c539322020-11-28 16:05:05 +01008536 } else {
8537 lua_atpanic(L, hlua_panic_ljmp);
Thierry Fournier3d4a6752016-02-19 20:53:30 +01008538 }
Frédéric Lécaille54f2bcf2018-08-29 13:46:24 +02008539
Thierry Fournierb8cef172020-11-28 15:37:17 +01008540 hlua_fcn_post_init(L);
Thierry Fournier3d4a6752016-02-19 20:53:30 +01008541
Thierry Fournierc7492592020-11-28 23:57:24 +01008542 list_for_each_entry(init, &hlua_init_functions[hlua_state_id], l) {
Thierry Fournierb8cef172020-11-28 15:37:17 +01008543 lua_rawgeti(L, LUA_REGISTRYINDEX, init->function_ref);
Thierry Fournier670db242020-11-28 10:49:59 +01008544
8545#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 504
Thierry Fournierb8cef172020-11-28 15:37:17 +01008546 ret = lua_resume(L, L, 0, &nres);
Thierry Fournier670db242020-11-28 10:49:59 +01008547#else
Thierry Fournierb8cef172020-11-28 15:37:17 +01008548 ret = lua_resume(L, L, 0);
Thierry Fournier670db242020-11-28 10:49:59 +01008549#endif
8550 kind = NULL;
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008551 switch (ret) {
Thierry Fournier670db242020-11-28 10:49:59 +01008552
8553 case LUA_OK:
Thierry Fournierb8cef172020-11-28 15:37:17 +01008554 lua_pop(L, -1);
Thierry Fournier13d08b72020-11-28 11:02:58 +01008555 break;
Thierry Fournier670db242020-11-28 10:49:59 +01008556
8557 case LUA_ERRERR:
8558 kind = "message handler error";
Thayne McCombs8f0cc5c2021-01-07 21:35:52 -07008559 /* Fall through */
Thierry Fournier670db242020-11-28 10:49:59 +01008560 case LUA_ERRRUN:
8561 if (!kind)
8562 kind = "runtime error";
Thierry Fournierb8cef172020-11-28 15:37:17 +01008563 msg = lua_tostring(L, -1);
8564 lua_settop(L, 0); /* Empty the stack. */
8565 lua_pop(L, 1);
Christopher Fauletd09cc512021-03-24 14:48:45 +01008566 trace = hlua_traceback(L, ", ");
Thierry Fournier670db242020-11-28 10:49:59 +01008567 if (msg)
8568 ha_alert("Lua init: %s: '%s' from %s\n", kind, msg, trace);
8569 else
8570 ha_alert("Lua init: unknown %s from %s\n", kind, trace);
8571 return_status = 0;
8572 break;
8573
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008574 default:
Thierry Fournier670db242020-11-28 10:49:59 +01008575 /* Unknown error */
8576 kind = "Unknown error";
Thayne McCombs8f0cc5c2021-01-07 21:35:52 -07008577 /* Fall through */
Thierry Fournier670db242020-11-28 10:49:59 +01008578 case LUA_YIELD:
8579 /* yield is not configured at this step, this state doesn't happen */
8580 if (!kind)
8581 kind = "yield not allowed";
Thayne McCombs8f0cc5c2021-01-07 21:35:52 -07008582 /* Fall through */
Thierry Fournier670db242020-11-28 10:49:59 +01008583 case LUA_ERRMEM:
8584 if (!kind)
8585 kind = "out of memory error";
Thierry Fournierb8cef172020-11-28 15:37:17 +01008586 lua_settop(L, 0);
8587 lua_pop(L, 1);
Christopher Fauletd09cc512021-03-24 14:48:45 +01008588 trace = hlua_traceback(L, ", ");
Thierry Fournier670db242020-11-28 10:49:59 +01008589 ha_alert("Lua init: %s: %s\n", kind, trace);
8590 return_status = 0;
8591 break;
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008592 }
Thierry Fournier670db242020-11-28 10:49:59 +01008593 if (!return_status)
8594 break;
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008595 }
Thierry Fournier3c539322020-11-28 16:05:05 +01008596
8597 lua_atpanic(L, hlua_panic_safe);
Thierry Fournier670db242020-11-28 10:49:59 +01008598 return return_status;
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008599}
8600
Thierry Fournierb8cef172020-11-28 15:37:17 +01008601int hlua_post_init()
8602{
Thierry Fournier59f11be2020-11-29 00:37:41 +01008603 int ret;
8604 int i;
8605 int errors;
8606 char *err = NULL;
8607 struct hlua_function *fcn;
8608
Willy Tarreau42afc592021-08-30 09:35:18 +02008609#if defined(USE_OPENSSL)
Thierry Fournierb8cef172020-11-28 15:37:17 +01008610 /* Initialize SSL server. */
Amaury Denoyelle704ba1d2021-03-24 17:57:47 +01008611 if (socket_ssl->xprt->prepare_srv) {
Thierry Fournierb8cef172020-11-28 15:37:17 +01008612 int saved_used_backed = global.ssl_used_backend;
8613 // don't affect maxconn automatic computation
Amaury Denoyelle704ba1d2021-03-24 17:57:47 +01008614 socket_ssl->xprt->prepare_srv(socket_ssl);
Thierry Fournierb8cef172020-11-28 15:37:17 +01008615 global.ssl_used_backend = saved_used_backed;
8616 }
8617#endif
8618
Thierry Fournierc7492592020-11-28 23:57:24 +01008619 /* Perform post init of common thread */
8620 hlua_state_id = 0;
Thierry Fournier59f11be2020-11-29 00:37:41 +01008621 ha_set_tid(0);
8622 ret = hlua_post_init_state(hlua_states[hlua_state_id]);
8623 if (ret == 0)
8624 return 0;
8625
8626 /* init remaining lua states and load files */
8627 for (hlua_state_id = 2; hlua_state_id < global.nbthread + 1; hlua_state_id++) {
8628
8629 /* set thread context */
8630 ha_set_tid(hlua_state_id - 1);
8631
8632 /* Init lua state */
8633 hlua_states[hlua_state_id] = hlua_init_state(hlua_state_id);
8634
8635 /* Load lua files */
8636 for (i = 0; per_thread_load && per_thread_load[i]; i++) {
8637 ret = hlua_load_state(per_thread_load[i], hlua_states[hlua_state_id], &err);
8638 if (ret != 0) {
8639 ha_alert("Lua init: %s\n", err);
8640 return 0;
8641 }
8642 }
8643 }
8644
8645 /* Reset thread context */
8646 ha_set_tid(0);
8647
8648 /* Execute post init for all states */
8649 for (hlua_state_id = 1; hlua_state_id < global.nbthread + 1; hlua_state_id++) {
8650
8651 /* set thread context */
8652 ha_set_tid(hlua_state_id - 1);
8653
8654 /* run post init */
8655 ret = hlua_post_init_state(hlua_states[hlua_state_id]);
8656 if (ret == 0)
8657 return 0;
8658 }
8659
8660 /* Reset thread context */
8661 ha_set_tid(0);
8662
8663 /* control functions registering. Each function must have:
8664 * - only the function_ref[0] set positive and all other to -1
8665 * - only the function_ref[0] set to -1 and all other positive
8666 * This ensure a same reference is not used both in shared
8667 * lua state and thread dedicated lua state. Note: is the case
Ilya Shipitsinb8888ab2021-01-06 21:20:16 +05008668 * reach, the shared state is priority, but the bug will be
Thierry Fournier59f11be2020-11-29 00:37:41 +01008669 * complicated to found for the end user.
8670 */
8671 errors = 0;
8672 list_for_each_entry(fcn, &referenced_functions, l) {
8673 ret = 0;
8674 for (i = 1; i < global.nbthread + 1; i++) {
8675 if (fcn->function_ref[i] == -1)
8676 ret--;
8677 else
8678 ret++;
8679 }
8680 if (abs(ret) != global.nbthread) {
8681 ha_alert("Lua function '%s' is not referenced in all thread. "
8682 "Expect function in all thread or in none thread.\n", fcn->name);
8683 errors++;
8684 continue;
8685 }
8686
8687 if ((fcn->function_ref[0] == -1) == (ret < 0)) {
Ilya Shipitsinb8888ab2021-01-06 21:20:16 +05008688 ha_alert("Lua function '%s' is referenced both ins shared Lua context (through lua-load) "
8689 "and per-thread Lua context (through lua-load-per-thread). these two context "
Thierry Fournier59f11be2020-11-29 00:37:41 +01008690 "exclusive.\n", fcn->name);
8691 errors++;
8692 }
8693 }
8694
8695 if (errors > 0)
8696 return 0;
8697
Ilya Shipitsinb8888ab2021-01-06 21:20:16 +05008698 /* after this point, this global will no longer be used, so set to
Thierry Fournier59f11be2020-11-29 00:37:41 +01008699 * -1 in order to have probably a segfault if someone use it
8700 */
8701 hlua_state_id = -1;
8702
8703 return 1;
Thierry Fournierb8cef172020-11-28 15:37:17 +01008704}
8705
Willy Tarreau32f61e22015-03-18 17:54:59 +01008706/* The memory allocator used by the Lua stack. <ud> is a pointer to the
8707 * allocator's context. <ptr> is the pointer to alloc/free/realloc. <osize>
8708 * is the previously allocated size or the kind of object in case of a new
Willy Tarreaud36c7fa2020-12-02 12:26:29 +01008709 * allocation. <nsize> is the requested new size. A new allocation is
8710 * indicated by <ptr> being NULL. A free is indicated by <nsize> being
Willy Tarreaucdb53462020-12-02 12:12:00 +01008711 * zero. This one verifies that the limits are respected but is optimized
8712 * for the fast case where limits are not used, hence stats are not updated.
Willy Tarreaue00ad052021-10-22 16:00:02 +02008713 *
8714 * Warning: while this API ressembles glibc's realloc() a lot, glibc surpasses
8715 * POSIX by making realloc(ptr,0) an effective free(), but others do not do
8716 * that and will simply allocate zero as if it were the result of malloc(0),
8717 * so mapping this onto realloc() will lead to memory leaks on non-glibc
8718 * systems.
Willy Tarreau32f61e22015-03-18 17:54:59 +01008719 */
8720static void *hlua_alloc(void *ud, void *ptr, size_t osize, size_t nsize)
8721{
8722 struct hlua_mem_allocator *zone = ud;
Willy Tarreaucdb53462020-12-02 12:12:00 +01008723 size_t limit, old, new;
8724
Tim Duesterhus22586522021-01-08 10:35:33 +01008725 if (unlikely(!ptr && !nsize))
8726 return NULL;
8727
Willy Tarreaucdb53462020-12-02 12:12:00 +01008728 /* a limit of ~0 means unlimited and boot complete, so there's no need
8729 * for accounting anymore.
8730 */
Willy Tarreaue00ad052021-10-22 16:00:02 +02008731 if (likely(~zone->limit == 0)) {
8732 if (!nsize)
8733 ha_free(&ptr);
8734 else
8735 ptr = realloc(ptr, nsize);
8736 return ptr;
8737 }
Willy Tarreau32f61e22015-03-18 17:54:59 +01008738
Willy Tarreaud36c7fa2020-12-02 12:26:29 +01008739 if (!ptr)
8740 osize = 0;
Willy Tarreau32f61e22015-03-18 17:54:59 +01008741
Willy Tarreaucdb53462020-12-02 12:12:00 +01008742 /* enforce strict limits across all threads */
8743 limit = zone->limit;
8744 old = _HA_ATOMIC_LOAD(&zone->allocated);
8745 do {
8746 new = old + nsize - osize;
8747 if (unlikely(nsize && limit && new > limit))
8748 return NULL;
8749 } while (!_HA_ATOMIC_CAS(&zone->allocated, &old, new));
Willy Tarreau32f61e22015-03-18 17:54:59 +01008750
Willy Tarreaue00ad052021-10-22 16:00:02 +02008751 if (!nsize)
8752 ha_free(&ptr);
8753 else
8754 ptr = realloc(ptr, nsize);
Willy Tarreaucdb53462020-12-02 12:12:00 +01008755
8756 if (unlikely(!ptr && nsize)) // failed
8757 _HA_ATOMIC_SUB(&zone->allocated, nsize - osize);
8758
8759 __ha_barrier_atomic_store();
Willy Tarreau32f61e22015-03-18 17:54:59 +01008760 return ptr;
8761}
8762
Thierry Fournierecb83c22020-11-28 15:49:44 +01008763/* This function can fail with an abort() due to a Lua critical error.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02008764 * We are in the initialisation process of HAProxy, this abort() is
8765 * tolerated.
8766 */
Thierry Fournierecb83c22020-11-28 15:49:44 +01008767lua_State *hlua_init_state(int thread_num)
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +01008768{
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008769 int i;
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008770 int idx;
8771 struct sample_fetch *sf;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008772 struct sample_conv *sc;
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008773 char *p;
Thierry Fournierfd107a22016-02-19 19:57:23 +01008774 const char *error_msg;
Thierry Fournier4234dbd2020-11-28 13:18:23 +01008775 void **context;
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008776 lua_State *L;
Thierry Fournier59f11be2020-11-29 00:37:41 +01008777 struct prepend_path *pp;
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008778
Thierry FOURNIER380d0932015-01-23 14:27:52 +01008779 /* Init main lua stack. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008780 L = lua_newstate(hlua_alloc, &hlua_global_allocator);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01008781
Thierry Fournier4234dbd2020-11-28 13:18:23 +01008782 /* Initialise Lua context to NULL */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008783 context = lua_getextraspace(L);
Thierry Fournier4234dbd2020-11-28 13:18:23 +01008784 *context = NULL;
8785
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08008786 /* From this point, until the end of the initialisation function,
Thierry FOURNIERbabae282015-09-17 11:36:37 +02008787 * the Lua function can fail with an abort. We are in the initialisation
8788 * process of HAProxy, this abort() is tolerated.
8789 */
8790
Thierry Fournier3c539322020-11-28 16:05:05 +01008791 /* Call post initialisation function in safe environment. */
8792 if (setjmp(safe_ljmp_env) != 0) {
8793 lua_atpanic(L, hlua_panic_safe);
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008794 if (lua_type(L, -1) == LUA_TSTRING)
8795 error_msg = lua_tostring(L, -1);
Thierry Fournier2f05cc62020-11-28 16:08:02 +01008796 else
8797 error_msg = "critical error";
8798 fprintf(stderr, "Lua init: %s.\n", error_msg);
8799 exit(1);
Thierry Fournier3c539322020-11-28 16:05:05 +01008800 } else {
8801 lua_atpanic(L, hlua_panic_ljmp);
Thierry Fournier2f05cc62020-11-28 16:08:02 +01008802 }
8803
Thierry FOURNIER380d0932015-01-23 14:27:52 +01008804 /* Initialise lua. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008805 luaL_openlibs(L);
Tim Duesterhus541fe1e2020-01-12 13:55:41 +01008806#define HLUA_PREPEND_PATH_TOSTRING1(x) #x
8807#define HLUA_PREPEND_PATH_TOSTRING(x) HLUA_PREPEND_PATH_TOSTRING1(x)
8808#ifdef HLUA_PREPEND_PATH
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008809 hlua_prepend_path(L, "path", HLUA_PREPEND_PATH_TOSTRING(HLUA_PREPEND_PATH));
Tim Duesterhus541fe1e2020-01-12 13:55:41 +01008810#endif
8811#ifdef HLUA_PREPEND_CPATH
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008812 hlua_prepend_path(L, "cpath", HLUA_PREPEND_PATH_TOSTRING(HLUA_PREPEND_CPATH));
Tim Duesterhus541fe1e2020-01-12 13:55:41 +01008813#endif
8814#undef HLUA_PREPEND_PATH_TOSTRING
8815#undef HLUA_PREPEND_PATH_TOSTRING1
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008816
Thierry Fournier59f11be2020-11-29 00:37:41 +01008817 /* Apply configured prepend path */
8818 list_for_each_entry(pp, &prepend_path_list, l)
8819 hlua_prepend_path(L, pp->type, pp->path);
8820
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008821 /*
8822 *
8823 * Create "core" object.
8824 *
8825 */
8826
Thierry FOURNIERa2d8c652015-03-11 17:29:39 +01008827 /* This table entry is the object "core" base. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008828 lua_newtable(L);
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008829
Thierry Fournierecb83c22020-11-28 15:49:44 +01008830 /* set the thread id */
8831 hlua_class_const_int(L, "thread", thread_num);
8832
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008833 /* Push the loglevel constants. */
Willy Tarreau80f5fae2015-02-27 16:38:20 +01008834 for (i = 0; i < NB_LOG_LEVELS; i++)
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008835 hlua_class_const_int(L, log_levels[i], i);
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008836
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008837 /* Register special functions. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008838 hlua_class_function(L, "register_init", hlua_register_init);
8839 hlua_class_function(L, "register_task", hlua_register_task);
8840 hlua_class_function(L, "register_fetches", hlua_register_fetches);
8841 hlua_class_function(L, "register_converters", hlua_register_converters);
8842 hlua_class_function(L, "register_action", hlua_register_action);
8843 hlua_class_function(L, "register_service", hlua_register_service);
8844 hlua_class_function(L, "register_cli", hlua_register_cli);
8845 hlua_class_function(L, "yield", hlua_yield);
8846 hlua_class_function(L, "set_nice", hlua_set_nice);
8847 hlua_class_function(L, "sleep", hlua_sleep);
8848 hlua_class_function(L, "msleep", hlua_msleep);
8849 hlua_class_function(L, "add_acl", hlua_add_acl);
8850 hlua_class_function(L, "del_acl", hlua_del_acl);
8851 hlua_class_function(L, "set_map", hlua_set_map);
8852 hlua_class_function(L, "del_map", hlua_del_map);
8853 hlua_class_function(L, "tcp", hlua_socket_new);
8854 hlua_class_function(L, "log", hlua_log);
8855 hlua_class_function(L, "Debug", hlua_log_debug);
8856 hlua_class_function(L, "Info", hlua_log_info);
8857 hlua_class_function(L, "Warning", hlua_log_warning);
8858 hlua_class_function(L, "Alert", hlua_log_alert);
8859 hlua_class_function(L, "done", hlua_done);
8860 hlua_fcn_reg_core_fcn(L);
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008861
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008862 lua_setglobal(L, "core");
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01008863
8864 /*
8865 *
Christopher Faulet0f3c8902020-01-31 18:57:12 +01008866 * Create "act" object.
8867 *
8868 */
8869
8870 /* This table entry is the object "act" base. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008871 lua_newtable(L);
Christopher Faulet0f3c8902020-01-31 18:57:12 +01008872
8873 /* push action return constants */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008874 hlua_class_const_int(L, "CONTINUE", ACT_RET_CONT);
8875 hlua_class_const_int(L, "STOP", ACT_RET_STOP);
8876 hlua_class_const_int(L, "YIELD", ACT_RET_YIELD);
8877 hlua_class_const_int(L, "ERROR", ACT_RET_ERR);
8878 hlua_class_const_int(L, "DONE", ACT_RET_DONE);
8879 hlua_class_const_int(L, "DENY", ACT_RET_DENY);
8880 hlua_class_const_int(L, "ABORT", ACT_RET_ABRT);
8881 hlua_class_const_int(L, "INVALID", ACT_RET_INV);
Christopher Faulet0f3c8902020-01-31 18:57:12 +01008882
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008883 hlua_class_function(L, "wake_time", hlua_set_wake_time);
Christopher Faulet2c2c2e32020-01-31 19:07:52 +01008884
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008885 lua_setglobal(L, "act");
Christopher Faulet0f3c8902020-01-31 18:57:12 +01008886
8887 /*
8888 *
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008889 * Register class Map
8890 *
8891 */
8892
8893 /* This table entry is the object "Map" base. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008894 lua_newtable(L);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008895
8896 /* register pattern types. */
8897 for (i=0; i<PAT_MATCH_NUM; i++)
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008898 hlua_class_const_int(L, pat_match_names[i], i);
Thierry FOURNIER4dc71972017-01-28 08:33:08 +01008899 for (i=0; i<PAT_MATCH_NUM; i++) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008900 snprintf(trash.area, trash.size, "_%s", pat_match_names[i]);
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008901 hlua_class_const_int(L, trash.area, i);
Thierry FOURNIER4dc71972017-01-28 08:33:08 +01008902 }
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008903
8904 /* register constructor. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008905 hlua_class_function(L, "new", hlua_map_new);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008906
8907 /* Create and fill the metatable. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008908 lua_newtable(L);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008909
Ilya Shipitsind4259502020-04-08 01:07:56 +05008910 /* Create and fill the __index entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008911 lua_pushstring(L, "__index");
8912 lua_newtable(L);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008913
8914 /* Register . */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008915 hlua_class_function(L, "lookup", hlua_map_lookup);
8916 hlua_class_function(L, "slookup", hlua_map_slookup);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008917
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008918 lua_rawset(L, -3);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008919
Thierry Fournier45e78d72016-02-19 18:34:46 +01008920 /* Register previous table in the registry with reference and named entry.
8921 * The function hlua_register_metatable() pops the stack, so we
8922 * previously create a copy of the table.
8923 */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008924 lua_pushvalue(L, -1); /* Copy the -1 entry and push it on the stack. */
8925 class_map_ref = hlua_register_metatable(L, CLASS_MAP);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008926
8927 /* Assign the metatable to the mai Map object. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008928 lua_setmetatable(L, -2);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008929
8930 /* Set a name to the table. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008931 lua_setglobal(L, "Map");
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008932
8933 /*
8934 *
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008935 * Register class Channel
8936 *
8937 */
8938
8939 /* Create and fill the metatable. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008940 lua_newtable(L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008941
Ilya Shipitsind4259502020-04-08 01:07:56 +05008942 /* Create and fill the __index entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008943 lua_pushstring(L, "__index");
8944 lua_newtable(L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008945
8946 /* Register . */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008947 hlua_class_function(L, "get", hlua_channel_get);
8948 hlua_class_function(L, "dup", hlua_channel_dup);
8949 hlua_class_function(L, "getline", hlua_channel_getline);
8950 hlua_class_function(L, "set", hlua_channel_set);
8951 hlua_class_function(L, "append", hlua_channel_append);
8952 hlua_class_function(L, "send", hlua_channel_send);
8953 hlua_class_function(L, "forward", hlua_channel_forward);
8954 hlua_class_function(L, "get_in_len", hlua_channel_get_in_len);
8955 hlua_class_function(L, "get_out_len", hlua_channel_get_out_len);
8956 hlua_class_function(L, "is_full", hlua_channel_is_full);
8957 hlua_class_function(L, "is_resp", hlua_channel_is_resp);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008958
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008959 lua_rawset(L, -3);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008960
8961 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008962 class_channel_ref = hlua_register_metatable(L, CLASS_CHANNEL);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008963
8964 /*
8965 *
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01008966 * Register class Fetches
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01008967 *
8968 */
8969
8970 /* Create and fill the metatable. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008971 lua_newtable(L);
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01008972
Ilya Shipitsind4259502020-04-08 01:07:56 +05008973 /* Create and fill the __index entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008974 lua_pushstring(L, "__index");
8975 lua_newtable(L);
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01008976
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008977 /* Browse existing fetches and create the associated
8978 * object method.
8979 */
8980 sf = NULL;
8981 while ((sf = sample_fetch_getnext(sf, &idx)) != NULL) {
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008982 /* gL.Tua doesn't support '.' and '-' in the function names, replace it
8983 * by an underscore.
8984 */
Willy Tarreaufa92f362021-08-26 16:48:53 +02008985 strlcpy2(trash.area, sf->kw, trash.size);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008986 for (p = trash.area; *p; p++)
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008987 if (*p == '.' || *p == '-' || *p == '+')
8988 *p = '_';
8989
8990 /* Register the function. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008991 lua_pushstring(L, trash.area);
8992 lua_pushlightuserdata(L, sf);
8993 lua_pushcclosure(L, hlua_run_sample_fetch, 1);
8994 lua_rawset(L, -3);
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008995 }
8996
Thierry Fournier1eac28f2020-11-28 12:26:24 +01008997 lua_rawset(L, -3);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01008998
8999 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009000 class_fetches_ref = hlua_register_metatable(L, CLASS_FETCHES);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01009001
9002 /*
9003 *
Thierry FOURNIER594afe72015-03-10 23:58:30 +01009004 * Register class Converters
9005 *
9006 */
9007
9008 /* Create and fill the metatable. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009009 lua_newtable(L);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01009010
9011 /* Create and fill the __index entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009012 lua_pushstring(L, "__index");
9013 lua_newtable(L);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01009014
9015 /* Browse existing converters and create the associated
9016 * object method.
9017 */
9018 sc = NULL;
9019 while ((sc = sample_conv_getnext(sc, &idx)) != NULL) {
Thierry FOURNIER594afe72015-03-10 23:58:30 +01009020 /* gL.Tua doesn't support '.' and '-' in the function names, replace it
9021 * by an underscore.
9022 */
Willy Tarreaufa92f362021-08-26 16:48:53 +02009023 strlcpy2(trash.area, sc->kw, trash.size);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02009024 for (p = trash.area; *p; p++)
Thierry FOURNIER594afe72015-03-10 23:58:30 +01009025 if (*p == '.' || *p == '-' || *p == '+')
9026 *p = '_';
9027
9028 /* Register the function. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009029 lua_pushstring(L, trash.area);
9030 lua_pushlightuserdata(L, sc);
9031 lua_pushcclosure(L, hlua_run_sample_conv, 1);
9032 lua_rawset(L, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01009033 }
9034
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009035 lua_rawset(L, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01009036
9037 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009038 class_converters_ref = hlua_register_metatable(L, CLASS_CONVERTERS);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01009039
9040 /*
9041 *
Thierry FOURNIER08504f42015-03-16 14:17:08 +01009042 * Register class HTTP
9043 *
9044 */
9045
9046 /* Create and fill the metatable. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009047 lua_newtable(L);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01009048
Ilya Shipitsind4259502020-04-08 01:07:56 +05009049 /* Create and fill the __index entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009050 lua_pushstring(L, "__index");
9051 lua_newtable(L);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01009052
9053 /* Register Lua functions. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009054 hlua_class_function(L, "req_get_headers",hlua_http_req_get_headers);
9055 hlua_class_function(L, "req_del_header", hlua_http_req_del_hdr);
9056 hlua_class_function(L, "req_rep_header", hlua_http_req_rep_hdr);
9057 hlua_class_function(L, "req_rep_value", hlua_http_req_rep_val);
9058 hlua_class_function(L, "req_add_header", hlua_http_req_add_hdr);
9059 hlua_class_function(L, "req_set_header", hlua_http_req_set_hdr);
9060 hlua_class_function(L, "req_set_method", hlua_http_req_set_meth);
9061 hlua_class_function(L, "req_set_path", hlua_http_req_set_path);
9062 hlua_class_function(L, "req_set_query", hlua_http_req_set_query);
9063 hlua_class_function(L, "req_set_uri", hlua_http_req_set_uri);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01009064
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009065 hlua_class_function(L, "res_get_headers",hlua_http_res_get_headers);
9066 hlua_class_function(L, "res_del_header", hlua_http_res_del_hdr);
9067 hlua_class_function(L, "res_rep_header", hlua_http_res_rep_hdr);
9068 hlua_class_function(L, "res_rep_value", hlua_http_res_rep_val);
9069 hlua_class_function(L, "res_add_header", hlua_http_res_add_hdr);
9070 hlua_class_function(L, "res_set_header", hlua_http_res_set_hdr);
9071 hlua_class_function(L, "res_set_status", hlua_http_res_set_status);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01009072
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009073 lua_rawset(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01009074
9075 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009076 class_http_ref = hlua_register_metatable(L, CLASS_HTTP);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01009077
9078 /*
9079 *
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02009080 * Register class AppletTCP
9081 *
9082 */
9083
9084 /* Create and fill the metatable. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009085 lua_newtable(L);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02009086
Ilya Shipitsind4259502020-04-08 01:07:56 +05009087 /* Create and fill the __index entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009088 lua_pushstring(L, "__index");
9089 lua_newtable(L);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02009090
9091 /* Register Lua functions. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009092 hlua_class_function(L, "getline", hlua_applet_tcp_getline);
9093 hlua_class_function(L, "receive", hlua_applet_tcp_recv);
9094 hlua_class_function(L, "send", hlua_applet_tcp_send);
9095 hlua_class_function(L, "set_priv", hlua_applet_tcp_set_priv);
9096 hlua_class_function(L, "get_priv", hlua_applet_tcp_get_priv);
9097 hlua_class_function(L, "set_var", hlua_applet_tcp_set_var);
9098 hlua_class_function(L, "unset_var", hlua_applet_tcp_unset_var);
9099 hlua_class_function(L, "get_var", hlua_applet_tcp_get_var);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02009100
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009101 lua_settable(L, -3);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02009102
9103 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009104 class_applet_tcp_ref = hlua_register_metatable(L, CLASS_APPLET_TCP);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02009105
9106 /*
9107 *
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02009108 * Register class AppletHTTP
9109 *
9110 */
9111
9112 /* Create and fill the metatable. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009113 lua_newtable(L);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02009114
Ilya Shipitsind4259502020-04-08 01:07:56 +05009115 /* Create and fill the __index entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009116 lua_pushstring(L, "__index");
9117 lua_newtable(L);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02009118
9119 /* Register Lua functions. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009120 hlua_class_function(L, "set_priv", hlua_applet_http_set_priv);
9121 hlua_class_function(L, "get_priv", hlua_applet_http_get_priv);
9122 hlua_class_function(L, "set_var", hlua_applet_http_set_var);
9123 hlua_class_function(L, "unset_var", hlua_applet_http_unset_var);
9124 hlua_class_function(L, "get_var", hlua_applet_http_get_var);
9125 hlua_class_function(L, "getline", hlua_applet_http_getline);
9126 hlua_class_function(L, "receive", hlua_applet_http_recv);
9127 hlua_class_function(L, "send", hlua_applet_http_send);
9128 hlua_class_function(L, "add_header", hlua_applet_http_addheader);
9129 hlua_class_function(L, "set_status", hlua_applet_http_status);
9130 hlua_class_function(L, "start_response", hlua_applet_http_start_response);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02009131
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009132 lua_settable(L, -3);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02009133
9134 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009135 class_applet_http_ref = hlua_register_metatable(L, CLASS_APPLET_HTTP);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02009136
9137 /*
9138 *
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01009139 * Register class TXN
9140 *
9141 */
9142
9143 /* Create and fill the metatable. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009144 lua_newtable(L);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01009145
Ilya Shipitsind4259502020-04-08 01:07:56 +05009146 /* Create and fill the __index entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009147 lua_pushstring(L, "__index");
9148 lua_newtable(L);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01009149
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01009150 /* Register Lua functions. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009151 hlua_class_function(L, "set_priv", hlua_set_priv);
9152 hlua_class_function(L, "get_priv", hlua_get_priv);
9153 hlua_class_function(L, "set_var", hlua_set_var);
9154 hlua_class_function(L, "unset_var", hlua_unset_var);
9155 hlua_class_function(L, "get_var", hlua_get_var);
9156 hlua_class_function(L, "done", hlua_txn_done);
9157 hlua_class_function(L, "reply", hlua_txn_reply_new);
9158 hlua_class_function(L, "set_loglevel", hlua_txn_set_loglevel);
9159 hlua_class_function(L, "set_tos", hlua_txn_set_tos);
9160 hlua_class_function(L, "set_mark", hlua_txn_set_mark);
9161 hlua_class_function(L, "set_priority_class", hlua_txn_set_priority_class);
9162 hlua_class_function(L, "set_priority_offset", hlua_txn_set_priority_offset);
9163 hlua_class_function(L, "deflog", hlua_txn_deflog);
9164 hlua_class_function(L, "log", hlua_txn_log);
9165 hlua_class_function(L, "Debug", hlua_txn_log_debug);
9166 hlua_class_function(L, "Info", hlua_txn_log_info);
9167 hlua_class_function(L, "Warning", hlua_txn_log_warning);
9168 hlua_class_function(L, "Alert", hlua_txn_log_alert);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01009169
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009170 lua_rawset(L, -3);
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01009171
9172 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009173 class_txn_ref = hlua_register_metatable(L, CLASS_TXN);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009174
9175 /*
9176 *
Christopher Faulet700d9e82020-01-31 12:21:52 +01009177 * Register class reply
9178 *
9179 */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009180 lua_newtable(L);
9181 lua_pushstring(L, "__index");
9182 lua_newtable(L);
9183 hlua_class_function(L, "set_status", hlua_txn_reply_set_status);
9184 hlua_class_function(L, "add_header", hlua_txn_reply_add_header);
9185 hlua_class_function(L, "del_header", hlua_txn_reply_del_header);
9186 hlua_class_function(L, "set_body", hlua_txn_reply_set_body);
9187 lua_settable(L, -3); /* Sets the __index entry. */
9188 class_txn_reply_ref = luaL_ref(L, LUA_REGISTRYINDEX);
Christopher Faulet700d9e82020-01-31 12:21:52 +01009189
9190
9191 /*
9192 *
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009193 * Register class Socket
9194 *
9195 */
9196
9197 /* Create and fill the metatable. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009198 lua_newtable(L);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009199
Ilya Shipitsind4259502020-04-08 01:07:56 +05009200 /* Create and fill the __index entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009201 lua_pushstring(L, "__index");
9202 lua_newtable(L);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009203
Baptiste Assmann84bb4932015-03-02 21:40:06 +01009204#ifdef USE_OPENSSL
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009205 hlua_class_function(L, "connect_ssl", hlua_socket_connect_ssl);
Baptiste Assmann84bb4932015-03-02 21:40:06 +01009206#endif
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009207 hlua_class_function(L, "connect", hlua_socket_connect);
9208 hlua_class_function(L, "send", hlua_socket_send);
9209 hlua_class_function(L, "receive", hlua_socket_receive);
9210 hlua_class_function(L, "close", hlua_socket_close);
9211 hlua_class_function(L, "getpeername", hlua_socket_getpeername);
9212 hlua_class_function(L, "getsockname", hlua_socket_getsockname);
9213 hlua_class_function(L, "setoption", hlua_socket_setoption);
9214 hlua_class_function(L, "settimeout", hlua_socket_settimeout);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009215
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009216 lua_rawset(L, -3); /* Push the last 2 entries in the table at index -3 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009217
9218 /* Register the garbage collector entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009219 lua_pushstring(L, "__gc");
9220 lua_pushcclosure(L, hlua_socket_gc, 0);
9221 lua_rawset(L, -3); /* Push the last 2 entries in the table at index -3 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009222
9223 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier1eac28f2020-11-28 12:26:24 +01009224 class_socket_ref = hlua_register_metatable(L, CLASS_SOCKET);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009225
Thierry Fournieraafc7772020-12-04 11:47:47 +01009226 lua_atpanic(L, hlua_panic_safe);
9227
9228 return L;
9229}
9230
9231void hlua_init(void) {
9232 int i;
Amaury Denoyelle239fdbf2021-03-24 10:22:03 +01009233 char *errmsg;
Thierry Fournieraafc7772020-12-04 11:47:47 +01009234#ifdef USE_OPENSSL
9235 struct srv_kw *kw;
9236 int tmp_error;
9237 char *error;
9238 char *args[] = { /* SSL client configuration. */
9239 "ssl",
9240 "verify",
9241 "none",
9242 NULL
9243 };
9244#endif
9245
9246 /* Init post init function list head */
9247 for (i = 0; i < MAX_THREADS + 1; i++)
9248 LIST_INIT(&hlua_init_functions[i]);
9249
9250 /* Init state for common/shared lua parts */
9251 hlua_state_id = 0;
9252 ha_set_tid(0);
9253 hlua_states[0] = hlua_init_state(0);
9254
9255 /* Init state 1 for thread 0. We have at least one thread. */
9256 hlua_state_id = 1;
9257 ha_set_tid(0);
9258 hlua_states[1] = hlua_init_state(1);
9259
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009260 /* Proxy and server configuration initialisation. */
Amaury Denoyelle239fdbf2021-03-24 10:22:03 +01009261 socket_proxy = alloc_new_proxy("LUA-SOCKET", PR_CAP_FE|PR_CAP_BE|PR_CAP_LUA, &errmsg);
9262 if (!socket_proxy) {
9263 fprintf(stderr, "Lua init: %s\n", errmsg);
9264 exit(1);
9265 }
9266 proxy_preset_defaults(socket_proxy);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009267
9268 /* Init TCP server: unchanged parameters */
Amaury Denoyelle704ba1d2021-03-24 17:57:47 +01009269 socket_tcp = new_server(socket_proxy);
9270 if (!socket_tcp) {
9271 fprintf(stderr, "Lua init: failed to allocate tcp server socket\n");
9272 exit(1);
9273 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009274
9275#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009276 /* Init TCP server: unchanged parameters */
Amaury Denoyelle704ba1d2021-03-24 17:57:47 +01009277 socket_ssl = new_server(socket_proxy);
9278 if (!socket_ssl) {
9279 fprintf(stderr, "Lua init: failed to allocate ssl server socket\n");
9280 exit(1);
9281 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009282
Amaury Denoyelle704ba1d2021-03-24 17:57:47 +01009283 socket_ssl->use_ssl = 1;
9284 socket_ssl->xprt = xprt_get(XPRT_SSL);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009285
Bertrand Jacquin80839ff2021-01-21 19:14:46 +00009286 for (i = 0; args[i] != NULL; i++) {
9287 if ((kw = srv_find_kw(args[i])) != NULL) { /* Maybe it's registered server keyword */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009288 /*
9289 *
9290 * If the keyword is not known, we can search in the registered
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08009291 * server keywords. This is useful to configure special SSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009292 * features like client certificates and ssl_verify.
9293 *
9294 */
Amaury Denoyelle704ba1d2021-03-24 17:57:47 +01009295 tmp_error = kw->parse(args, &i, socket_proxy, socket_ssl, &error);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009296 if (tmp_error != 0) {
9297 fprintf(stderr, "INTERNAL ERROR: %s\n", error);
9298 abort(); /* This must be never arrives because the command line
9299 not editable by the user. */
9300 }
Bertrand Jacquin80839ff2021-01-21 19:14:46 +00009301 i += kw->skip;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009302 }
9303 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01009304#endif
Thierry Fournier75933d42016-01-21 09:30:18 +01009305
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +01009306}
Willy Tarreaubb57d942016-12-21 19:04:56 +01009307
Tim Duesterhusd0c0ca22020-07-04 11:53:26 +02009308static void hlua_deinit()
9309{
Willy Tarreau186f3762020-12-04 11:48:12 +01009310 int thr;
9311
9312 for (thr = 0; thr < MAX_THREADS+1; thr++) {
9313 if (hlua_states[thr])
9314 lua_close(hlua_states[thr]);
9315 }
Willy Tarreau430bf4a2021-03-04 09:45:32 +01009316
Amaury Denoyelle704ba1d2021-03-24 17:57:47 +01009317 free_server(socket_tcp);
Willy Tarreau430bf4a2021-03-04 09:45:32 +01009318
Willy Tarreau0f143af2021-03-05 10:41:48 +01009319#ifdef USE_OPENSSL
Amaury Denoyelle704ba1d2021-03-24 17:57:47 +01009320 free_server(socket_ssl);
Willy Tarreau0f143af2021-03-05 10:41:48 +01009321#endif
Amaury Denoyelle239fdbf2021-03-24 10:22:03 +01009322
9323 free_proxy(socket_proxy);
Tim Duesterhusd0c0ca22020-07-04 11:53:26 +02009324}
9325
9326REGISTER_POST_DEINIT(hlua_deinit);
9327
Willy Tarreau80713382018-11-26 10:19:54 +01009328static void hlua_register_build_options(void)
9329{
Willy Tarreaubb57d942016-12-21 19:04:56 +01009330 char *ptr = NULL;
Willy Tarreau80713382018-11-26 10:19:54 +01009331
Willy Tarreaubb57d942016-12-21 19:04:56 +01009332 memprintf(&ptr, "Built with Lua version : %s", LUA_RELEASE);
9333 hap_register_build_opts(ptr, 1);
9334}
Willy Tarreau80713382018-11-26 10:19:54 +01009335
9336INITCALL0(STG_REGISTER, hlua_register_build_options);