blob: 491bc93260c9eb270023c66d964de314f8d71035 [file] [log] [blame]
Thierry Fourniere726b142016-02-11 17:57:57 +01001/*
2 * Lua unsafe core engine
3 *
4 * Copyright 2015-2016 Thierry Fournier <tfournier@arpalert.org>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +010013#include <ctype.h>
Thierry FOURNIERbabae282015-09-17 11:36:37 +020014#include <setjmp.h>
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +010015
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +010016#include <lauxlib.h>
17#include <lua.h>
18#include <lualib.h>
19
Thierry FOURNIER463119c2015-03-10 00:35:36 +010020#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 503
21#error "Requires Lua 5.3 or later."
Cyril Bontédc0306e2015-03-02 00:08:40 +010022#endif
23
Willy Tarreau8d2b7772020-05-27 10:58:19 +020024#include <import/ebpttree.h>
Thierry FOURNIER380d0932015-01-23 14:27:52 +010025
Willy Tarreaub2551052020-06-09 09:07:15 +020026#include <haproxy/api.h>
27#include <haproxy/applet.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020028#include <haproxy/arg.h>
Christopher Fauletd25d9262020-08-06 11:04:46 +020029#include <haproxy/auth.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020030#include <haproxy/cfgparse.h>
Willy Tarreauf1d32c42020-06-04 21:07:02 +020031#include <haproxy/channel.h>
Willy Tarreau83487a82020-06-04 20:19:54 +020032#include <haproxy/cli.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020033#include <haproxy/connection.h>
Willy Tarreau5413a872020-06-02 19:33:08 +020034#include <haproxy/h1.h>
Willy Tarreau86416052020-06-04 09:20:54 +020035#include <haproxy/hlua.h>
Willy Tarreau8c794002020-06-04 10:05:25 +020036#include <haproxy/hlua_fcn.h>
Willy Tarreauc2b1ff02020-06-04 21:21:03 +020037#include <haproxy/http_ana.h>
Willy Tarreau126ba3a2020-06-04 18:26:43 +020038#include <haproxy/http_fetch.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020039#include <haproxy/http_htx.h>
Willy Tarreauc761f842020-06-04 11:40:28 +020040#include <haproxy/http_rules.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020041#include <haproxy/log.h>
Willy Tarreau2cd58092020-06-04 15:10:43 +020042#include <haproxy/map.h>
Willy Tarreau8efbdfb2020-06-04 11:29:21 +020043#include <haproxy/obj_type.h>
Willy Tarreau225a90a2020-06-04 15:06:28 +020044#include <haproxy/pattern.h>
Willy Tarreau469509b2020-06-04 15:13:30 +020045#include <haproxy/payload.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020046#include <haproxy/proxy-t.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020047#include <haproxy/regex.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020048#include <haproxy/sample.h>
Willy Tarreau1e56f922020-06-04 23:20:13 +020049#include <haproxy/server-t.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020050#include <haproxy/session.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020051#include <haproxy/stats-t.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020052#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020053#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020054#include <haproxy/task.h>
Willy Tarreau8b550af2020-06-04 17:42:48 +020055#include <haproxy/tcp_rules.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020056#include <haproxy/thread.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020057#include <haproxy/tools.h>
Willy Tarreaua1718922020-06-04 16:25:31 +020058#include <haproxy/vars.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020059#include <haproxy/xref.h>
60
Thierry FOURNIER380d0932015-01-23 14:27:52 +010061
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +010062/* Lua uses longjmp to perform yield or throwing errors. This
63 * macro is used only for identifying the function that can
64 * not return because a longjmp is executed.
65 * __LJMP marks a prototype of hlua file that can use longjmp.
66 * WILL_LJMP() marks an lua function that will use longjmp.
67 * MAY_LJMP() marks an lua function that may use longjmp.
68 */
69#define __LJMP
Willy Tarreau4e7cc332018-10-20 17:45:48 +020070#define WILL_LJMP(func) do { func; my_unreachable(); } while(0)
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +010071#define MAY_LJMP(func) func
72
Thierry FOURNIERbabae282015-09-17 11:36:37 +020073/* This couple of function executes securely some Lua calls outside of
74 * the lua runtime environment. Each Lua call can return a longjmp
75 * if it encounter a memory error.
76 *
77 * Lua documentation extract:
78 *
79 * If an error happens outside any protected environment, Lua calls
80 * a panic function (see lua_atpanic) and then calls abort, thus
81 * exiting the host application. Your panic function can avoid this
82 * exit by never returning (e.g., doing a long jump to your own
83 * recovery point outside Lua).
84 *
85 * The panic function runs as if it were a message handler (see
86 * §2.3); in particular, the error message is at the top of the
87 * stack. However, there is no guarantee about stack space. To push
88 * anything on the stack, the panic function must first check the
89 * available space (see §4.2).
90 *
91 * We must check all the Lua entry point. This includes:
92 * - The include/proto/hlua.h exported functions
93 * - the task wrapper function
94 * - The action wrapper function
95 * - The converters wrapper function
96 * - The sample-fetch wrapper functions
97 *
Ilya Shipitsin46a030c2020-07-05 16:36:08 +050098 * It is tolerated that the initialisation function returns an abort.
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -080099 * Before each Lua abort, an error message is written on stderr.
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200100 *
101 * The macro SET_SAFE_LJMP initialise the longjmp. The Macro
102 * RESET_SAFE_LJMP reset the longjmp. These function must be macro
103 * because they must be exists in the program stack when the longjmp
104 * is called.
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +0200105 *
106 * Note that the Lua processing is not really thread safe. It provides
107 * heavy system which consists to add our own lock function in the Lua
108 * code and recompile the library. This system will probably not accepted
109 * by maintainers of various distribs.
110 *
Ilya Shipitsin856aabc2020-04-16 23:51:34 +0500111 * Our main execution point of the Lua is the function lua_resume(). A
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +0200112 * quick looking on the Lua sources displays a lua_lock() a the start
113 * of function and a lua_unlock() at the end of the function. So I
114 * conclude that the Lua thread safe mode just perform a mutex around
115 * all execution. So I prefer to do this in the HAProxy code, it will be
116 * easier for distro maintainers.
117 *
118 * Note that the HAProxy lua functions rounded by the macro SET_SAFE_LJMP
119 * and RESET_SAFE_LJMP manipulates the Lua stack, so it will be careful
120 * to set mutex around these functions.
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200121 */
Willy Tarreau86abe442018-11-25 20:12:18 +0100122__decl_spinlock(hlua_global_lock);
Thierry FOURNIERffbad792017-07-12 11:39:04 +0200123THREAD_LOCAL jmp_buf safe_ljmp_env;
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200124static int hlua_panic_safe(lua_State *L) { return 0; }
Willy Tarreau9d6bb5a2020-02-06 15:55:41 +0100125static int hlua_panic_ljmp(lua_State *L) { WILL_LJMP(longjmp(safe_ljmp_env, 1)); }
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200126
127#define SET_SAFE_LJMP(__L) \
128 ({ \
129 int ret; \
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100130 HA_SPIN_LOCK(LUA_LOCK, &hlua_global_lock); \
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200131 if (setjmp(safe_ljmp_env) != 0) { \
132 lua_atpanic(__L, hlua_panic_safe); \
133 ret = 0; \
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100134 HA_SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock); \
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200135 } else { \
136 lua_atpanic(__L, hlua_panic_ljmp); \
137 ret = 1; \
138 } \
139 ret; \
140 })
141
142/* If we are the last function catching Lua errors, we
143 * must reset the panic function.
144 */
145#define RESET_SAFE_LJMP(__L) \
146 do { \
147 lua_atpanic(__L, hlua_panic_safe); \
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100148 HA_SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock); \
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200149 } while(0)
150
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200151/* Applet status flags */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200152#define APPLET_DONE 0x01 /* applet processing is done. */
Christopher Faulet18c2e8d2019-03-01 12:02:08 +0100153/* unused: 0x02 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200154#define APPLET_HDR_SENT 0x04 /* Response header sent. */
Christopher Fauleta2097962019-07-15 16:25:33 +0200155/* unused: 0x08, 0x10 */
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +0100156#define APPLET_HTTP11 0x20 /* Last chunk sent. */
Christopher Faulet56a3d6e2019-02-27 22:06:23 +0100157#define APPLET_RSP_SENT 0x40 /* The response was fully sent */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200158
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100159/* The main Lua execution context. */
160struct hlua gL;
161
Thierry FOURNIERebed6e92016-12-16 11:54:07 +0100162/* This is the memory pool containing struct lua for applets
163 * (including cli).
164 */
Willy Tarreau8ceae722018-11-26 11:58:30 +0100165DECLARE_STATIC_POOL(pool_head_hlua, "hlua", sizeof(struct hlua));
Thierry FOURNIERebed6e92016-12-16 11:54:07 +0100166
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +0100167/* Used for Socket connection. */
168static struct proxy socket_proxy;
169static struct server socket_tcp;
170#ifdef USE_OPENSSL
171static struct server socket_ssl;
172#endif
173
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +0100174/* List head of the function called at the initialisation time. */
175struct list hlua_init_functions = LIST_HEAD_INIT(hlua_init_functions);
176
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +0100177/* The following variables contains the reference of the different
178 * Lua classes. These references are useful for identify metadata
179 * associated with an object.
180 */
Thierry FOURNIER65f34c62015-02-16 20:11:43 +0100181static int class_txn_ref;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +0100182static int class_socket_ref;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +0100183static int class_channel_ref;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +0100184static int class_fetches_ref;
Thierry FOURNIER594afe72015-03-10 23:58:30 +0100185static int class_converters_ref;
Thierry FOURNIER08504f42015-03-16 14:17:08 +0100186static int class_http_ref;
Thierry FOURNIER3def3932015-04-07 11:27:54 +0200187static int class_map_ref;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200188static int class_applet_tcp_ref;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200189static int class_applet_http_ref;
Christopher Faulet700d9e82020-01-31 12:21:52 +0100190static int class_txn_reply_ref;
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +0100191
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100192/* Global Lua execution timeout. By default Lua, execution linked
Willy Tarreau87b09662015-04-03 00:22:06 +0200193 * with stream (actions, sample-fetches and converters) have a
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100194 * short timeout. Lua linked with tasks doesn't have a timeout
195 * because a task may remain alive during all the haproxy execution.
196 */
197static unsigned int hlua_timeout_session = 4000; /* session timeout. */
198static unsigned int hlua_timeout_task = TICK_ETERNITY; /* task timeout. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200199static unsigned int hlua_timeout_applet = 4000; /* applet timeout. */
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100200
Thierry FOURNIERee9f8022015-03-03 17:37:37 +0100201/* Interrupts the Lua processing each "hlua_nb_instruction" instructions.
202 * it is used for preventing infinite loops.
203 *
204 * I test the scheer with an infinite loop containing one incrementation
205 * and one test. I run this loop between 10 seconds, I raise a ceil of
206 * 710M loops from one interrupt each 9000 instructions, so I fix the value
207 * to one interrupt each 10 000 instructions.
208 *
209 * configured | Number of
210 * instructions | loops executed
211 * between two | in milions
212 * forced yields |
213 * ---------------+---------------
214 * 10 | 160
215 * 500 | 670
216 * 1000 | 680
217 * 5000 | 700
218 * 7000 | 700
219 * 8000 | 700
220 * 9000 | 710 <- ceil
221 * 10000 | 710
222 * 100000 | 710
223 * 1000000 | 710
224 *
225 */
226static unsigned int hlua_nb_instruction = 10000;
227
Willy Tarreau32f61e22015-03-18 17:54:59 +0100228/* Descriptor for the memory allocation state. If limit is not null, it will
229 * be enforced on any memory allocation.
230 */
231struct hlua_mem_allocator {
232 size_t allocated;
233 size_t limit;
234};
235
236static struct hlua_mem_allocator hlua_global_allocator;
237
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100238/* These functions converts types between HAProxy internal args or
239 * sample and LUA types. Another function permits to check if the
240 * LUA stack contains arguments according with an required ARG_T
241 * format.
242 */
243static int hlua_arg2lua(lua_State *L, const struct arg *arg);
244static int hlua_lua2arg(lua_State *L, int ud, struct arg *arg);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100245__LJMP static int hlua_lua2arg_check(lua_State *L, int first, struct arg *argp,
David Carlier0c437f42016-04-27 16:21:56 +0100246 uint64_t mask, struct proxy *p);
Willy Tarreau5eadada2015-03-10 17:28:54 +0100247static int hlua_smp2lua(lua_State *L, struct sample *smp);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100248static int hlua_smp2lua_str(lua_State *L, struct sample *smp);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100249static int hlua_lua2smp(lua_State *L, int ud, struct sample *smp);
250
Christopher Faulet9d1332b2020-02-24 16:46:16 +0100251__LJMP static int hlua_http_get_headers(lua_State *L, struct http_msg *msg);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200252
Thierry FOURNIER23bc3752015-09-11 19:15:43 +0200253#define SEND_ERR(__be, __fmt, __args...) \
254 do { \
255 send_log(__be, LOG_ERR, __fmt, ## __args); \
256 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) \
Christopher Faulet767a84b2017-11-24 16:50:31 +0100257 ha_alert(__fmt, ## __args); \
Thierry FOURNIER23bc3752015-09-11 19:15:43 +0200258 } while (0)
259
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100260/* Used to check an Lua function type in the stack. It creates and
261 * returns a reference of the function. This function throws an
262 * error if the rgument is not a "function".
263 */
264__LJMP unsigned int hlua_checkfunction(lua_State *L, int argno)
265{
266 if (!lua_isfunction(L, argno)) {
Thierry FOURNIERfd1e9552018-02-23 18:41:18 +0100267 const char *msg = lua_pushfstring(L, "function expected, got %s", luaL_typename(L, argno));
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100268 WILL_LJMP(luaL_argerror(L, argno, msg));
269 }
270 lua_pushvalue(L, argno);
271 return luaL_ref(L, LUA_REGISTRYINDEX);
272}
273
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200274/* Return the string that is of the top of the stack. */
275const char *hlua_get_top_error_string(lua_State *L)
276{
277 if (lua_gettop(L) < 1)
278 return "unknown error";
279 if (lua_type(L, -1) != LUA_TSTRING)
280 return "unknown error";
281 return lua_tostring(L, -1);
282}
283
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200284__LJMP static const char *hlua_traceback(lua_State *L)
285{
286 lua_Debug ar;
287 int level = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +0200288 struct buffer *msg = get_trash_chunk();
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200289 int filled = 0;
290
291 while (lua_getstack(L, level++, &ar)) {
292
293 /* Add separator */
294 if (filled)
295 chunk_appendf(msg, ", ");
296 filled = 1;
297
298 /* Fill fields:
299 * 'S': fills in the fields source, short_src, linedefined, lastlinedefined, and what;
300 * 'l': fills in the field currentline;
301 * 'n': fills in the field name and namewhat;
302 * 't': fills in the field istailcall;
303 */
304 lua_getinfo(L, "Slnt", &ar);
305
306 /* Append code localisation */
307 if (ar.currentline > 0)
308 chunk_appendf(msg, "%s:%d ", ar.short_src, ar.currentline);
309 else
310 chunk_appendf(msg, "%s ", ar.short_src);
311
312 /*
313 * Get function name
314 *
315 * if namewhat is no empty, name is defined.
316 * what contains "Lua" for Lua function, "C" for C function,
317 * or "main" for main code.
318 */
319 if (*ar.namewhat != '\0' && ar.name != NULL) /* is there a name from code? */
320 chunk_appendf(msg, "%s '%s'", ar.namewhat, ar.name); /* use it */
321
322 else if (*ar.what == 'm') /* "main", the code is not executed in a function */
323 chunk_appendf(msg, "main chunk");
324
325 else if (*ar.what != 'C') /* for Lua functions, use <file:line> */
326 chunk_appendf(msg, "C function line %d", ar.linedefined);
327
328 else /* nothing left... */
329 chunk_appendf(msg, "?");
330
331
332 /* Display tailed call */
333 if (ar.istailcall)
334 chunk_appendf(msg, " ...");
335 }
336
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200337 return msg->area;
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200338}
339
340
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100341/* This function check the number of arguments available in the
342 * stack. If the number of arguments available is not the same
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500343 * then <nb> an error is thrown.
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100344 */
345__LJMP static inline void check_args(lua_State *L, int nb, char *fcn)
346{
347 if (lua_gettop(L) == nb)
348 return;
349 WILL_LJMP(luaL_error(L, "'%s' needs %d arguments", fcn, nb));
350}
351
Mark Lakes22154b42018-01-29 14:38:40 -0800352/* This function pushes an error string prefixed by the file name
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100353 * and the line number where the error is encountered.
354 */
355static int hlua_pusherror(lua_State *L, const char *fmt, ...)
356{
357 va_list argp;
358 va_start(argp, fmt);
359 luaL_where(L, 1);
360 lua_pushvfstring(L, fmt, argp);
361 va_end(argp);
362 lua_concat(L, 2);
363 return 1;
364}
365
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100366/* This functions is used with sample fetch and converters. It
367 * converts the HAProxy configuration argument in a lua stack
368 * values.
369 *
370 * It takes an array of "arg", and each entry of the array is
371 * converted and pushed in the LUA stack.
372 */
373static int hlua_arg2lua(lua_State *L, const struct arg *arg)
374{
375 switch (arg->type) {
376 case ARGT_SINT:
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100377 case ARGT_TIME:
378 case ARGT_SIZE:
Thierry FOURNIERf90838b2015-03-06 13:48:32 +0100379 lua_pushinteger(L, arg->data.sint);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100380 break;
381
382 case ARGT_STR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200383 lua_pushlstring(L, arg->data.str.area, arg->data.str.data);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100384 break;
385
386 case ARGT_IPV4:
387 case ARGT_IPV6:
388 case ARGT_MSK4:
389 case ARGT_MSK6:
390 case ARGT_FE:
391 case ARGT_BE:
392 case ARGT_TAB:
393 case ARGT_SRV:
394 case ARGT_USR:
395 case ARGT_MAP:
396 default:
397 lua_pushnil(L);
398 break;
399 }
400 return 1;
401}
402
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500403/* This function take one entry in an LUA stack at the index "ud",
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100404 * and try to convert it in an HAProxy argument entry. This is useful
Ilya Shipitsind4259502020-04-08 01:07:56 +0500405 * with sample fetch wrappers. The input arguments are given to the
406 * lua wrapper and converted as arg list by the function.
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100407 */
408static int hlua_lua2arg(lua_State *L, int ud, struct arg *arg)
409{
410 switch (lua_type(L, ud)) {
411
412 case LUA_TNUMBER:
413 case LUA_TBOOLEAN:
414 arg->type = ARGT_SINT;
415 arg->data.sint = lua_tointeger(L, ud);
416 break;
417
418 case LUA_TSTRING:
419 arg->type = ARGT_STR;
Tim Duesterhus2e89dec2019-09-29 23:03:08 +0200420 arg->data.str.area = (char *)lua_tolstring(L, ud, &arg->data.str.data);
Tim Duesterhus29d2e8a2019-09-29 23:03:07 +0200421 /* We don't know the actual size of the underlying allocation, so be conservative. */
Christopher Fauletfdea1b62020-08-06 08:29:18 +0200422 arg->data.str.size = arg->data.str.data+1; /* count the terminating null byte */
Tim Duesterhus29d2e8a2019-09-29 23:03:07 +0200423 arg->data.str.head = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100424 break;
425
426 case LUA_TUSERDATA:
427 case LUA_TNIL:
428 case LUA_TTABLE:
429 case LUA_TFUNCTION:
430 case LUA_TTHREAD:
431 case LUA_TLIGHTUSERDATA:
432 arg->type = ARGT_SINT;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +0200433 arg->data.sint = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100434 break;
435 }
436 return 1;
437}
438
439/* the following functions are used to convert a struct sample
440 * in Lua type. This useful to convert the return of the
Ilya Shipitsind4259502020-04-08 01:07:56 +0500441 * fetches or converters.
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100442 */
Willy Tarreau5eadada2015-03-10 17:28:54 +0100443static int hlua_smp2lua(lua_State *L, struct sample *smp)
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100444{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200445 switch (smp->data.type) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100446 case SMP_T_SINT:
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100447 case SMP_T_BOOL:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200448 lua_pushinteger(L, smp->data.u.sint);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100449 break;
450
451 case SMP_T_BIN:
452 case SMP_T_STR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200453 lua_pushlstring(L, smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100454 break;
455
456 case SMP_T_METH:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200457 switch (smp->data.u.meth.meth) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100458 case HTTP_METH_OPTIONS: lua_pushstring(L, "OPTIONS"); break;
459 case HTTP_METH_GET: lua_pushstring(L, "GET"); break;
460 case HTTP_METH_HEAD: lua_pushstring(L, "HEAD"); break;
461 case HTTP_METH_POST: lua_pushstring(L, "POST"); break;
462 case HTTP_METH_PUT: lua_pushstring(L, "PUT"); break;
463 case HTTP_METH_DELETE: lua_pushstring(L, "DELETE"); break;
464 case HTTP_METH_TRACE: lua_pushstring(L, "TRACE"); break;
465 case HTTP_METH_CONNECT: lua_pushstring(L, "CONNECT"); break;
466 case HTTP_METH_OTHER:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200467 lua_pushlstring(L, smp->data.u.meth.str.area, smp->data.u.meth.str.data);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100468 break;
469 default:
470 lua_pushnil(L);
471 break;
472 }
473 break;
474
475 case SMP_T_IPV4:
476 case SMP_T_IPV6:
477 case SMP_T_ADDR: /* This type is never used to qualify a sample. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200478 if (sample_casts[smp->data.type][SMP_T_STR] &&
479 sample_casts[smp->data.type][SMP_T_STR](smp))
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200480 lua_pushlstring(L, smp->data.u.str.area, smp->data.u.str.data);
Willy Tarreau5eadada2015-03-10 17:28:54 +0100481 else
482 lua_pushnil(L);
483 break;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100484 default:
485 lua_pushnil(L);
486 break;
487 }
488 return 1;
489}
490
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100491/* the following functions are used to convert a struct sample
492 * in Lua strings. This is useful to convert the return of the
Ilya Shipitsind4259502020-04-08 01:07:56 +0500493 * fetches or converters.
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100494 */
495static int hlua_smp2lua_str(lua_State *L, struct sample *smp)
496{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200497 switch (smp->data.type) {
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100498
499 case SMP_T_BIN:
500 case SMP_T_STR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200501 lua_pushlstring(L, smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100502 break;
503
504 case SMP_T_METH:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200505 switch (smp->data.u.meth.meth) {
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100506 case HTTP_METH_OPTIONS: lua_pushstring(L, "OPTIONS"); break;
507 case HTTP_METH_GET: lua_pushstring(L, "GET"); break;
508 case HTTP_METH_HEAD: lua_pushstring(L, "HEAD"); break;
509 case HTTP_METH_POST: lua_pushstring(L, "POST"); break;
510 case HTTP_METH_PUT: lua_pushstring(L, "PUT"); break;
511 case HTTP_METH_DELETE: lua_pushstring(L, "DELETE"); break;
512 case HTTP_METH_TRACE: lua_pushstring(L, "TRACE"); break;
513 case HTTP_METH_CONNECT: lua_pushstring(L, "CONNECT"); break;
514 case HTTP_METH_OTHER:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200515 lua_pushlstring(L, smp->data.u.meth.str.area, smp->data.u.meth.str.data);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100516 break;
517 default:
518 lua_pushstring(L, "");
519 break;
520 }
521 break;
522
523 case SMP_T_SINT:
524 case SMP_T_BOOL:
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100525 case SMP_T_IPV4:
526 case SMP_T_IPV6:
527 case SMP_T_ADDR: /* This type is never used to qualify a sample. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200528 if (sample_casts[smp->data.type][SMP_T_STR] &&
529 sample_casts[smp->data.type][SMP_T_STR](smp))
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200530 lua_pushlstring(L, smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100531 else
532 lua_pushstring(L, "");
533 break;
534 default:
535 lua_pushstring(L, "");
536 break;
537 }
538 return 1;
539}
540
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100541/* the following functions are used to convert an Lua type in a
542 * struct sample. This is useful to provide data from a converter
543 * to the LUA code.
544 */
545static int hlua_lua2smp(lua_State *L, int ud, struct sample *smp)
546{
547 switch (lua_type(L, ud)) {
548
549 case LUA_TNUMBER:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200550 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200551 smp->data.u.sint = lua_tointeger(L, ud);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100552 break;
553
554
555 case LUA_TBOOLEAN:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200556 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200557 smp->data.u.sint = lua_toboolean(L, ud);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100558 break;
559
560 case LUA_TSTRING:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200561 smp->data.type = SMP_T_STR;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100562 smp->flags |= SMP_F_CONST;
Tim Duesterhus2e89dec2019-09-29 23:03:08 +0200563 smp->data.u.str.area = (char *)lua_tolstring(L, ud, &smp->data.u.str.data);
Tim Duesterhus29d2e8a2019-09-29 23:03:07 +0200564 /* We don't know the actual size of the underlying allocation, so be conservative. */
Christopher Fauletfdea1b62020-08-06 08:29:18 +0200565 smp->data.u.str.size = smp->data.u.str.data+1; /* count the terminating null byte */
Tim Duesterhus29d2e8a2019-09-29 23:03:07 +0200566 smp->data.u.str.head = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100567 break;
568
569 case LUA_TUSERDATA:
570 case LUA_TNIL:
571 case LUA_TTABLE:
572 case LUA_TFUNCTION:
573 case LUA_TTHREAD:
574 case LUA_TLIGHTUSERDATA:
Thierry FOURNIER93405e12015-08-26 14:19:03 +0200575 case LUA_TNONE:
576 default:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200577 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200578 smp->data.u.sint = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100579 break;
580 }
581 return 1;
582}
583
Ilya Shipitsind4259502020-04-08 01:07:56 +0500584/* This function check the "argp" built by another conversion function
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -0800585 * is in accord with the expected argp defined by the "mask". The function
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100586 * returns true or false. It can be adjust the types if there compatibles.
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100587 *
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500588 * This function assumes that the argp argument contains ARGM_NBARGS + 1
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100589 * entries.
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100590 */
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100591__LJMP int hlua_lua2arg_check(lua_State *L, int first, struct arg *argp,
David Carlier0c437f42016-04-27 16:21:56 +0100592 uint64_t mask, struct proxy *p)
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100593{
594 int min_arg;
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200595 int i, idx;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100596 struct proxy *px;
Christopher Fauletd25d9262020-08-06 11:04:46 +0200597 struct userlist *ul;
Christopher Fauletfd2e9062020-08-06 11:10:57 +0200598 struct my_regex *reg;
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200599 const char *msg = NULL;
Christopher Fauletfd2e9062020-08-06 11:10:57 +0200600 char *sname, *pname, *err = NULL;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100601
602 idx = 0;
603 min_arg = ARGM(mask);
604 mask >>= ARGM_BITS;
605
606 while (1) {
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200607 struct buffer tmp = BUF_NULL;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100608
609 /* Check oversize. */
610 if (idx >= ARGM_NBARGS && argp[idx].type != ARGT_STOP) {
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200611 msg = "Malformed argument mask";
612 goto error;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100613 }
614
615 /* Check for mandatory arguments. */
616 if (argp[idx].type == ARGT_STOP) {
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100617 if (idx < min_arg) {
618
619 /* If miss other argument than the first one, we return an error. */
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200620 if (idx > 0) {
621 msg = "Mandatory argument expected";
622 goto error;
623 }
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100624
625 /* If first argument have a certain type, some default values
626 * may be used. See the function smp_resolve_args().
627 */
628 switch (mask & ARGT_MASK) {
629
630 case ARGT_FE:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200631 if (!(p->cap & PR_CAP_FE)) {
632 msg = "Mandatory argument expected";
633 goto error;
634 }
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100635 argp[idx].data.prx = p;
636 argp[idx].type = ARGT_FE;
637 argp[idx+1].type = ARGT_STOP;
638 break;
639
640 case ARGT_BE:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200641 if (!(p->cap & PR_CAP_BE)) {
642 msg = "Mandatory argument expected";
643 goto error;
644 }
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100645 argp[idx].data.prx = p;
646 argp[idx].type = ARGT_BE;
647 argp[idx+1].type = ARGT_STOP;
648 break;
649
650 case ARGT_TAB:
651 argp[idx].data.prx = p;
652 argp[idx].type = ARGT_TAB;
653 argp[idx+1].type = ARGT_STOP;
654 break;
655
656 default:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200657 msg = "Mandatory argument expected";
658 goto error;
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100659 break;
660 }
661 }
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200662 break;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100663 }
664
Ilya Shipitsin856aabc2020-04-16 23:51:34 +0500665 /* Check for exceed the number of required argument. */
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100666 if ((mask & ARGT_MASK) == ARGT_STOP &&
667 argp[idx].type != ARGT_STOP) {
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200668 msg = "Last argument expected";
669 goto error;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100670 }
671
672 if ((mask & ARGT_MASK) == ARGT_STOP &&
673 argp[idx].type == ARGT_STOP) {
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200674 break;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100675 }
676
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200677 /* Convert some argument types. All string in argp[] are for not
678 * duplicated yet.
679 */
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100680 switch (mask & ARGT_MASK) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100681 case ARGT_SINT:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200682 if (argp[idx].type != ARGT_SINT) {
683 msg = "integer expected";
684 goto error;
685 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100686 argp[idx].type = ARGT_SINT;
687 break;
688
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100689 case ARGT_TIME:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200690 if (argp[idx].type != ARGT_SINT) {
691 msg = "integer expected";
692 goto error;
693 }
Thierry FOURNIER29176f32015-07-07 00:41:29 +0200694 argp[idx].type = ARGT_TIME;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100695 break;
696
697 case ARGT_SIZE:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200698 if (argp[idx].type != ARGT_SINT) {
699 msg = "integer expected";
700 goto error;
701 }
Thierry FOURNIER29176f32015-07-07 00:41:29 +0200702 argp[idx].type = ARGT_SIZE;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100703 break;
704
705 case ARGT_FE:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200706 if (argp[idx].type != ARGT_STR) {
707 msg = "string expected";
708 goto error;
709 }
Christopher Fauletfdea1b62020-08-06 08:29:18 +0200710 argp[idx].data.prx = proxy_fe_by_name(argp[idx].data.str.area);
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200711 if (!argp[idx].data.prx) {
712 msg = "frontend doesn't exist";
713 goto error;
714 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100715 argp[idx].type = ARGT_FE;
716 break;
717
718 case ARGT_BE:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200719 if (argp[idx].type != ARGT_STR) {
720 msg = "string expected";
721 goto error;
722 }
Christopher Fauletfdea1b62020-08-06 08:29:18 +0200723 argp[idx].data.prx = proxy_be_by_name(argp[idx].data.str.area);
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200724 if (!argp[idx].data.prx) {
725 msg = "backend doesn't exist";
726 goto error;
727 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100728 argp[idx].type = ARGT_BE;
729 break;
730
731 case ARGT_TAB:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200732 if (argp[idx].type != ARGT_STR) {
733 msg = "string expected";
734 goto error;
735 }
Christopher Fauletfdea1b62020-08-06 08:29:18 +0200736 argp[idx].data.t = stktable_find_by_name(argp[idx].data.str.area);
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200737 if (!argp[idx].data.t) {
738 msg = "table doesn't exist";
739 goto error;
740 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100741 argp[idx].type = ARGT_TAB;
742 break;
743
744 case ARGT_SRV:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200745 if (argp[idx].type != ARGT_STR) {
746 msg = "string expected";
747 goto error;
748 }
Christopher Fauletfdea1b62020-08-06 08:29:18 +0200749 sname = strrchr(argp[idx].data.str.area, '/');
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100750 if (sname) {
751 *sname++ = '\0';
Christopher Fauletfdea1b62020-08-06 08:29:18 +0200752 pname = argp[idx].data.str.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +0200753 px = proxy_be_by_name(pname);
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200754 if (!px) {
755 msg = "backend doesn't exist";
756 goto error;
757 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100758 }
759 else {
Christopher Fauletfdea1b62020-08-06 08:29:18 +0200760 sname = argp[idx].data.str.area;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100761 px = p;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100762 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100763 argp[idx].data.srv = findserver(px, sname);
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200764 if (!argp[idx].data.srv) {
765 msg = "server doesn't exist";
766 goto error;
767 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100768 argp[idx].type = ARGT_SRV;
769 break;
770
771 case ARGT_IPV4:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200772 if (argp[idx].type != ARGT_STR) {
773 msg = "string expected";
774 goto error;
775 }
776 if (inet_pton(AF_INET, argp[idx].data.str.area, &argp[idx].data.ipv4)) {
777 msg = "invalid IPv4 address";
778 goto error;
779 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100780 argp[idx].type = ARGT_IPV4;
781 break;
782
783 case ARGT_MSK4:
Christopher Faulete663a6e2020-08-07 09:11:22 +0200784 if (argp[idx].type == ARGT_SINT)
785 len2mask4(argp[idx].data.sint, &argp[idx].data.ipv4);
786 else if (argp[idx].type == ARGT_STR) {
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200787 if (!str2mask(argp[idx].data.str.area, &argp[idx].data.ipv4)) {
788 msg = "invalid IPv4 mask";
789 goto error;
790 }
791 }
792 else {
793 msg = "integer or string expected";
794 goto error;
Christopher Faulete663a6e2020-08-07 09:11:22 +0200795 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100796 argp[idx].type = ARGT_MSK4;
797 break;
798
799 case ARGT_IPV6:
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200800 if (argp[idx].type != ARGT_STR) {
801 msg = "string expected";
802 goto error;
803 }
804 if (inet_pton(AF_INET6, argp[idx].data.str.area, &argp[idx].data.ipv6)) {
805 msg = "invalid IPv6 address";
806 goto error;
807 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100808 argp[idx].type = ARGT_IPV6;
809 break;
810
811 case ARGT_MSK6:
Christopher Faulete663a6e2020-08-07 09:11:22 +0200812 if (argp[idx].type == ARGT_SINT)
813 len2mask6(argp[idx].data.sint, &argp[idx].data.ipv6);
814 else if (argp[idx].type == ARGT_STR) {
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200815 if (!str2mask6(argp[idx].data.str.area, &argp[idx].data.ipv6)) {
816 msg = "invalid IPv6 mask";
817 goto error;
818 }
819 }
820 else {
821 msg = "integer or string expected";
822 goto error;
Christopher Faulete663a6e2020-08-07 09:11:22 +0200823 }
Tim Duesterhusb814da62018-01-25 16:24:50 +0100824 argp[idx].type = ARGT_MSK6;
825 break;
826
Christopher Fauletfd2e9062020-08-06 11:10:57 +0200827 case ARGT_REG:
828 if (argp[idx].type != ARGT_STR) {
829 msg = "string expected";
830 goto error;
831 }
832 reg = regex_comp(argp[idx].data.str.area, !(argp[idx].type_flags & ARGF_REG_ICASE), 1, &err);
833 if (!reg) {
834 msg = lua_pushfstring(L, "error compiling regex '%s' : '%s'",
835 argp[idx].data.str.area, err);
836 free(err);
837 goto error;
838 }
839 argp[idx].type = ARGT_REG;
840 argp[idx].data.reg = reg;
841 break;
842
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100843 case ARGT_USR:
Christopher Fauletd25d9262020-08-06 11:04:46 +0200844 if (argp[idx].type != ARGT_STR) {
845 msg = "string expected";
846 goto error;
847 }
848 if (p->uri_auth && p->uri_auth->userlist &&
849 !strcmp(p->uri_auth->userlist->name, argp[idx].data.str.area))
850 ul = p->uri_auth->userlist;
851 else
852 ul = auth_find_userlist(argp[idx].data.str.area);
853
854 if (!ul) {
855 msg = lua_pushfstring(L, "unable to find userlist '%s'", argp[idx].data.str.area);
856 goto error;
857 }
858 argp[idx].type = ARGT_USR;
859 argp[idx].data.usr = ul;
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200860 break;
861
862 case ARGT_STR:
863 if (!chunk_dup(&tmp, &argp[idx].data.str)) {
864 msg = "unable to duplicate string arg";
865 goto error;
866 }
867 argp[idx].data.str = tmp;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100868 break;
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200869
Christopher Fauletd25d9262020-08-06 11:04:46 +0200870 case ARGT_MAP:
Christopher Fauletd25d9262020-08-06 11:04:46 +0200871 msg = "type not yet supported";
872 goto error;
873 break;
874
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100875 }
876
877 /* Check for type of argument. */
878 if ((mask & ARGT_MASK) != argp[idx].type) {
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200879 msg = lua_pushfstring(L, "'%s' expected, got '%s'",
880 arg_type_names[(mask & ARGT_MASK)],
881 arg_type_names[argp[idx].type & ARGT_MASK]);
882 goto error;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100883 }
884
885 /* Next argument. */
886 mask >>= ARGT_BITS;
887 idx++;
888 }
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200889 return 0;
890
891 error:
892 for (i = 0; i < idx; i++) {
893 if (argp[i].type == ARGT_STR)
894 chunk_destroy(&argp[i].data.str);
Christopher Fauletfd2e9062020-08-06 11:10:57 +0200895 else if (argp[i].type == ARGT_REG)
896 regex_free(argp[i].data.reg);
Christopher Fauletaec27ef2020-08-06 08:54:25 +0200897 }
898 WILL_LJMP(luaL_argerror(L, first + idx, msg));
899 return 0; /* Never reached */
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100900}
901
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100902/*
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500903 * The following functions are used to make correspondence between the the
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100904 * executed lua pointer and the "struct hlua *" that contain the context.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100905 *
906 * - hlua_gethlua : return the hlua context associated with an lua_State.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100907 * - hlua_sethlua : create the association between hlua context and lua_state.
908 */
909static inline struct hlua *hlua_gethlua(lua_State *L)
910{
Thierry FOURNIER38c5fd62015-03-10 02:40:29 +0100911 struct hlua **hlua = lua_getextraspace(L);
912 return *hlua;
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100913}
914static inline void hlua_sethlua(struct hlua *hlua)
915{
Thierry FOURNIER38c5fd62015-03-10 02:40:29 +0100916 struct hlua **hlua_store = lua_getextraspace(hlua->T);
917 *hlua_store = hlua;
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100918}
919
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100920/* This function is used to send logs. It try to send on screen (stderr)
921 * and on the default syslog server.
922 */
923static inline void hlua_sendlog(struct proxy *px, int level, const char *msg)
924{
925 struct tm tm;
926 char *p;
927
928 /* Cleanup the log message. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200929 p = trash.area;
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100930 for (; *msg != '\0'; msg++, p++) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200931 if (p >= trash.area + trash.size - 1) {
Thierry FOURNIERccf00632015-09-16 12:47:03 +0200932 /* Break the message if exceed the buffer size. */
933 *(p-4) = ' ';
934 *(p-3) = '.';
935 *(p-2) = '.';
936 *(p-1) = '.';
937 break;
938 }
Willy Tarreau90807112020-02-25 08:16:33 +0100939 if (isprint((unsigned char)*msg))
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100940 *p = *msg;
941 else
942 *p = '.';
943 }
944 *p = '\0';
945
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200946 send_log(px, level, "%s\n", trash.area);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100947 if (!(global.mode & MODE_QUIET) || (global.mode & (MODE_VERBOSE | MODE_STARTING))) {
Willy Tarreaua678b432015-08-28 10:14:59 +0200948 get_localtime(date.tv_sec, &tm);
949 fprintf(stderr, "[%s] %03d/%02d%02d%02d (%d) : %s\n",
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100950 log_levels[level], tm.tm_yday, tm.tm_hour, tm.tm_min, tm.tm_sec,
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200951 (int)getpid(), trash.area);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100952 fflush(stderr);
953 }
954}
955
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100956/* This function just ensure that the yield will be always
957 * returned with a timeout and permit to set some flags
958 */
959__LJMP void hlua_yieldk(lua_State *L, int nresults, int ctx,
Thierry FOURNIERf90838b2015-03-06 13:48:32 +0100960 lua_KFunction k, int timeout, unsigned int flags)
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100961{
962 struct hlua *hlua = hlua_gethlua(L);
963
964 /* Set the wake timeout. If timeout is required, we set
965 * the expiration time.
966 */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +0200967 hlua->wake_time = timeout;
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100968
Thierry FOURNIER4abd3ae2015-03-03 17:29:06 +0100969 hlua->flags |= flags;
970
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100971 /* Process the yield. */
Willy Tarreau9635e032018-10-16 17:52:55 +0200972 MAY_LJMP(lua_yieldk(L, nresults, ctx, k));
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100973}
974
Willy Tarreau87b09662015-04-03 00:22:06 +0200975/* This function initialises the Lua environment stored in the stream.
976 * It must be called at the start of the stream. This function creates
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100977 * an LUA coroutine. It can not be use to crete the main LUA context.
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200978 *
979 * This function is particular. it initialises a new Lua thread. If the
980 * initialisation fails (example: out of memory error), the lua function
981 * throws an error (longjmp).
982 *
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +0100983 * In some case (at least one), this function can be called from safe
Ilya Shipitsin856aabc2020-04-16 23:51:34 +0500984 * environment, so we must not initialise it. While the support of
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +0100985 * threads appear, the safe environment set a lock to ensure only one
986 * Lua execution at a time. If we initialize safe environment in another
Ilya Shipitsin856aabc2020-04-16 23:51:34 +0500987 * safe environment, we have a dead lock.
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +0100988 *
989 * set "already_safe" true if the context is initialized form safe
Ilya Shipitsin856aabc2020-04-16 23:51:34 +0500990 * Lua function.
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +0100991 *
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -0800992 * This function manipulates two Lua stacks: the main and the thread. Only
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200993 * the main stack can fail. The thread is not manipulated. This function
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -0800994 * MUST NOT manipulate the created thread stack state, because it is not
Ilya Shipitsin856aabc2020-04-16 23:51:34 +0500995 * protected against errors thrown by the thread stack.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100996 */
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +0100997int hlua_ctx_init(struct hlua *lua, struct task *task, int already_safe)
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100998{
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +0100999 if (!already_safe) {
1000 if (!SET_SAFE_LJMP(gL.T)) {
1001 lua->Tref = LUA_REFNIL;
1002 return 0;
1003 }
Thierry FOURNIERbabae282015-09-17 11:36:37 +02001004 }
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001005 lua->Mref = LUA_REFNIL;
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001006 lua->flags = 0;
Willy Tarreauf31af932020-01-14 09:59:38 +01001007 lua->gc_count = 0;
Christopher Fauletbc275a92020-02-26 14:55:16 +01001008 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +01001009 LIST_INIT(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001010 lua->T = lua_newthread(gL.T);
1011 if (!lua->T) {
1012 lua->Tref = LUA_REFNIL;
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01001013 if (!already_safe)
1014 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001015 return 0;
1016 }
1017 hlua_sethlua(lua);
1018 lua->Tref = luaL_ref(gL.T, LUA_REGISTRYINDEX);
1019 lua->task = task;
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01001020 if (!already_safe)
1021 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001022 return 1;
1023}
1024
Willy Tarreau87b09662015-04-03 00:22:06 +02001025/* Used to destroy the Lua coroutine when the attached stream or task
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001026 * is destroyed. The destroy also the memory context. The struct "lua"
1027 * is not freed.
1028 */
1029void hlua_ctx_destroy(struct hlua *lua)
1030{
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01001031 if (!lua)
Thierry FOURNIERa718b292015-03-04 16:48:34 +01001032 return;
1033
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01001034 if (!lua->T)
1035 goto end;
1036
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +01001037 /* Purge all the pending signals. */
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001038 notification_purge(&lua->com);
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +01001039
Thierry FOURNIER75d02082017-07-12 13:41:33 +02001040 if (!SET_SAFE_LJMP(lua->T))
1041 return;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001042 luaL_unref(lua->T, LUA_REGISTRYINDEX, lua->Mref);
Thierry FOURNIER75d02082017-07-12 13:41:33 +02001043 RESET_SAFE_LJMP(lua->T);
Thierry FOURNIER5a50a852015-09-23 16:59:28 +02001044
Thierry FOURNIER75d02082017-07-12 13:41:33 +02001045 if (!SET_SAFE_LJMP(gL.T))
1046 return;
1047 luaL_unref(gL.T, LUA_REGISTRYINDEX, lua->Tref);
1048 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER5a50a852015-09-23 16:59:28 +02001049 /* Forces a garbage collecting process. If the Lua program is finished
1050 * without error, we run the GC on the thread pointer. Its freed all
1051 * the unused memory.
1052 * If the thread is finnish with an error or is currently yielded,
1053 * it seems that the GC applied on the thread doesn't clean anything,
1054 * so e run the GC on the main thread.
1055 * NOTE: maybe this action locks all the Lua threads untiml the en of
1056 * the garbage collection.
1057 */
Willy Tarreauf31af932020-01-14 09:59:38 +01001058 if (lua->gc_count) {
Thierry FOURNIER7bd10d52017-07-17 00:44:40 +02001059 if (!SET_SAFE_LJMP(gL.T))
Thierry FOURNIER75d02082017-07-12 13:41:33 +02001060 return;
Thierry FOURNIER7bd10d52017-07-17 00:44:40 +02001061 lua_gc(gL.T, LUA_GCCOLLECT, 0);
1062 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +02001063 }
Thierry FOURNIER5a50a852015-09-23 16:59:28 +02001064
Thierry FOURNIERa7b536b2015-09-21 22:50:24 +02001065 lua->T = NULL;
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01001066
1067end:
Willy Tarreaubafbe012017-11-24 17:34:44 +01001068 pool_free(pool_head_hlua, lua);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001069}
1070
1071/* This function is used to restore the Lua context when a coroutine
1072 * fails. This function copy the common memory between old coroutine
1073 * and the new coroutine. The old coroutine is destroyed, and its
1074 * replaced by the new coroutine.
1075 * If the flag "keep_msg" is set, the last entry of the old is assumed
1076 * as string error message and it is copied in the new stack.
1077 */
1078static int hlua_ctx_renew(struct hlua *lua, int keep_msg)
1079{
1080 lua_State *T;
1081 int new_ref;
1082
1083 /* Renew the main LUA stack doesn't have sense. */
1084 if (lua == &gL)
1085 return 0;
1086
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001087 /* New Lua coroutine. */
1088 T = lua_newthread(gL.T);
1089 if (!T)
1090 return 0;
1091
1092 /* Copy last error message. */
1093 if (keep_msg)
1094 lua_xmove(lua->T, T, 1);
1095
1096 /* Copy data between the coroutines. */
1097 lua_rawgeti(lua->T, LUA_REGISTRYINDEX, lua->Mref);
1098 lua_xmove(lua->T, T, 1);
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05001099 new_ref = luaL_ref(T, LUA_REGISTRYINDEX); /* Value popped. */
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001100
1101 /* Destroy old data. */
1102 luaL_unref(lua->T, LUA_REGISTRYINDEX, lua->Mref);
1103
1104 /* The thread is garbage collected by Lua. */
1105 luaL_unref(gL.T, LUA_REGISTRYINDEX, lua->Tref);
1106
1107 /* Fill the struct with the new coroutine values. */
1108 lua->Mref = new_ref;
1109 lua->T = T;
1110 lua->Tref = luaL_ref(gL.T, LUA_REGISTRYINDEX);
1111
1112 /* Set context. */
1113 hlua_sethlua(lua);
1114
1115 return 1;
1116}
1117
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001118void hlua_hook(lua_State *L, lua_Debug *ar)
1119{
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001120 struct hlua *hlua = hlua_gethlua(L);
1121
1122 /* Lua cannot yield when its returning from a function,
1123 * so, we can fix the interrupt hook to 1 instruction,
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001124 * expecting that the function is finished.
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001125 */
1126 if (lua_gethookmask(L) & LUA_MASKRET) {
1127 lua_sethook(hlua->T, hlua_hook, LUA_MASKCOUNT, 1);
1128 return;
1129 }
1130
1131 /* restore the interrupt condition. */
1132 lua_sethook(hlua->T, hlua_hook, LUA_MASKCOUNT, hlua_nb_instruction);
1133
1134 /* If we interrupt the Lua processing in yieldable state, we yield.
1135 * If the state is not yieldable, trying yield causes an error.
1136 */
1137 if (lua_isyieldable(L))
Willy Tarreau9635e032018-10-16 17:52:55 +02001138 MAY_LJMP(hlua_yieldk(L, 0, 0, NULL, TICK_ETERNITY, HLUA_CTRLYIELD));
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001139
Thierry FOURNIERa85cfb12015-03-13 14:50:06 +01001140 /* If we cannot yield, update the clock and check the timeout. */
1141 tv_update_date(0, 1);
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001142 hlua->run_time += now_ms - hlua->start_time;
1143 if (hlua->max_time && hlua->run_time >= hlua->max_time) {
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001144 lua_pushfstring(L, "execution timeout");
1145 WILL_LJMP(lua_error(L));
1146 }
1147
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001148 /* Update the start time. */
1149 hlua->start_time = now_ms;
1150
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001151 /* Try to interrupt the process at the end of the current
1152 * unyieldable function.
1153 */
1154 lua_sethook(hlua->T, hlua_hook, LUA_MASKRET|LUA_MASKCOUNT, hlua_nb_instruction);
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001155}
1156
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001157/* This function start or resumes the Lua stack execution. If the flag
1158 * "yield_allowed" if no set and the LUA stack execution returns a yield
1159 * The function return an error.
1160 *
1161 * The function can returns 4 values:
1162 * - HLUA_E_OK : The execution is terminated without any errors.
1163 * - HLUA_E_AGAIN : The execution must continue at the next associated
1164 * task wakeup.
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001165 * - HLUA_E_ERRMSG : An error has occurred, an error message is set in
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001166 * the top of the stack.
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001167 * - HLUA_E_ERR : An error has occurred without error message.
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001168 *
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001169 * If an error occurred, the stack is renewed and it is ready to run new
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001170 * LUA code.
1171 */
1172static enum hlua_exec hlua_ctx_resume(struct hlua *lua, int yield_allowed)
1173{
Christopher Faulet08ed98f2020-07-28 10:33:25 +02001174#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 504
1175 int nres;
1176#endif
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001177 int ret;
1178 const char *msg;
Thierry FOURNIERfc044c92018-06-07 14:40:48 +02001179 const char *trace;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001180
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001181 /* Initialise run time counter. */
1182 if (!HLUA_IS_RUNNING(lua))
1183 lua->run_time = 0;
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001184
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +02001185 /* Lock the whole Lua execution. This lock must be before the
1186 * label "resume_execution".
1187 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001188 HA_SPIN_LOCK(LUA_LOCK, &hlua_global_lock);
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +02001189
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001190resume_execution:
1191
1192 /* This hook interrupts the Lua processing each 'hlua_nb_instruction'
1193 * instructions. it is used for preventing infinite loops.
1194 */
1195 lua_sethook(lua->T, hlua_hook, LUA_MASKCOUNT, hlua_nb_instruction);
1196
Thierry FOURNIER1bfc09b2015-03-05 17:10:14 +01001197 /* Remove all flags except the running flags. */
Thierry FOURNIER2f3867f2015-09-28 01:02:01 +02001198 HLUA_SET_RUN(lua);
1199 HLUA_CLR_CTRLYIELD(lua);
1200 HLUA_CLR_WAKERESWR(lua);
1201 HLUA_CLR_WAKEREQWR(lua);
Thierry FOURNIER1bfc09b2015-03-05 17:10:14 +01001202
Christopher Fauletbc275a92020-02-26 14:55:16 +01001203 /* Update the start time and reset wake_time. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001204 lua->start_time = now_ms;
Christopher Fauletbc275a92020-02-26 14:55:16 +01001205 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001206
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001207 /* Call the function. */
Christopher Faulet08ed98f2020-07-28 10:33:25 +02001208#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 504
1209 ret = lua_resume(lua->T, gL.T, lua->nargs, &nres);
1210#else
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001211 ret = lua_resume(lua->T, gL.T, lua->nargs);
Christopher Faulet08ed98f2020-07-28 10:33:25 +02001212#endif
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001213 switch (ret) {
1214
1215 case LUA_OK:
1216 ret = HLUA_E_OK;
1217 break;
1218
1219 case LUA_YIELD:
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001220 /* Check if the execution timeout is expired. It it is the case, we
1221 * break the Lua execution.
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001222 */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001223 tv_update_date(0, 1);
1224 lua->run_time += now_ms - lua->start_time;
1225 if (lua->max_time && lua->run_time > lua->max_time) {
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001226 lua_settop(lua->T, 0); /* Empty the stack. */
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001227 ret = HLUA_E_ETMOUT;
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001228 break;
1229 }
1230 /* Process the forced yield. if the general yield is not allowed or
1231 * if no task were associated this the current Lua execution
1232 * coroutine, we resume the execution. Else we want to return in the
1233 * scheduler and we want to be waked up again, to continue the
1234 * current Lua execution. So we schedule our own task.
1235 */
1236 if (HLUA_IS_CTRLYIELDING(lua)) {
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001237 if (!yield_allowed || !lua->task)
1238 goto resume_execution;
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001239 task_wakeup(lua->task, TASK_WOKEN_MSG);
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001240 }
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001241 if (!yield_allowed) {
1242 lua_settop(lua->T, 0); /* Empty the stack. */
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001243 ret = HLUA_E_YIELD;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001244 break;
1245 }
1246 ret = HLUA_E_AGAIN;
1247 break;
1248
1249 case LUA_ERRRUN:
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001250
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001251 /* Special exit case. The traditional exit is returned as an error
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001252 * because the errors ares the only one mean to return immediately
1253 * from and lua execution.
1254 */
1255 if (lua->flags & HLUA_EXIT) {
1256 ret = HLUA_E_OK;
Christopher Faulet7716cdf2020-01-29 11:53:30 +01001257 hlua_ctx_renew(lua, 1);
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001258 break;
1259 }
1260
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001261 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001262 if (!lua_checkstack(lua->T, 1)) {
1263 ret = HLUA_E_ERR;
1264 break;
1265 }
1266 msg = lua_tostring(lua->T, -1);
1267 lua_settop(lua->T, 0); /* Empty the stack. */
1268 lua_pop(lua->T, 1);
Thierry FOURNIERfc044c92018-06-07 14:40:48 +02001269 trace = hlua_traceback(lua->T);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001270 if (msg)
Thierry FOURNIERfc044c92018-06-07 14:40:48 +02001271 lua_pushfstring(lua->T, "runtime error: %s from %s", msg, trace);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001272 else
Thierry FOURNIERfc044c92018-06-07 14:40:48 +02001273 lua_pushfstring(lua->T, "unknown runtime error from %s", trace);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001274 ret = HLUA_E_ERRMSG;
1275 break;
1276
1277 case LUA_ERRMEM:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001278 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001279 lua_settop(lua->T, 0); /* Empty the stack. */
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001280 ret = HLUA_E_NOMEM;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001281 break;
1282
1283 case LUA_ERRERR:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001284 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001285 if (!lua_checkstack(lua->T, 1)) {
1286 ret = HLUA_E_ERR;
1287 break;
1288 }
1289 msg = lua_tostring(lua->T, -1);
1290 lua_settop(lua->T, 0); /* Empty the stack. */
1291 lua_pop(lua->T, 1);
1292 if (msg)
1293 lua_pushfstring(lua->T, "message handler error: %s", msg);
1294 else
1295 lua_pushfstring(lua->T, "message handler error");
1296 ret = HLUA_E_ERRMSG;
1297 break;
1298
1299 default:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001300 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001301 lua_settop(lua->T, 0); /* Empty the stack. */
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001302 ret = HLUA_E_ERR;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001303 break;
1304 }
1305
1306 switch (ret) {
1307 case HLUA_E_AGAIN:
1308 break;
1309
1310 case HLUA_E_ERRMSG:
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001311 notification_purge(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001312 hlua_ctx_renew(lua, 1);
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001313 HLUA_CLR_RUN(lua);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001314 break;
1315
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001316 case HLUA_E_ETMOUT:
1317 case HLUA_E_NOMEM:
1318 case HLUA_E_YIELD:
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001319 case HLUA_E_ERR:
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001320 HLUA_CLR_RUN(lua);
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001321 notification_purge(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001322 hlua_ctx_renew(lua, 0);
1323 break;
1324
1325 case HLUA_E_OK:
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001326 HLUA_CLR_RUN(lua);
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001327 notification_purge(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001328 break;
1329 }
1330
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +02001331 /* This is the main exit point, remove the Lua lock. */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001332 HA_SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock);
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +02001333
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001334 return ret;
1335}
1336
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001337/* This function exit the current code. */
1338__LJMP static int hlua_done(lua_State *L)
1339{
1340 struct hlua *hlua = hlua_gethlua(L);
1341
1342 hlua->flags |= HLUA_EXIT;
1343 WILL_LJMP(lua_error(L));
1344
1345 return 0;
1346}
1347
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001348/* This function is an LUA binding. It provides a function
1349 * for deleting ACL from a referenced ACL file.
1350 */
1351__LJMP static int hlua_del_acl(lua_State *L)
1352{
1353 const char *name;
1354 const char *key;
1355 struct pat_ref *ref;
1356
1357 MAY_LJMP(check_args(L, 2, "del_acl"));
1358
1359 name = MAY_LJMP(luaL_checkstring(L, 1));
1360 key = MAY_LJMP(luaL_checkstring(L, 2));
1361
1362 ref = pat_ref_lookup(name);
1363 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001364 WILL_LJMP(luaL_error(L, "'del_acl': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001365
Christopher Faulet5cf2dfc2020-06-03 18:39:16 +02001366 HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001367 pat_ref_delete(ref, key);
Christopher Faulet5cf2dfc2020-06-03 18:39:16 +02001368 HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001369 return 0;
1370}
1371
1372/* This function is an LUA binding. It provides a function
1373 * for deleting map entry from a referenced map file.
1374 */
1375static int hlua_del_map(lua_State *L)
1376{
1377 const char *name;
1378 const char *key;
1379 struct pat_ref *ref;
1380
1381 MAY_LJMP(check_args(L, 2, "del_map"));
1382
1383 name = MAY_LJMP(luaL_checkstring(L, 1));
1384 key = MAY_LJMP(luaL_checkstring(L, 2));
1385
1386 ref = pat_ref_lookup(name);
1387 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001388 WILL_LJMP(luaL_error(L, "'del_map': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001389
Christopher Faulet5cf2dfc2020-06-03 18:39:16 +02001390 HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001391 pat_ref_delete(ref, key);
Christopher Faulet5cf2dfc2020-06-03 18:39:16 +02001392 HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001393 return 0;
1394}
1395
1396/* This function is an LUA binding. It provides a function
1397 * for adding ACL pattern from a referenced ACL file.
1398 */
1399static int hlua_add_acl(lua_State *L)
1400{
1401 const char *name;
1402 const char *key;
1403 struct pat_ref *ref;
1404
1405 MAY_LJMP(check_args(L, 2, "add_acl"));
1406
1407 name = MAY_LJMP(luaL_checkstring(L, 1));
1408 key = MAY_LJMP(luaL_checkstring(L, 2));
1409
1410 ref = pat_ref_lookup(name);
1411 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001412 WILL_LJMP(luaL_error(L, "'add_acl': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001413
Christopher Faulet5cf2dfc2020-06-03 18:39:16 +02001414 HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001415 if (pat_ref_find_elt(ref, key) == NULL)
1416 pat_ref_add(ref, key, NULL, NULL);
Christopher Faulet5cf2dfc2020-06-03 18:39:16 +02001417 HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001418 return 0;
1419}
1420
1421/* This function is an LUA binding. It provides a function
1422 * for setting map pattern and sample from a referenced map
1423 * file.
1424 */
1425static int hlua_set_map(lua_State *L)
1426{
1427 const char *name;
1428 const char *key;
1429 const char *value;
1430 struct pat_ref *ref;
1431
1432 MAY_LJMP(check_args(L, 3, "set_map"));
1433
1434 name = MAY_LJMP(luaL_checkstring(L, 1));
1435 key = MAY_LJMP(luaL_checkstring(L, 2));
1436 value = MAY_LJMP(luaL_checkstring(L, 3));
1437
1438 ref = pat_ref_lookup(name);
1439 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001440 WILL_LJMP(luaL_error(L, "'set_map': unknown map file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001441
Christopher Faulet5cf2dfc2020-06-03 18:39:16 +02001442 HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001443 if (pat_ref_find_elt(ref, key) != NULL)
1444 pat_ref_set(ref, key, value, NULL);
1445 else
1446 pat_ref_add(ref, key, value, NULL);
Christopher Faulet5cf2dfc2020-06-03 18:39:16 +02001447 HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001448 return 0;
1449}
1450
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01001451/* A class is a lot of memory that contain data. This data can be a table,
1452 * an integer or user data. This data is associated with a metatable. This
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05001453 * metatable have an original version registered in the global context with
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01001454 * the name of the object (_G[<name>] = <metable> ).
1455 *
1456 * A metable is a table that modify the standard behavior of a standard
1457 * access to the associated data. The entries of this new metatable are
1458 * defined as is:
1459 *
1460 * http://lua-users.org/wiki/MetatableEvents
1461 *
1462 * __index
1463 *
1464 * we access an absent field in a table, the result is nil. This is
1465 * true, but it is not the whole truth. Actually, such access triggers
1466 * the interpreter to look for an __index metamethod: If there is no
1467 * such method, as usually happens, then the access results in nil;
1468 * otherwise, the metamethod will provide the result.
1469 *
1470 * Control 'prototype' inheritance. When accessing "myTable[key]" and
1471 * the key does not appear in the table, but the metatable has an __index
1472 * property:
1473 *
1474 * - if the value is a function, the function is called, passing in the
1475 * table and the key; the return value of that function is returned as
1476 * the result.
1477 *
1478 * - if the value is another table, the value of the key in that table is
1479 * asked for and returned (and if it doesn't exist in that table, but that
1480 * table's metatable has an __index property, then it continues on up)
1481 *
1482 * - Use "rawget(myTable,key)" to skip this metamethod.
1483 *
1484 * http://www.lua.org/pil/13.4.1.html
1485 *
1486 * __newindex
1487 *
1488 * Like __index, but control property assignment.
1489 *
1490 * __mode - Control weak references. A string value with one or both
1491 * of the characters 'k' and 'v' which specifies that the the
1492 * keys and/or values in the table are weak references.
1493 *
1494 * __call - Treat a table like a function. When a table is followed by
1495 * parenthesis such as "myTable( 'foo' )" and the metatable has
1496 * a __call key pointing to a function, that function is invoked
1497 * (passing any specified arguments) and the return value is
1498 * returned.
1499 *
1500 * __metatable - Hide the metatable. When "getmetatable( myTable )" is
1501 * called, if the metatable for myTable has a __metatable
1502 * key, the value of that key is returned instead of the
1503 * actual metatable.
1504 *
1505 * __tostring - Control string representation. When the builtin
1506 * "tostring( myTable )" function is called, if the metatable
1507 * for myTable has a __tostring property set to a function,
1508 * that function is invoked (passing myTable to it) and the
1509 * return value is used as the string representation.
1510 *
1511 * __len - Control table length. When the table length is requested using
1512 * the length operator ( '#' ), if the metatable for myTable has
1513 * a __len key pointing to a function, that function is invoked
1514 * (passing myTable to it) and the return value used as the value
1515 * of "#myTable".
1516 *
1517 * __gc - Userdata finalizer code. When userdata is set to be garbage
1518 * collected, if the metatable has a __gc field pointing to a
1519 * function, that function is first invoked, passing the userdata
1520 * to it. The __gc metamethod is not called for tables.
1521 * (See http://lua-users.org/lists/lua-l/2006-11/msg00508.html)
1522 *
1523 * Special metamethods for redefining standard operators:
1524 * http://www.lua.org/pil/13.1.html
1525 *
1526 * __add "+"
1527 * __sub "-"
1528 * __mul "*"
1529 * __div "/"
1530 * __unm "!"
1531 * __pow "^"
1532 * __concat ".."
1533 *
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001534 * Special methods for redefining standard relations
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01001535 * http://www.lua.org/pil/13.2.html
1536 *
1537 * __eq "=="
1538 * __lt "<"
1539 * __le "<="
1540 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001541
1542/*
1543 *
1544 *
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001545 * Class Map
1546 *
1547 *
1548 */
1549
1550/* Returns a struct hlua_map if the stack entry "ud" is
1551 * a class session, otherwise it throws an error.
1552 */
1553__LJMP static struct map_descriptor *hlua_checkmap(lua_State *L, int ud)
1554{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02001555 return MAY_LJMP(hlua_checkudata(L, ud, class_map_ref));
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001556}
1557
1558/* This function is the map constructor. It don't need
1559 * the class Map object. It creates and return a new Map
1560 * object. It must be called only during "body" or "init"
1561 * context because it process some filesystem accesses.
1562 */
1563__LJMP static int hlua_map_new(struct lua_State *L)
1564{
1565 const char *fn;
1566 int match = PAT_MATCH_STR;
1567 struct sample_conv conv;
1568 const char *file = "";
1569 int line = 0;
1570 lua_Debug ar;
1571 char *err = NULL;
1572 struct arg args[2];
1573
1574 if (lua_gettop(L) < 1 || lua_gettop(L) > 2)
1575 WILL_LJMP(luaL_error(L, "'new' needs at least 1 argument."));
1576
1577 fn = MAY_LJMP(luaL_checkstring(L, 1));
1578
1579 if (lua_gettop(L) >= 2) {
1580 match = MAY_LJMP(luaL_checkinteger(L, 2));
1581 if (match < 0 || match >= PAT_MATCH_NUM)
1582 WILL_LJMP(luaL_error(L, "'new' needs a valid match method."));
1583 }
1584
1585 /* Get Lua filename and line number. */
1586 if (lua_getstack(L, 1, &ar)) { /* check function at level */
1587 lua_getinfo(L, "Sl", &ar); /* get info about it */
1588 if (ar.currentline > 0) { /* is there info? */
1589 file = ar.short_src;
1590 line = ar.currentline;
1591 }
1592 }
1593
1594 /* fill fake sample_conv struct. */
1595 conv.kw = ""; /* unused. */
1596 conv.process = NULL; /* unused. */
1597 conv.arg_mask = 0; /* unused. */
1598 conv.val_args = NULL; /* unused. */
1599 conv.out_type = SMP_T_STR;
1600 conv.private = (void *)(long)match;
1601 switch (match) {
1602 case PAT_MATCH_STR: conv.in_type = SMP_T_STR; break;
1603 case PAT_MATCH_BEG: conv.in_type = SMP_T_STR; break;
1604 case PAT_MATCH_SUB: conv.in_type = SMP_T_STR; break;
1605 case PAT_MATCH_DIR: conv.in_type = SMP_T_STR; break;
1606 case PAT_MATCH_DOM: conv.in_type = SMP_T_STR; break;
1607 case PAT_MATCH_END: conv.in_type = SMP_T_STR; break;
1608 case PAT_MATCH_REG: conv.in_type = SMP_T_STR; break;
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001609 case PAT_MATCH_INT: conv.in_type = SMP_T_SINT; break;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001610 case PAT_MATCH_IP: conv.in_type = SMP_T_ADDR; break;
1611 default:
1612 WILL_LJMP(luaL_error(L, "'new' doesn't support this match mode."));
1613 }
1614
1615 /* fill fake args. */
1616 args[0].type = ARGT_STR;
Christopher Faulet73292e92020-08-06 08:40:09 +02001617 args[0].data.str.area = strdup(fn);
1618 args[0].data.str.data = strlen(fn);
1619 args[0].data.str.size = args[0].data.str.data+1;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001620 args[1].type = ARGT_STOP;
1621
1622 /* load the map. */
1623 if (!sample_load_map(args, &conv, file, line, &err)) {
1624 /* error case: we cant use luaL_error because we must
1625 * free the err variable.
1626 */
1627 luaL_where(L, 1);
1628 lua_pushfstring(L, "'new': %s.", err);
1629 lua_concat(L, 2);
1630 free(err);
Christopher Faulet6ad7df42020-08-07 11:45:18 +02001631 chunk_destroy(&args[0].data.str);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001632 WILL_LJMP(lua_error(L));
1633 }
1634
1635 /* create the lua object. */
1636 lua_newtable(L);
1637 lua_pushlightuserdata(L, args[0].data.map);
1638 lua_rawseti(L, -2, 0);
1639
1640 /* Pop a class Map metatable and affect it to the userdata. */
1641 lua_rawgeti(L, LUA_REGISTRYINDEX, class_map_ref);
1642 lua_setmetatable(L, -2);
1643
1644
1645 return 1;
1646}
1647
1648__LJMP static inline int _hlua_map_lookup(struct lua_State *L, int str)
1649{
1650 struct map_descriptor *desc;
1651 struct pattern *pat;
1652 struct sample smp;
1653
1654 MAY_LJMP(check_args(L, 2, "lookup"));
1655 desc = MAY_LJMP(hlua_checkmap(L, 1));
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001656 if (desc->pat.expect_type == SMP_T_SINT) {
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001657 smp.data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001658 smp.data.u.sint = MAY_LJMP(luaL_checkinteger(L, 2));
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001659 }
1660 else {
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001661 smp.data.type = SMP_T_STR;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001662 smp.flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001663 smp.data.u.str.area = (char *)MAY_LJMP(luaL_checklstring(L, 2, (size_t *)&smp.data.u.str.data));
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001664 }
1665
1666 pat = pattern_exec_match(&desc->pat, &smp, 1);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001667 if (!pat || !pat->data) {
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001668 if (str)
1669 lua_pushstring(L, "");
1670 else
1671 lua_pushnil(L);
1672 return 1;
1673 }
1674
1675 /* The Lua pattern must return a string, so we can't check the returned type */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001676 lua_pushlstring(L, pat->data->u.str.area, pat->data->u.str.data);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001677 return 1;
1678}
1679
1680__LJMP static int hlua_map_lookup(struct lua_State *L)
1681{
1682 return _hlua_map_lookup(L, 0);
1683}
1684
1685__LJMP static int hlua_map_slookup(struct lua_State *L)
1686{
1687 return _hlua_map_lookup(L, 1);
1688}
1689
1690/*
1691 *
1692 *
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001693 * Class Socket
1694 *
1695 *
1696 */
1697
1698__LJMP static struct hlua_socket *hlua_checksocket(lua_State *L, int ud)
1699{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02001700 return MAY_LJMP(hlua_checkudata(L, ud, class_socket_ref));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001701}
1702
1703/* This function is the handler called for each I/O on the established
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001704 * connection. It is used for notify space available to send or data
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001705 * received.
1706 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02001707static void hlua_socket_handler(struct appctx *appctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001708{
Willy Tarreau00a37f02015-04-13 12:05:19 +02001709 struct stream_interface *si = appctx->owner;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001710
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02001711 if (appctx->ctx.hlua_cosocket.die) {
1712 si_shutw(si);
1713 si_shutr(si);
1714 si_ic(si)->flags |= CF_READ_NULL;
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001715 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1716 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02001717 stream_shutdown(si_strm(si), SF_ERR_KILLED);
1718 }
1719
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001720 /* If we cant write, wakeup the pending write signals. */
1721 if (channel_output_closed(si_ic(si)))
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001722 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001723
1724 /* If we cant read, wakeup the pending read signals. */
1725 if (channel_input_closed(si_oc(si)))
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001726 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001727
Willy Tarreau5a0b25d2019-07-18 18:01:14 +02001728 /* if the connection is not established, inform the stream that we want
Thierry FOURNIER316e3192015-09-04 18:25:53 +02001729 * to be notified whenever the connection completes.
1730 */
Willy Tarreau5a0b25d2019-07-18 18:01:14 +02001731 if (si_opposite(si)->state < SI_ST_EST) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01001732 si_cant_get(si);
Willy Tarreau12c24232018-12-06 15:29:50 +01001733 si_rx_conn_blk(si);
Willy Tarreau3367d412018-11-15 10:57:41 +01001734 si_rx_endp_more(si);
Willy Tarreaud4da1962015-04-20 01:31:23 +02001735 return;
Thierry FOURNIER316e3192015-09-04 18:25:53 +02001736 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001737
1738 /* This function is called after the connect. */
Thierry FOURNIER18d09902016-12-16 09:25:38 +01001739 appctx->ctx.hlua_cosocket.connected = 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001740
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001741 /* Wake the tasks which wants to write if the buffer have available space. */
Thierry FOURNIEReba6f642015-09-26 22:01:07 +02001742 if (channel_may_recv(si_ic(si)))
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001743 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001744
1745 /* Wake the tasks which wants to read if the buffer contains data. */
Thierry FOURNIEReba6f642015-09-26 22:01:07 +02001746 if (!channel_is_empty(si_oc(si)))
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001747 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
Thierry FOURNIER101b9762018-05-27 01:27:40 +02001748
1749 /* Some data were injected in the buffer, notify the stream
1750 * interface.
1751 */
1752 if (!channel_is_empty(si_ic(si)))
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01001753 si_update(si);
Thierry FOURNIER101b9762018-05-27 01:27:40 +02001754
1755 /* If write notifications are registered, we considers we want
Willy Tarreau3367d412018-11-15 10:57:41 +01001756 * to write, so we clear the blocking flag.
Thierry FOURNIER101b9762018-05-27 01:27:40 +02001757 */
1758 if (notification_registered(&appctx->ctx.hlua_cosocket.wake_on_write))
Willy Tarreau3367d412018-11-15 10:57:41 +01001759 si_rx_endp_more(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001760}
1761
Willy Tarreau87b09662015-04-03 00:22:06 +02001762/* This function is called when the "struct stream" is destroyed.
1763 * Remove the link from the object to this stream.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001764 * Wake all the pending signals.
1765 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02001766static void hlua_socket_release(struct appctx *appctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001767{
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001768 struct xref *peer;
1769
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001770 /* Remove my link in the original object. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001771 peer = xref_get_peer_and_lock(&appctx->ctx.hlua_cosocket.xref);
1772 if (peer)
1773 xref_disconnect(&appctx->ctx.hlua_cosocket.xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001774
1775 /* Wake all the task waiting for me. */
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001776 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1777 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001778}
1779
1780/* If the garbage collectio of the object is launch, nobody
Willy Tarreau87b09662015-04-03 00:22:06 +02001781 * uses this object. If the stream does not exists, just quit.
1782 * Send the shutdown signal to the stream. In some cases,
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001783 * pending signal can rest in the read and write lists. destroy
1784 * it.
1785 */
1786__LJMP static int hlua_socket_gc(lua_State *L)
1787{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001788 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001789 struct appctx *appctx;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001790 struct xref *peer;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001791
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001792 MAY_LJMP(check_args(L, 1, "__gc"));
1793
1794 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001795 peer = xref_get_peer_and_lock(&socket->xref);
1796 if (!peer)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001797 return 0;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001798 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001799
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001800 /* Set the flag which destroy the session. */
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02001801 appctx->ctx.hlua_cosocket.die = 1;
1802 appctx_wakeup(appctx);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001803
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001804 /* Remove all reference between the Lua stack and the coroutine stream. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001805 xref_disconnect(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001806 return 0;
1807}
1808
1809/* The close function send shutdown signal and break the
Willy Tarreau87b09662015-04-03 00:22:06 +02001810 * links between the stream and the object.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001811 */
sada05ed3302018-05-11 11:48:18 -07001812__LJMP static int hlua_socket_close_helper(lua_State *L)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001813{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001814 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001815 struct appctx *appctx;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001816 struct xref *peer;
Willy Tarreauf31af932020-01-14 09:59:38 +01001817 struct hlua *hlua = hlua_gethlua(L);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001818
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001819 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02001820
1821 /* Check if we run on the same thread than the xreator thread.
1822 * We cannot access to the socket if the thread is different.
1823 */
1824 if (socket->tid != tid)
1825 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
1826
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001827 peer = xref_get_peer_and_lock(&socket->xref);
1828 if (!peer)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001829 return 0;
Willy Tarreauf31af932020-01-14 09:59:38 +01001830
1831 hlua->gc_count--;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001832 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001833
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001834 /* Set the flag which destroy the session. */
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02001835 appctx->ctx.hlua_cosocket.die = 1;
1836 appctx_wakeup(appctx);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001837
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001838 /* Remove all reference between the Lua stack and the coroutine stream. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001839 xref_disconnect(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001840 return 0;
1841}
1842
sada05ed3302018-05-11 11:48:18 -07001843/* The close function calls close_helper.
1844 */
1845__LJMP static int hlua_socket_close(lua_State *L)
1846{
1847 MAY_LJMP(check_args(L, 1, "close"));
1848 return hlua_socket_close_helper(L);
1849}
1850
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001851/* This Lua function assumes that the stack contain three parameters.
1852 * 1 - USERDATA containing a struct socket
1853 * 2 - INTEGER with values of the macro defined below
1854 * If the integer is -1, we must read at most one line.
1855 * If the integer is -2, we ust read all the data until the
1856 * end of the stream.
1857 * If the integer is positive value, we must read a number of
1858 * bytes corresponding to this value.
1859 */
1860#define HLSR_READ_LINE (-1)
1861#define HLSR_READ_ALL (-2)
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001862__LJMP static int hlua_socket_receive_yield(struct lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001863{
1864 struct hlua_socket *socket = MAY_LJMP(hlua_checksocket(L, 1));
1865 int wanted = lua_tointeger(L, 2);
1866 struct hlua *hlua = hlua_gethlua(L);
1867 struct appctx *appctx;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02001868 size_t len;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001869 int nblk;
Willy Tarreau206ba832018-06-14 15:27:31 +02001870 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02001871 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02001872 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02001873 size_t len2;
Thierry FOURNIER00543922015-03-09 18:35:06 +01001874 int skip_at_end = 0;
Willy Tarreau81389672015-03-10 12:03:52 +01001875 struct channel *oc;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001876 struct stream_interface *si;
1877 struct stream *s;
1878 struct xref *peer;
Thierry FOURNIER8c126c72018-05-25 16:27:44 +02001879 int missing_bytes;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001880
1881 /* Check if this lua stack is schedulable. */
1882 if (!hlua || !hlua->task)
1883 WILL_LJMP(luaL_error(L, "The 'receive' function is only allowed in "
1884 "'frontend', 'backend' or 'task'"));
1885
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02001886 /* Check if we run on the same thread than the xreator thread.
1887 * We cannot access to the socket if the thread is different.
1888 */
1889 if (socket->tid != tid)
1890 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
1891
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001892 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001893 peer = xref_get_peer_and_lock(&socket->xref);
1894 if (!peer)
1895 goto no_peer;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001896 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
1897 si = appctx->owner;
1898 s = si_strm(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001899
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001900 oc = &s->res;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001901 if (wanted == HLSR_READ_LINE) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001902 /* Read line. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02001903 nblk = co_getline_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001904 if (nblk < 0) /* Connection close. */
1905 goto connection_closed;
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001906 if (nblk == 0) /* No data available. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001907 goto connection_empty;
Thierry FOURNIER00543922015-03-09 18:35:06 +01001908
1909 /* remove final \r\n. */
1910 if (nblk == 1) {
1911 if (blk1[len1-1] == '\n') {
1912 len1--;
1913 skip_at_end++;
1914 if (blk1[len1-1] == '\r') {
1915 len1--;
1916 skip_at_end++;
1917 }
1918 }
1919 }
1920 else {
1921 if (blk2[len2-1] == '\n') {
1922 len2--;
1923 skip_at_end++;
1924 if (blk2[len2-1] == '\r') {
1925 len2--;
1926 skip_at_end++;
1927 }
1928 }
1929 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001930 }
1931
1932 else if (wanted == HLSR_READ_ALL) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001933 /* Read all the available data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02001934 nblk = co_getblk_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001935 if (nblk < 0) /* Connection close. */
1936 goto connection_closed;
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001937 if (nblk == 0) /* No data available. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001938 goto connection_empty;
1939 }
1940
1941 else {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001942 /* Read a block of data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02001943 nblk = co_getblk_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001944 if (nblk < 0) /* Connection close. */
1945 goto connection_closed;
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001946 if (nblk == 0) /* No data available. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001947 goto connection_empty;
1948
Thierry FOURNIER8c126c72018-05-25 16:27:44 +02001949 missing_bytes = wanted - socket->b.n;
1950 if (len1 > missing_bytes) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001951 nblk = 1;
Thierry FOURNIER8c126c72018-05-25 16:27:44 +02001952 len1 = missing_bytes;
1953 } if (nblk == 2 && len1 + len2 > missing_bytes)
1954 len2 = missing_bytes - len1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001955 }
1956
1957 len = len1;
1958
1959 luaL_addlstring(&socket->b, blk1, len1);
1960 if (nblk == 2) {
1961 len += len2;
1962 luaL_addlstring(&socket->b, blk2, len2);
1963 }
1964
1965 /* Consume data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02001966 co_skip(oc, len + skip_at_end);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001967
1968 /* Don't wait anything. */
Thierry FOURNIER7e4ee472018-05-25 15:03:50 +02001969 appctx_wakeup(appctx);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001970
1971 /* If the pattern reclaim to read all the data
1972 * in the connection, got out.
1973 */
1974 if (wanted == HLSR_READ_ALL)
1975 goto connection_empty;
Thierry FOURNIER8c126c72018-05-25 16:27:44 +02001976 else if (wanted >= 0 && socket->b.n < wanted)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001977 goto connection_empty;
1978
1979 /* Return result. */
1980 luaL_pushresult(&socket->b);
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001981 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001982 return 1;
1983
1984connection_closed:
1985
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001986 xref_unlock(&socket->xref, peer);
1987
1988no_peer:
1989
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001990 /* If the buffer containds data. */
1991 if (socket->b.n > 0) {
1992 luaL_pushresult(&socket->b);
1993 return 1;
1994 }
1995 lua_pushnil(L);
1996 lua_pushstring(L, "connection closed.");
1997 return 2;
1998
1999connection_empty:
2000
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002001 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_read, hlua->task)) {
2002 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002003 WILL_LJMP(luaL_error(L, "out of memory"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002004 }
2005 xref_unlock(&socket->xref, peer);
Willy Tarreau9635e032018-10-16 17:52:55 +02002006 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_receive_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002007 return 0;
2008}
2009
Tim Duesterhusb33754c2018-01-04 19:32:14 +01002010/* This Lua function gets two parameters. The first one can be string
2011 * or a number. If the string is "*l", the user requires one line. If
2012 * the string is "*a", the user requires all the contents of the stream.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002013 * If the value is a number, the user require a number of bytes equal
2014 * to the value. The default value is "*l" (a line).
2015 *
Tim Duesterhusb33754c2018-01-04 19:32:14 +01002016 * This parameter with a variable type is converted in integer. This
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002017 * integer takes this values:
2018 * -1 : read a line
2019 * -2 : read all the stream
Tim Duesterhusb33754c2018-01-04 19:32:14 +01002020 * >0 : amount of bytes.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002021 *
Tim Duesterhusb33754c2018-01-04 19:32:14 +01002022 * The second parameter is optional. It contains a string that must be
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002023 * concatenated with the read data.
2024 */
2025__LJMP static int hlua_socket_receive(struct lua_State *L)
2026{
2027 int wanted = HLSR_READ_LINE;
2028 const char *pattern;
2029 int type;
2030 char *error;
2031 size_t len;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002032 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002033
2034 if (lua_gettop(L) < 1 || lua_gettop(L) > 3)
2035 WILL_LJMP(luaL_error(L, "The 'receive' function requires between 1 and 3 arguments."));
2036
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002037 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002038
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002039 /* Check if we run on the same thread than the xreator thread.
2040 * We cannot access to the socket if the thread is different.
2041 */
2042 if (socket->tid != tid)
2043 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2044
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002045 /* check for pattern. */
2046 if (lua_gettop(L) >= 2) {
2047 type = lua_type(L, 2);
2048 if (type == LUA_TSTRING) {
2049 pattern = lua_tostring(L, 2);
2050 if (strcmp(pattern, "*a") == 0)
2051 wanted = HLSR_READ_ALL;
2052 else if (strcmp(pattern, "*l") == 0)
2053 wanted = HLSR_READ_LINE;
2054 else {
2055 wanted = strtoll(pattern, &error, 10);
2056 if (*error != '\0')
2057 WILL_LJMP(luaL_error(L, "Unsupported pattern."));
2058 }
2059 }
2060 else if (type == LUA_TNUMBER) {
2061 wanted = lua_tointeger(L, 2);
2062 if (wanted < 0)
2063 WILL_LJMP(luaL_error(L, "Unsupported size."));
2064 }
2065 }
2066
2067 /* Set pattern. */
2068 lua_pushinteger(L, wanted);
Tim Duesterhusc6e377e2018-01-04 19:32:13 +01002069
2070 /* Check if we would replace the top by itself. */
2071 if (lua_gettop(L) != 2)
2072 lua_replace(L, 2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002073
Tim Duesterhusb33754c2018-01-04 19:32:14 +01002074 /* init buffer, and fill it with prefix. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002075 luaL_buffinit(L, &socket->b);
2076
2077 /* Check prefix. */
2078 if (lua_gettop(L) >= 3) {
2079 if (lua_type(L, 3) != LUA_TSTRING)
2080 WILL_LJMP(luaL_error(L, "Expect a 'string' for the prefix"));
2081 pattern = lua_tolstring(L, 3, &len);
2082 luaL_addlstring(&socket->b, pattern, len);
2083 }
2084
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002085 return __LJMP(hlua_socket_receive_yield(L, 0, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002086}
2087
2088/* Write the Lua input string in the output buffer.
Mark Lakes22154b42018-01-29 14:38:40 -08002089 * This function returns a yield if no space is available.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002090 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002091static int hlua_socket_write_yield(struct lua_State *L,int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002092{
2093 struct hlua_socket *socket;
2094 struct hlua *hlua = hlua_gethlua(L);
2095 struct appctx *appctx;
2096 size_t buf_len;
2097 const char *buf;
2098 int len;
2099 int send_len;
2100 int sent;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002101 struct xref *peer;
2102 struct stream_interface *si;
2103 struct stream *s;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002104
2105 /* Check if this lua stack is schedulable. */
2106 if (!hlua || !hlua->task)
2107 WILL_LJMP(luaL_error(L, "The 'write' function is only allowed in "
2108 "'frontend', 'backend' or 'task'"));
2109
2110 /* Get object */
2111 socket = MAY_LJMP(hlua_checksocket(L, 1));
2112 buf = MAY_LJMP(luaL_checklstring(L, 2, &buf_len));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002113 sent = MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002114
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002115 /* Check if we run on the same thread than the xreator thread.
2116 * We cannot access to the socket if the thread is different.
2117 */
2118 if (socket->tid != tid)
2119 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2120
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002121 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002122 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002123 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002124 lua_pushinteger(L, -1);
2125 return 1;
2126 }
2127 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2128 si = appctx->owner;
2129 s = si_strm(si);
2130
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002131 /* Check for connection close. */
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002132 if (channel_output_closed(&s->req)) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002133 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002134 lua_pushinteger(L, -1);
2135 return 1;
2136 }
2137
2138 /* Update the input buffer data. */
2139 buf += sent;
2140 send_len = buf_len - sent;
2141
2142 /* All the data are sent. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002143 if (sent >= buf_len) {
2144 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002145 return 1; /* Implicitly return the length sent. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002146 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002147
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002148 /* Check if the buffer is available because HAProxy doesn't allocate
Thierry FOURNIER486d52a2015-03-09 17:51:43 +01002149 * the request buffer if its not required.
2150 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002151 if (s->req.buf.size == 0) {
Willy Tarreau581abd32018-10-25 10:21:41 +02002152 if (!si_alloc_ibuf(si, &appctx->buffer_wait))
Christopher Faulet33834b12016-12-19 09:29:06 +01002153 goto hlua_socket_write_yield_return;
Thierry FOURNIER486d52a2015-03-09 17:51:43 +01002154 }
2155
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002156 /* Check for available space. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002157 len = b_room(&s->req.buf);
Christopher Faulet33834b12016-12-19 09:29:06 +01002158 if (len <= 0) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002159 goto hlua_socket_write_yield_return;
Christopher Faulet33834b12016-12-19 09:29:06 +01002160 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002161
2162 /* send data */
2163 if (len < send_len)
2164 send_len = len;
Thierry FOURNIER66b89192018-05-27 01:14:47 +02002165 len = ci_putblk(&s->req, buf, send_len);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002166
2167 /* "Not enough space" (-1), "Buffer too little to contain
2168 * the data" (-2) are not expected because the available length
2169 * is tested.
2170 * Other unknown error are also not expected.
2171 */
2172 if (len <= 0) {
Willy Tarreaubc18da12015-03-13 14:00:47 +01002173 if (len == -1)
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002174 s->req.flags |= CF_WAKE_WRITE;
Willy Tarreaubc18da12015-03-13 14:00:47 +01002175
sada05ed3302018-05-11 11:48:18 -07002176 MAY_LJMP(hlua_socket_close_helper(L));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002177 lua_pop(L, 1);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002178 lua_pushinteger(L, -1);
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002179 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002180 return 1;
2181 }
2182
2183 /* update buffers. */
Thierry FOURNIER101b9762018-05-27 01:27:40 +02002184 appctx_wakeup(appctx);
Willy Tarreaude70fa12015-09-26 11:25:05 +02002185
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002186 s->req.rex = TICK_ETERNITY;
2187 s->res.wex = TICK_ETERNITY;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002188
2189 /* Update length sent. */
2190 lua_pop(L, 1);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002191 lua_pushinteger(L, sent + len);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002192
2193 /* All the data buffer is sent ? */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002194 if (sent + len >= buf_len) {
2195 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002196 return 1;
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002197 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002198
2199hlua_socket_write_yield_return:
Thierry FOURNIERba42fcd2018-05-27 00:59:48 +02002200 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task)) {
2201 xref_unlock(&socket->xref, peer);
2202 WILL_LJMP(luaL_error(L, "out of memory"));
2203 }
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002204 xref_unlock(&socket->xref, peer);
Willy Tarreau9635e032018-10-16 17:52:55 +02002205 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_write_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002206 return 0;
2207}
2208
2209/* This function initiate the send of data. It just check the input
2210 * parameters and push an integer in the Lua stack that contain the
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002211 * amount of data written to the buffer. This is used by the function
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002212 * "hlua_socket_write_yield" that can yield.
2213 *
2214 * The Lua function gets between 3 and 4 parameters. The first one is
2215 * the associated object. The second is a string buffer. The third is
2216 * a facultative integer that represents where is the buffer position
2217 * of the start of the data that can send. The first byte is the
2218 * position "1". The default value is "1". The fourth argument is a
2219 * facultative integer that represents where is the buffer position
2220 * of the end of the data that can send. The default is the last byte.
2221 */
2222static int hlua_socket_send(struct lua_State *L)
2223{
2224 int i;
2225 int j;
2226 const char *buf;
2227 size_t buf_len;
2228
2229 /* Check number of arguments. */
2230 if (lua_gettop(L) < 2 || lua_gettop(L) > 4)
2231 WILL_LJMP(luaL_error(L, "'send' needs between 2 and 4 arguments"));
2232
2233 /* Get the string. */
2234 buf = MAY_LJMP(luaL_checklstring(L, 2, &buf_len));
2235
2236 /* Get and check j. */
2237 if (lua_gettop(L) == 4) {
2238 j = MAY_LJMP(luaL_checkinteger(L, 4));
2239 if (j < 0)
2240 j = buf_len + j + 1;
2241 if (j > buf_len)
2242 j = buf_len + 1;
2243 lua_pop(L, 1);
2244 }
2245 else
2246 j = buf_len;
2247
2248 /* Get and check i. */
2249 if (lua_gettop(L) == 3) {
2250 i = MAY_LJMP(luaL_checkinteger(L, 3));
2251 if (i < 0)
2252 i = buf_len + i + 1;
2253 if (i > buf_len)
2254 i = buf_len + 1;
2255 lua_pop(L, 1);
2256 } else
2257 i = 1;
2258
2259 /* Check bth i and j. */
2260 if (i > j) {
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002261 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002262 return 1;
2263 }
2264 if (i == 0 && j == 0) {
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002265 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002266 return 1;
2267 }
2268 if (i == 0)
2269 i = 1;
2270 if (j == 0)
2271 j = 1;
2272
2273 /* Pop the string. */
2274 lua_pop(L, 1);
2275
2276 /* Update the buffer length. */
2277 buf += i - 1;
2278 buf_len = j - i + 1;
2279 lua_pushlstring(L, buf, buf_len);
2280
2281 /* This unsigned is used to remember the amount of sent data. */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002282 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002283
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002284 return MAY_LJMP(hlua_socket_write_yield(L, 0, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002285}
2286
Willy Tarreau22b0a682015-06-17 19:43:49 +02002287#define SOCKET_INFO_MAX_LEN sizeof("[0000:0000:0000:0000:0000:0000:0000:0000]:12345")
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002288__LJMP static inline int hlua_socket_info(struct lua_State *L, struct sockaddr_storage *addr)
2289{
2290 static char buffer[SOCKET_INFO_MAX_LEN];
2291 int ret;
2292 int len;
2293 char *p;
2294
2295 ret = addr_to_str(addr, buffer+1, SOCKET_INFO_MAX_LEN-1);
2296 if (ret <= 0) {
2297 lua_pushnil(L);
2298 return 1;
2299 }
2300
2301 if (ret == AF_UNIX) {
2302 lua_pushstring(L, buffer+1);
2303 return 1;
2304 }
2305 else if (ret == AF_INET6) {
2306 buffer[0] = '[';
2307 len = strlen(buffer);
2308 buffer[len] = ']';
2309 len++;
2310 buffer[len] = ':';
2311 len++;
2312 p = buffer;
2313 }
2314 else if (ret == AF_INET) {
2315 p = buffer + 1;
2316 len = strlen(p);
2317 p[len] = ':';
2318 len++;
2319 }
2320 else {
2321 lua_pushnil(L);
2322 return 1;
2323 }
2324
2325 if (port_to_str(addr, p + len, SOCKET_INFO_MAX_LEN-1 - len) <= 0) {
2326 lua_pushnil(L);
2327 return 1;
2328 }
2329
2330 lua_pushstring(L, p);
2331 return 1;
2332}
2333
2334/* Returns information about the peer of the connection. */
2335__LJMP static int hlua_socket_getpeername(struct lua_State *L)
2336{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002337 struct hlua_socket *socket;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002338 struct xref *peer;
2339 struct appctx *appctx;
2340 struct stream_interface *si;
2341 struct stream *s;
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002342 int ret;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002343
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002344 MAY_LJMP(check_args(L, 1, "getpeername"));
2345
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002346 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002347
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002348 /* Check if we run on the same thread than the xreator thread.
2349 * We cannot access to the socket if the thread is different.
2350 */
2351 if (socket->tid != tid)
2352 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2353
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002354 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002355 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002356 if (!peer) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002357 lua_pushnil(L);
2358 return 1;
2359 }
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002360 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2361 si = appctx->owner;
2362 s = si_strm(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002363
Willy Tarreau5a0b25d2019-07-18 18:01:14 +02002364 if (!s->target_addr) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002365 xref_unlock(&socket->xref, peer);
Willy Tarreaua71f6422016-11-16 17:00:14 +01002366 lua_pushnil(L);
2367 return 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002368 }
2369
Willy Tarreau5a0b25d2019-07-18 18:01:14 +02002370 ret = MAY_LJMP(hlua_socket_info(L, s->target_addr));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002371 xref_unlock(&socket->xref, peer);
2372 return ret;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002373}
2374
2375/* Returns information about my connection side. */
2376static int hlua_socket_getsockname(struct lua_State *L)
2377{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002378 struct hlua_socket *socket;
2379 struct connection *conn;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002380 struct appctx *appctx;
2381 struct xref *peer;
2382 struct stream_interface *si;
2383 struct stream *s;
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002384 int ret;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002385
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002386 MAY_LJMP(check_args(L, 1, "getsockname"));
2387
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002388 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002389
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002390 /* Check if we run on the same thread than the xreator thread.
2391 * We cannot access to the socket if the thread is different.
2392 */
2393 if (socket->tid != tid)
2394 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2395
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002396 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002397 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002398 if (!peer) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002399 lua_pushnil(L);
2400 return 1;
2401 }
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002402 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2403 si = appctx->owner;
2404 s = si_strm(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002405
Olivier Houchard9aaf7782017-09-13 18:30:23 +02002406 conn = cs_conn(objt_cs(s->si[1].end));
Willy Tarreau5a0b25d2019-07-18 18:01:14 +02002407 if (!conn || !conn_get_src(conn)) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002408 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002409 lua_pushnil(L);
2410 return 1;
2411 }
2412
Willy Tarreau9da9a6f2019-07-17 14:49:44 +02002413 ret = hlua_socket_info(L, conn->src);
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002414 xref_unlock(&socket->xref, peer);
2415 return ret;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002416}
2417
2418/* This struct define the applet. */
Willy Tarreau30576452015-04-13 13:50:30 +02002419static struct applet update_applet = {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002420 .obj_type = OBJ_TYPE_APPLET,
2421 .name = "<LUA_TCP>",
2422 .fct = hlua_socket_handler,
2423 .release = hlua_socket_release,
2424};
2425
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002426__LJMP static int hlua_socket_connect_yield(struct lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002427{
2428 struct hlua_socket *socket = MAY_LJMP(hlua_checksocket(L, 1));
2429 struct hlua *hlua = hlua_gethlua(L);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002430 struct xref *peer;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002431 struct appctx *appctx;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002432 struct stream_interface *si;
2433 struct stream *s;
2434
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002435 /* Check if we run on the same thread than the xreator thread.
2436 * We cannot access to the socket if the thread is different.
2437 */
2438 if (socket->tid != tid)
2439 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2440
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002441 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002442 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002443 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002444 lua_pushnil(L);
2445 lua_pushstring(L, "Can't connect");
2446 return 2;
2447 }
2448 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2449 si = appctx->owner;
2450 s = si_strm(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002451
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002452 /* Check if we run on the same thread than the xreator thread.
2453 * We cannot access to the socket if the thread is different.
2454 */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002455 if (socket->tid != tid) {
2456 xref_unlock(&socket->xref, peer);
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002457 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002458 }
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002459
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002460 /* Check for connection close. */
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002461 if (!hlua || channel_output_closed(&s->req)) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002462 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002463 lua_pushnil(L);
2464 lua_pushstring(L, "Can't connect");
2465 return 2;
2466 }
2467
Willy Tarreaue09101e2018-10-16 17:37:12 +02002468 appctx = __objt_appctx(s->si[0].end);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002469
2470 /* Check for connection established. */
Thierry FOURNIER18d09902016-12-16 09:25:38 +01002471 if (appctx->ctx.hlua_cosocket.connected) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002472 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002473 lua_pushinteger(L, 1);
2474 return 1;
2475 }
2476
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002477 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task)) {
2478 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002479 WILL_LJMP(luaL_error(L, "out of memory error"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002480 }
2481 xref_unlock(&socket->xref, peer);
Willy Tarreau9635e032018-10-16 17:52:55 +02002482 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_connect_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002483 return 0;
2484}
2485
2486/* This function fail or initite the connection. */
2487__LJMP static int hlua_socket_connect(struct lua_State *L)
2488{
2489 struct hlua_socket *socket;
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002490 int port = -1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002491 const char *ip;
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002492 struct hlua *hlua;
2493 struct appctx *appctx;
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002494 int low, high;
2495 struct sockaddr_storage *addr;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002496 struct xref *peer;
2497 struct stream_interface *si;
2498 struct stream *s;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002499
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002500 if (lua_gettop(L) < 2)
2501 WILL_LJMP(luaL_error(L, "connect: need at least 2 arguments"));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002502
2503 /* Get args. */
2504 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002505
2506 /* Check if we run on the same thread than the xreator thread.
2507 * We cannot access to the socket if the thread is different.
2508 */
2509 if (socket->tid != tid)
2510 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2511
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002512 ip = MAY_LJMP(luaL_checkstring(L, 2));
Tim Duesterhus6edab862018-01-06 19:04:45 +01002513 if (lua_gettop(L) >= 3) {
2514 luaL_Buffer b;
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002515 port = MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002516
Tim Duesterhus6edab862018-01-06 19:04:45 +01002517 /* Force the ip to end with a colon, to support IPv6 addresses
2518 * that are not enclosed within square brackets.
2519 */
2520 if (port > 0) {
2521 luaL_buffinit(L, &b);
2522 luaL_addstring(&b, ip);
2523 luaL_addchar(&b, ':');
2524 luaL_pushresult(&b);
2525 ip = lua_tolstring(L, lua_gettop(L), NULL);
2526 }
2527 }
2528
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002529 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002530 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002531 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002532 lua_pushnil(L);
2533 return 1;
2534 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002535
2536 /* Parse ip address. */
Willy Tarreau48ef4c92017-01-06 18:32:38 +01002537 addr = str2sa_range(ip, NULL, &low, &high, NULL, NULL, NULL, 0);
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002538 if (!addr) {
2539 xref_unlock(&socket->xref, peer);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002540 WILL_LJMP(luaL_error(L, "connect: cannot parse destination address '%s'", ip));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002541 }
2542 if (low != high) {
2543 xref_unlock(&socket->xref, peer);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002544 WILL_LJMP(luaL_error(L, "connect: port ranges not supported : address '%s'", ip));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002545 }
Willy Tarreau9da9a6f2019-07-17 14:49:44 +02002546
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002547 /* Set port. */
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002548 if (low == 0) {
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002549 if (addr->ss_family == AF_INET) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002550 if (port == -1) {
2551 xref_unlock(&socket->xref, peer);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002552 WILL_LJMP(luaL_error(L, "connect: port missing"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002553 }
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002554 ((struct sockaddr_in *)addr)->sin_port = htons(port);
2555 } else if (addr->ss_family == AF_INET6) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002556 if (port == -1) {
2557 xref_unlock(&socket->xref, peer);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002558 WILL_LJMP(luaL_error(L, "connect: port missing"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002559 }
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002560 ((struct sockaddr_in6 *)addr)->sin6_port = htons(port);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002561 }
2562 }
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002563
Willy Tarreau5a0b25d2019-07-18 18:01:14 +02002564 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2565 si = appctx->owner;
2566 s = si_strm(si);
Willy Tarreau1c8d32b2019-07-18 15:47:45 +02002567
2568 if (!sockaddr_alloc(&s->target_addr)) {
2569 xref_unlock(&socket->xref, peer);
2570 WILL_LJMP(luaL_error(L, "connect: internal error"));
2571 }
2572 *s->target_addr = *addr;
Willy Tarreau5a0b25d2019-07-18 18:01:14 +02002573 s->flags |= SF_ADDR_SET;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002574
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002575 hlua = hlua_gethlua(L);
Willy Tarreaubdc97a82015-08-24 15:42:28 +02002576
2577 /* inform the stream that we want to be notified whenever the
2578 * connection completes.
2579 */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002580 si_cant_get(&s->si[0]);
Willy Tarreau3367d412018-11-15 10:57:41 +01002581 si_rx_endp_more(&s->si[0]);
Thierry FOURNIER8c8fbbe2015-09-26 17:02:35 +02002582 appctx_wakeup(appctx);
Willy Tarreaubdc97a82015-08-24 15:42:28 +02002583
Willy Tarreauf31af932020-01-14 09:59:38 +01002584 hlua->gc_count++;
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +02002585
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002586 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task)) {
2587 xref_unlock(&socket->xref, peer);
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002588 WILL_LJMP(luaL_error(L, "out of memory"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002589 }
2590 xref_unlock(&socket->xref, peer);
PiBa-NL706d5ee2018-05-05 23:51:42 +02002591
2592 task_wakeup(s->task, TASK_WOKEN_INIT);
2593 /* Return yield waiting for connection. */
2594
Willy Tarreau9635e032018-10-16 17:52:55 +02002595 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_connect_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002596
2597 return 0;
2598}
2599
Baptiste Assmann84bb4932015-03-02 21:40:06 +01002600#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002601__LJMP static int hlua_socket_connect_ssl(struct lua_State *L)
2602{
2603 struct hlua_socket *socket;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002604 struct xref *peer;
2605 struct appctx *appctx;
2606 struct stream_interface *si;
2607 struct stream *s;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002608
2609 MAY_LJMP(check_args(L, 3, "connect_ssl"));
2610 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002611
2612 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002613 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002614 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002615 lua_pushnil(L);
2616 return 1;
2617 }
2618 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2619 si = appctx->owner;
2620 s = si_strm(si);
2621
2622 s->target = &socket_ssl.obj_type;
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002623 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002624 return MAY_LJMP(hlua_socket_connect(L));
2625}
Baptiste Assmann84bb4932015-03-02 21:40:06 +01002626#endif
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002627
2628__LJMP static int hlua_socket_setoption(struct lua_State *L)
2629{
2630 return 0;
2631}
2632
2633__LJMP static int hlua_socket_settimeout(struct lua_State *L)
2634{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002635 struct hlua_socket *socket;
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002636 int tmout;
Mark Lakes56cc1252018-03-27 09:48:06 +02002637 double dtmout;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002638 struct xref *peer;
2639 struct appctx *appctx;
2640 struct stream_interface *si;
2641 struct stream *s;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002642
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002643 MAY_LJMP(check_args(L, 2, "settimeout"));
2644
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002645 socket = MAY_LJMP(hlua_checksocket(L, 1));
Mark Lakes56cc1252018-03-27 09:48:06 +02002646
Cyril Bonté7ee465f2018-08-19 22:08:50 +02002647 /* convert the timeout to millis */
2648 dtmout = MAY_LJMP(luaL_checknumber(L, 2)) * 1000;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002649
Thierry Fournier17a921b2018-03-08 09:59:02 +01002650 /* Check for negative values */
Mark Lakes56cc1252018-03-27 09:48:06 +02002651 if (dtmout < 0)
Thierry Fournier17a921b2018-03-08 09:59:02 +01002652 WILL_LJMP(luaL_error(L, "settimeout: cannot set negatives values"));
2653
Mark Lakes56cc1252018-03-27 09:48:06 +02002654 if (dtmout > INT_MAX) /* overflow check */
Cyril Bonté7ee465f2018-08-19 22:08:50 +02002655 WILL_LJMP(luaL_error(L, "settimeout: cannot set values larger than %d ms", INT_MAX));
Mark Lakes56cc1252018-03-27 09:48:06 +02002656
2657 tmout = MS_TO_TICKS((int)dtmout);
Cyril Bonté7ee465f2018-08-19 22:08:50 +02002658 if (tmout == 0)
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05002659 tmout++; /* very small timeouts are adjusted to a minimum of 1ms */
Mark Lakes56cc1252018-03-27 09:48:06 +02002660
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002661 /* Check if we run on the same thread than the xreator thread.
2662 * We cannot access to the socket if the thread is different.
2663 */
2664 if (socket->tid != tid)
2665 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2666
Mark Lakes56cc1252018-03-27 09:48:06 +02002667 /* check for connection break. If some data were read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002668 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002669 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002670 hlua_pusherror(L, "socket: not yet initialised, you can't set timeouts.");
2671 WILL_LJMP(lua_error(L));
2672 return 0;
2673 }
2674 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2675 si = appctx->owner;
2676 s = si_strm(si);
2677
Cyril Bonté7bb63452018-08-17 23:51:02 +02002678 s->sess->fe->timeout.connect = tmout;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002679 s->req.rto = tmout;
2680 s->req.wto = tmout;
2681 s->res.rto = tmout;
2682 s->res.wto = tmout;
Cyril Bonté7bb63452018-08-17 23:51:02 +02002683 s->req.rex = tick_add_ifset(now_ms, tmout);
2684 s->req.wex = tick_add_ifset(now_ms, tmout);
2685 s->res.rex = tick_add_ifset(now_ms, tmout);
2686 s->res.wex = tick_add_ifset(now_ms, tmout);
2687
2688 s->task->expire = tick_add_ifset(now_ms, tmout);
2689 task_queue(s->task);
2690
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002691 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002692
Thierry Fourniere9636f12018-03-08 09:54:32 +01002693 lua_pushinteger(L, 1);
Tim Duesterhus119a5f12018-01-06 19:16:25 +01002694 return 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002695}
2696
2697__LJMP static int hlua_socket_new(lua_State *L)
2698{
2699 struct hlua_socket *socket;
2700 struct appctx *appctx;
Willy Tarreau15b5e142015-04-04 14:38:25 +02002701 struct session *sess;
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002702 struct stream *strm;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002703
2704 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002705 if (!lua_checkstack(L, 3)) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002706 hlua_pusherror(L, "socket: full stack");
2707 goto out_fail_conf;
2708 }
2709
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002710 /* Create the object: obj[0] = userdata. */
2711 lua_newtable(L);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002712 socket = MAY_LJMP(lua_newuserdata(L, sizeof(*socket)));
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002713 lua_rawseti(L, -2, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002714 memset(socket, 0, sizeof(*socket));
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002715 socket->tid = tid;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002716
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05002717 /* Check if the various memory pools are initialized. */
Willy Tarreaubafbe012017-11-24 17:34:44 +01002718 if (!pool_head_stream || !pool_head_buffer) {
Thierry FOURNIER4a6170c2015-03-09 17:07:10 +01002719 hlua_pusherror(L, "socket: uninitialized pools.");
2720 goto out_fail_conf;
2721 }
2722
Willy Tarreau87b09662015-04-03 00:22:06 +02002723 /* Pop a class stream metatable and affect it to the userdata. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002724 lua_rawgeti(L, LUA_REGISTRYINDEX, class_socket_ref);
2725 lua_setmetatable(L, -2);
2726
Willy Tarreaud420a972015-04-06 00:39:18 +02002727 /* Create the applet context */
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01002728 appctx = appctx_new(&update_applet, tid_bit);
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002729 if (!appctx) {
2730 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaufeb76402015-04-03 14:10:06 +02002731 goto out_fail_conf;
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002732 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002733
Thierry FOURNIER18d09902016-12-16 09:25:38 +01002734 appctx->ctx.hlua_cosocket.connected = 0;
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02002735 appctx->ctx.hlua_cosocket.die = 0;
Thierry FOURNIER18d09902016-12-16 09:25:38 +01002736 LIST_INIT(&appctx->ctx.hlua_cosocket.wake_on_write);
2737 LIST_INIT(&appctx->ctx.hlua_cosocket.wake_on_read);
Willy Tarreaub2bf8332015-04-04 15:58:58 +02002738
Willy Tarreaud420a972015-04-06 00:39:18 +02002739 /* Now create a session, task and stream for this applet */
2740 sess = session_new(&socket_proxy, NULL, &appctx->obj_type);
2741 if (!sess) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002742 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaud420a972015-04-06 00:39:18 +02002743 goto out_fail_sess;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002744 }
2745
Willy Tarreau87787ac2017-08-28 16:22:54 +02002746 strm = stream_new(sess, &appctx->obj_type);
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002747 if (!strm) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002748 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaud420a972015-04-06 00:39:18 +02002749 goto out_fail_stream;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002750 }
2751
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002752 /* Initialise cross reference between stream and Lua socket object. */
2753 xref_create(&socket->xref, &appctx->ctx.hlua_cosocket.xref);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002754
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002755 /* Configure "right" stream interface. this "si" is used to connect
2756 * and retrieve data from the server. The connection is initialized
2757 * with the "struct server".
2758 */
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002759 si_set_state(&strm->si[1], SI_ST_ASS);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002760
2761 /* Force destination server. */
Willy Tarreau5a0b25d2019-07-18 18:01:14 +02002762 strm->flags |= SF_DIRECT | SF_ASSIGNED | SF_BE_ASSIGNED;
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002763 strm->target = &socket_tcp.obj_type;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002764
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002765 return 1;
2766
Willy Tarreaud420a972015-04-06 00:39:18 +02002767 out_fail_stream:
Willy Tarreau11c36242015-04-04 15:54:03 +02002768 session_free(sess);
Willy Tarreaud420a972015-04-06 00:39:18 +02002769 out_fail_sess:
2770 appctx_free(appctx);
2771 out_fail_conf:
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002772 WILL_LJMP(lua_error(L));
2773 return 0;
2774}
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01002775
2776/*
2777 *
2778 *
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002779 * Class Channel
2780 *
2781 *
2782 */
2783
2784/* Returns the struct hlua_channel join to the class channel in the
2785 * stack entry "ud" or throws an argument error.
2786 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002787__LJMP static struct channel *hlua_checkchannel(lua_State *L, int ud)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002788{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002789 return MAY_LJMP(hlua_checkudata(L, ud, class_channel_ref));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002790}
2791
Willy Tarreau47860ed2015-03-10 14:07:50 +01002792/* Pushes the channel onto the top of the stack. If the stask does not have a
2793 * free slots, the function fails and returns 0;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002794 */
Willy Tarreau2a71af42015-03-10 13:51:50 +01002795static int hlua_channel_new(lua_State *L, struct channel *channel)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002796{
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002797 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002798 if (!lua_checkstack(L, 3))
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002799 return 0;
2800
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002801 lua_newtable(L);
Willy Tarreau47860ed2015-03-10 14:07:50 +01002802 lua_pushlightuserdata(L, channel);
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002803 lua_rawseti(L, -2, 0);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002804
2805 /* Pop a class sesison metatable and affect it to the userdata. */
2806 lua_rawgeti(L, LUA_REGISTRYINDEX, class_channel_ref);
2807 lua_setmetatable(L, -2);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002808 return 1;
2809}
2810
2811/* Duplicate all the data present in the input channel and put it
2812 * in a string LUA variables. Returns -1 and push a nil value in
2813 * the stack if the channel is closed and all the data are consumed,
2814 * returns 0 if no data are available, otherwise it returns the length
Ilya Shipitsind4259502020-04-08 01:07:56 +05002815 * of the built string.
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002816 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002817static inline int _hlua_channel_dup(struct channel *chn, lua_State *L)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002818{
2819 char *blk1;
2820 char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02002821 size_t len1;
2822 size_t len2;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002823 int ret;
2824 luaL_Buffer b;
2825
Willy Tarreau06d80a92017-10-19 14:32:15 +02002826 ret = ci_getblk_nc(chn, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002827 if (unlikely(ret == 0))
2828 return 0;
2829
2830 if (unlikely(ret < 0)) {
2831 lua_pushnil(L);
2832 return -1;
2833 }
2834
2835 luaL_buffinit(L, &b);
2836 luaL_addlstring(&b, blk1, len1);
2837 if (unlikely(ret == 2))
2838 luaL_addlstring(&b, blk2, len2);
2839 luaL_pushresult(&b);
2840
2841 if (unlikely(ret == 2))
2842 return len1 + len2;
2843 return len1;
2844}
2845
2846/* "_hlua_channel_dup" wrapper. If no data are available, it returns
2847 * a yield. This function keep the data in the buffer.
2848 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002849__LJMP static int hlua_channel_dup_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002850{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002851 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002852
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002853 chn = MAY_LJMP(hlua_checkchannel(L, 1));
2854
Thierry Fournier77016da2020-08-15 14:35:51 +02002855 if (chn_strm(chn)->be->mode == PR_MODE_HTTP) {
2856 lua_pushfstring(L, "Cannot manipulate HAProxy channels in HTTP mode.");
Christopher Faulet3f829a42018-12-13 21:56:45 +01002857 WILL_LJMP(lua_error(L));
Thierry Fournier77016da2020-08-15 14:35:51 +02002858 }
Christopher Faulet3f829a42018-12-13 21:56:45 +01002859
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002860 if (_hlua_channel_dup(chn, L) == 0)
Willy Tarreau9635e032018-10-16 17:52:55 +02002861 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_dup_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002862 return 1;
2863}
2864
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002865/* Check arguments for the function "hlua_channel_dup_yield". */
2866__LJMP static int hlua_channel_dup(lua_State *L)
2867{
2868 MAY_LJMP(check_args(L, 1, "dup"));
2869 MAY_LJMP(hlua_checkchannel(L, 1));
2870 return MAY_LJMP(hlua_channel_dup_yield(L, 0, 0));
2871}
2872
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002873/* "_hlua_channel_dup" wrapper. If no data are available, it returns
2874 * a yield. This function consumes the data in the buffer. It returns
2875 * a string containing the data or a nil pointer if no data are available
2876 * and the channel is closed.
2877 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002878__LJMP static int hlua_channel_get_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002879{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002880 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002881 int ret;
2882
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002883 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002884
Thierry Fournier77016da2020-08-15 14:35:51 +02002885 if (chn_strm(chn)->be->mode == PR_MODE_HTTP) {
2886 lua_pushfstring(L, "Cannot manipulate HAProxy channels in HTTP mode.");
Christopher Faulet3f829a42018-12-13 21:56:45 +01002887 WILL_LJMP(lua_error(L));
Thierry Fournier77016da2020-08-15 14:35:51 +02002888 }
Christopher Faulet3f829a42018-12-13 21:56:45 +01002889
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002890 ret = _hlua_channel_dup(chn, L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002891 if (unlikely(ret == 0))
Willy Tarreau9635e032018-10-16 17:52:55 +02002892 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_get_yield, TICK_ETERNITY, 0));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002893
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002894 if (unlikely(ret == -1))
2895 return 1;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002896
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002897 b_sub(&chn->buf, ret);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002898 return 1;
2899}
2900
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002901/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002902__LJMP static int hlua_channel_get(lua_State *L)
2903{
2904 MAY_LJMP(check_args(L, 1, "get"));
2905 MAY_LJMP(hlua_checkchannel(L, 1));
2906 return MAY_LJMP(hlua_channel_get_yield(L, 0, 0));
2907}
2908
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002909/* This functions consumes and returns one line. If the channel is closed,
2910 * and the last data does not contains a final '\n', the data are returned
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002911 * without the final '\n'. When no more data are available, it returns nil
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002912 * value.
2913 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002914__LJMP static int hlua_channel_getline_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002915{
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002916 char *blk1;
2917 char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02002918 size_t len1;
2919 size_t len2;
2920 size_t len;
Willy Tarreau47860ed2015-03-10 14:07:50 +01002921 struct channel *chn;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002922 int ret;
2923 luaL_Buffer b;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002924
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002925 chn = MAY_LJMP(hlua_checkchannel(L, 1));
2926
Thierry Fournier77016da2020-08-15 14:35:51 +02002927 if (chn_strm(chn)->be->mode == PR_MODE_HTTP) {
2928 lua_pushfstring(L, "Cannot manipulate HAProxy channels in HTTP mode.");
Christopher Faulet3f829a42018-12-13 21:56:45 +01002929 WILL_LJMP(lua_error(L));
Thierry Fournier77016da2020-08-15 14:35:51 +02002930 }
Christopher Faulet3f829a42018-12-13 21:56:45 +01002931
Willy Tarreau06d80a92017-10-19 14:32:15 +02002932 ret = ci_getline_nc(chn, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002933 if (ret == 0)
Willy Tarreau9635e032018-10-16 17:52:55 +02002934 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_getline_yield, TICK_ETERNITY, 0));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002935
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002936 if (ret == -1) {
2937 lua_pushnil(L);
2938 return 1;
2939 }
2940
2941 luaL_buffinit(L, &b);
2942 luaL_addlstring(&b, blk1, len1);
2943 len = len1;
2944 if (unlikely(ret == 2)) {
2945 luaL_addlstring(&b, blk2, len2);
2946 len += len2;
2947 }
2948 luaL_pushresult(&b);
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002949 b_rep_blk(&chn->buf, ci_head(chn), ci_head(chn) + len, NULL, 0);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002950 return 1;
2951}
2952
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002953/* Check arguments for the function "hlua_channel_getline_yield". */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002954__LJMP static int hlua_channel_getline(lua_State *L)
2955{
2956 MAY_LJMP(check_args(L, 1, "getline"));
2957 MAY_LJMP(hlua_checkchannel(L, 1));
2958 return MAY_LJMP(hlua_channel_getline_yield(L, 0, 0));
2959}
2960
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002961/* This function takes a string as input, and append it at the
2962 * input side of channel. If the data is too big, but a space
2963 * is probably available after sending some data, the function
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002964 * yields. If the data is bigger than the buffer, or if the
2965 * channel is closed, it returns -1. Otherwise, it returns the
2966 * amount of data written.
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002967 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002968__LJMP static int hlua_channel_append_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002969{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002970 struct channel *chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002971 size_t len;
2972 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
2973 int l = MAY_LJMP(luaL_checkinteger(L, 3));
2974 int ret;
2975 int max;
2976
Thierry Fournier77016da2020-08-15 14:35:51 +02002977 if (chn_strm(chn)->be->mode == PR_MODE_HTTP) {
2978 lua_pushfstring(L, "Cannot manipulate HAProxy channels in HTTP mode.");
Christopher Faulet3f829a42018-12-13 21:56:45 +01002979 WILL_LJMP(lua_error(L));
Thierry Fournier77016da2020-08-15 14:35:51 +02002980 }
Christopher Faulet3f829a42018-12-13 21:56:45 +01002981
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002982 /* Check if the buffer is available because HAProxy doesn't allocate
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002983 * the request buffer if its not required.
2984 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002985 if (chn->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +01002986 si_rx_buff_blk(chn_prod(chn));
Willy Tarreau9635e032018-10-16 17:52:55 +02002987 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002988 }
2989
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002990 max = channel_recv_limit(chn) - b_data(&chn->buf);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002991 if (max > len - l)
2992 max = len - l;
2993
Willy Tarreau06d80a92017-10-19 14:32:15 +02002994 ret = ci_putblk(chn, str + l, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002995 if (ret == -2 || ret == -3) {
2996 lua_pushinteger(L, -1);
2997 return 1;
2998 }
Willy Tarreaubc18da12015-03-13 14:00:47 +01002999 if (ret == -1) {
3000 chn->flags |= CF_WAKE_WRITE;
Willy Tarreau9635e032018-10-16 17:52:55 +02003001 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
Willy Tarreaubc18da12015-03-13 14:00:47 +01003002 }
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003003 l += ret;
3004 lua_pop(L, 1);
3005 lua_pushinteger(L, l);
3006
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003007 max = channel_recv_limit(chn) - b_data(&chn->buf);
Willy Tarreaua79021a2018-06-15 18:07:57 +02003008 if (max == 0 && co_data(chn) == 0) {
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003009 /* There are no space available, and the output buffer is empty.
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003010 * in this case, we cannot add more data, so we cannot yield,
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05003011 * we return the amount of copied data.
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003012 */
3013 return 1;
3014 }
3015 if (l < len)
Willy Tarreau9635e032018-10-16 17:52:55 +02003016 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003017 return 1;
3018}
3019
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003020/* Just a wrapper of "hlua_channel_append_yield". It returns the length
3021 * of the written string, or -1 if the channel is closed or if the
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003022 * buffer size is too little for the data.
3023 */
3024__LJMP static int hlua_channel_append(lua_State *L)
3025{
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003026 size_t len;
3027
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003028 MAY_LJMP(check_args(L, 2, "append"));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003029 MAY_LJMP(hlua_checkchannel(L, 1));
3030 MAY_LJMP(luaL_checklstring(L, 2, &len));
3031 MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003032 lua_pushinteger(L, 0);
3033
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003034 return MAY_LJMP(hlua_channel_append_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003035}
3036
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003037/* Just a wrapper of "hlua_channel_append_yield". This wrapper starts
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003038 * his process by cleaning the buffer. The result is a replacement
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003039 * of the current data. It returns the length of the written string,
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003040 * or -1 if the channel is closed or if the buffer size is too
3041 * little for the data.
3042 */
3043__LJMP static int hlua_channel_set(lua_State *L)
3044{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003045 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003046
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003047 MAY_LJMP(check_args(L, 2, "set"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003048 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003049 lua_pushinteger(L, 0);
3050
Thierry Fournier77016da2020-08-15 14:35:51 +02003051 if (chn_strm(chn)->be->mode == PR_MODE_HTTP) {
3052 lua_pushfstring(L, "Cannot manipulate HAProxy channels in HTTP mode.");
Christopher Faulet3f829a42018-12-13 21:56:45 +01003053 WILL_LJMP(lua_error(L));
Thierry Fournier77016da2020-08-15 14:35:51 +02003054 }
Christopher Faulet3f829a42018-12-13 21:56:45 +01003055
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003056 b_set_data(&chn->buf, co_data(chn));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003057
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003058 return MAY_LJMP(hlua_channel_append_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003059}
3060
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003061/* Append data in the output side of the buffer. This data is immediately
3062 * sent. The function returns the amount of data written. If the buffer
3063 * cannot contain the data, the function yields. The function returns -1
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003064 * if the channel is closed.
3065 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003066__LJMP static int hlua_channel_send_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003067{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003068 struct channel *chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003069 size_t len;
3070 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
3071 int l = MAY_LJMP(luaL_checkinteger(L, 3));
3072 int max;
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003073 struct hlua *hlua = hlua_gethlua(L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003074
Thierry Fournier77016da2020-08-15 14:35:51 +02003075 if (chn_strm(chn)->be->mode == PR_MODE_HTTP) {
3076 lua_pushfstring(L, "Cannot manipulate HAProxy channels in HTTP mode.");
Christopher Faulet3f829a42018-12-13 21:56:45 +01003077 WILL_LJMP(lua_error(L));
Thierry Fournier77016da2020-08-15 14:35:51 +02003078 }
Christopher Faulet3f829a42018-12-13 21:56:45 +01003079
Willy Tarreau47860ed2015-03-10 14:07:50 +01003080 if (unlikely(channel_output_closed(chn))) {
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003081 lua_pushinteger(L, -1);
3082 return 1;
3083 }
3084
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003085 /* Check if the buffer is available because HAProxy doesn't allocate
Thierry FOURNIER3e3a6082015-03-05 17:06:12 +01003086 * the request buffer if its not required.
3087 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003088 if (chn->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +01003089 si_rx_buff_blk(chn_prod(chn));
Willy Tarreau9635e032018-10-16 17:52:55 +02003090 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIER3e3a6082015-03-05 17:06:12 +01003091 }
3092
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003093 /* The written data will be immediately sent, so we can check
3094 * the available space without taking in account the reserve.
3095 * The reserve is guaranteed for the processing of incoming
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003096 * data, because the buffer will be flushed.
3097 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003098 max = b_room(&chn->buf);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003099
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003100 /* If there is no space available, and the output buffer is empty.
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003101 * in this case, we cannot add more data, so we cannot yield,
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05003102 * we return the amount of copied data.
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003103 */
Willy Tarreaua79021a2018-06-15 18:07:57 +02003104 if (max == 0 && co_data(chn) == 0)
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003105 return 1;
3106
3107 /* Adjust the real required length. */
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003108 if (max > len - l)
3109 max = len - l;
3110
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003111 /* The buffer available size may be not contiguous. This test
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003112 * detects a non contiguous buffer and realign it.
3113 */
Willy Tarreau3f679992018-06-15 15:06:42 +02003114 if (ci_space_for_replace(chn) < max)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003115 channel_slow_realign(chn, trash.area);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003116
3117 /* Copy input data in the buffer. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003118 max = b_rep_blk(&chn->buf, ci_head(chn), ci_head(chn), str + l, max);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003119
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003120 /* buffer replace considers that the input part is filled.
3121 * so, I must forward these new data in the output part.
3122 */
Willy Tarreaubcbd3932018-06-06 07:13:22 +02003123 c_adv(chn, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003124
3125 l += max;
3126 lua_pop(L, 1);
3127 lua_pushinteger(L, l);
3128
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003129 /* If there is no space available, and the output buffer is empty.
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003130 * in this case, we cannot add more data, so we cannot yield,
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05003131 * we return the amount of copied data.
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003132 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003133 max = b_room(&chn->buf);
Willy Tarreaua79021a2018-06-15 18:07:57 +02003134 if (max == 0 && co_data(chn) == 0)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003135 return 1;
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003136
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003137 if (l < len) {
3138 /* If we are waiting for space in the response buffer, we
3139 * must set the flag WAKERESWR. This flag required the task
3140 * wake up if any activity is detected on the response buffer.
3141 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01003142 if (chn->flags & CF_ISRESP)
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003143 HLUA_SET_WAKERESWR(hlua);
Thierry FOURNIER53e08ec2015-03-06 00:35:53 +01003144 else
3145 HLUA_SET_WAKEREQWR(hlua);
Willy Tarreau9635e032018-10-16 17:52:55 +02003146 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003147 }
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003148
3149 return 1;
3150}
3151
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05003152/* Just a wrapper of "_hlua_channel_send". This wrapper permits
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003153 * yield the LUA process, and resume it without checking the
3154 * input arguments.
3155 */
3156__LJMP static int hlua_channel_send(lua_State *L)
3157{
3158 MAY_LJMP(check_args(L, 2, "send"));
3159 lua_pushinteger(L, 0);
3160
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003161 return MAY_LJMP(hlua_channel_send_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003162}
3163
3164/* This function forward and amount of butes. The data pass from
3165 * the input side of the buffer to the output side, and can be
3166 * forwarded. This function never fails.
3167 *
3168 * The Lua function takes an amount of bytes to be forwarded in
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05003169 * input. It returns the number of bytes forwarded.
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003170 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003171__LJMP static int hlua_channel_forward_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003172{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003173 struct channel *chn;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003174 int len;
3175 int l;
3176 int max;
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003177 struct hlua *hlua = hlua_gethlua(L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003178
3179 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Christopher Faulet3f829a42018-12-13 21:56:45 +01003180
Thierry Fournier77016da2020-08-15 14:35:51 +02003181 if (chn_strm(chn)->be->mode == PR_MODE_HTTP) {
3182 lua_pushfstring(L, "Cannot manipulate HAProxy channels in HTTP mode.");
Christopher Faulet3f829a42018-12-13 21:56:45 +01003183 WILL_LJMP(lua_error(L));
Thierry Fournier77016da2020-08-15 14:35:51 +02003184 }
Christopher Faulet3f829a42018-12-13 21:56:45 +01003185
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003186 len = MAY_LJMP(luaL_checkinteger(L, 2));
3187 l = MAY_LJMP(luaL_checkinteger(L, -1));
3188
3189 max = len - l;
Willy Tarreaua79021a2018-06-15 18:07:57 +02003190 if (max > ci_data(chn))
3191 max = ci_data(chn);
Willy Tarreau47860ed2015-03-10 14:07:50 +01003192 channel_forward(chn, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003193 l += max;
3194
3195 lua_pop(L, 1);
3196 lua_pushinteger(L, l);
3197
3198 /* Check if it miss bytes to forward. */
3199 if (l < len) {
3200 /* The the input channel or the output channel are closed, we
3201 * must return the amount of data forwarded.
3202 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01003203 if (channel_input_closed(chn) || channel_output_closed(chn))
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003204 return 1;
3205
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003206 /* If we are waiting for space data in the response buffer, we
3207 * must set the flag WAKERESWR. This flag required the task
3208 * wake up if any activity is detected on the response buffer.
3209 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01003210 if (chn->flags & CF_ISRESP)
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003211 HLUA_SET_WAKERESWR(hlua);
Thierry FOURNIER53e08ec2015-03-06 00:35:53 +01003212 else
3213 HLUA_SET_WAKEREQWR(hlua);
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003214
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003215 /* Otherwise, we can yield waiting for new data in the inpout side. */
Willy Tarreau9635e032018-10-16 17:52:55 +02003216 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_forward_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003217 }
3218
3219 return 1;
3220}
3221
3222/* Just check the input and prepare the stack for the previous
3223 * function "hlua_channel_forward_yield"
3224 */
3225__LJMP static int hlua_channel_forward(lua_State *L)
3226{
3227 MAY_LJMP(check_args(L, 2, "forward"));
3228 MAY_LJMP(hlua_checkchannel(L, 1));
3229 MAY_LJMP(luaL_checkinteger(L, 2));
3230
3231 lua_pushinteger(L, 0);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003232 return MAY_LJMP(hlua_channel_forward_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003233}
3234
3235/* Just returns the number of bytes available in the input
3236 * side of the buffer. This function never fails.
3237 */
3238__LJMP static int hlua_channel_get_in_len(lua_State *L)
3239{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003240 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003241
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003242 MAY_LJMP(check_args(L, 1, "get_in_len"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003243 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Christopher Fauleta3ceac12018-12-14 13:39:09 +01003244 if (IS_HTX_STRM(chn_strm(chn))) {
3245 struct htx *htx = htxbuf(&chn->buf);
3246 lua_pushinteger(L, htx->data - co_data(chn));
3247 }
3248 else
3249 lua_pushinteger(L, ci_data(chn));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003250 return 1;
3251}
3252
Thierry FOURNIER / OZON.IO65192f32016-11-07 15:28:40 +01003253/* Returns true if the channel is full. */
3254__LJMP static int hlua_channel_is_full(lua_State *L)
3255{
3256 struct channel *chn;
Thierry FOURNIER / OZON.IO65192f32016-11-07 15:28:40 +01003257
3258 MAY_LJMP(check_args(L, 1, "is_full"));
3259 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Christopher Faulet0ec740e2020-02-26 11:59:19 +01003260 /* ignore the reserve, we are not on a producer side (ie in an
3261 * applet).
3262 */
3263 lua_pushboolean(L, channel_full(chn, 0));
Thierry FOURNIER / OZON.IO65192f32016-11-07 15:28:40 +01003264 return 1;
3265}
3266
Christopher Faulet2ac9ba22020-02-25 10:15:50 +01003267/* Returns true if the channel is the response channel. */
3268__LJMP static int hlua_channel_is_resp(lua_State *L)
3269{
3270 struct channel *chn;
3271
3272 MAY_LJMP(check_args(L, 1, "is_resp"));
3273 chn = MAY_LJMP(hlua_checkchannel(L, 1));
3274
3275 lua_pushboolean(L, !!(chn->flags & CF_ISRESP));
3276 return 1;
3277}
3278
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003279/* Just returns the number of bytes available in the output
3280 * side of the buffer. This function never fails.
3281 */
3282__LJMP static int hlua_channel_get_out_len(lua_State *L)
3283{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003284 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003285
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003286 MAY_LJMP(check_args(L, 1, "get_out_len"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003287 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Willy Tarreaua79021a2018-06-15 18:07:57 +02003288 lua_pushinteger(L, co_data(chn));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003289 return 1;
3290}
3291
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003292/*
3293 *
3294 *
3295 * Class Fetches
3296 *
3297 *
3298 */
3299
3300/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02003301 * a class stream, otherwise it throws an error.
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003302 */
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003303__LJMP static struct hlua_smp *hlua_checkfetches(lua_State *L, int ud)
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003304{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003305 return MAY_LJMP(hlua_checkudata(L, ud, class_fetches_ref));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003306}
3307
3308/* This function creates and push in the stack a fetch object according
3309 * with a current TXN.
3310 */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003311static int hlua_fetches_new(lua_State *L, struct hlua_txn *txn, unsigned int flags)
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003312{
Willy Tarreau7073c472015-04-06 11:15:40 +02003313 struct hlua_smp *hsmp;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003314
3315 /* Check stack size. */
3316 if (!lua_checkstack(L, 3))
3317 return 0;
3318
3319 /* Create the object: obj[0] = userdata.
3320 * Note that the base of the Fetches object is the
3321 * transaction object.
3322 */
3323 lua_newtable(L);
Willy Tarreau7073c472015-04-06 11:15:40 +02003324 hsmp = lua_newuserdata(L, sizeof(*hsmp));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003325 lua_rawseti(L, -2, 0);
3326
Willy Tarreau7073c472015-04-06 11:15:40 +02003327 hsmp->s = txn->s;
3328 hsmp->p = txn->p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01003329 hsmp->dir = txn->dir;
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003330 hsmp->flags = flags;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003331
3332 /* Pop a class sesison metatable and affect it to the userdata. */
3333 lua_rawgeti(L, LUA_REGISTRYINDEX, class_fetches_ref);
3334 lua_setmetatable(L, -2);
3335
3336 return 1;
3337}
3338
3339/* This function is an LUA binding. It is called with each sample-fetch.
3340 * It uses closure argument to store the associated sample-fetch. It
3341 * returns only one argument or throws an error. An error is thrown
3342 * only if an error is encountered during the argument parsing. If
3343 * the "sample-fetch" function fails, nil is returned.
3344 */
3345__LJMP static int hlua_run_sample_fetch(lua_State *L)
3346{
Willy Tarreaub2ccb562015-04-06 11:11:15 +02003347 struct hlua_smp *hsmp;
Willy Tarreau2ec22742015-03-10 14:27:20 +01003348 struct sample_fetch *f;
Frédéric Lécaillef874a832018-06-15 13:56:04 +02003349 struct arg args[ARGM_NBARGS + 1] = {{0}};
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003350 int i;
3351 struct sample smp;
3352
3353 /* Get closure arguments. */
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003354 f = lua_touserdata(L, lua_upvalueindex(1));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003355
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003356 /* Get traditional arguments. */
Willy Tarreaub2ccb562015-04-06 11:11:15 +02003357 hsmp = MAY_LJMP(hlua_checkfetches(L, 1));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003358
Thierry FOURNIERca988662015-12-20 18:43:03 +01003359 /* Check execution authorization. */
3360 if (f->use & SMP_USE_HTTP_ANY &&
3361 !(hsmp->flags & HLUA_F_MAY_USE_HTTP)) {
3362 lua_pushfstring(L, "the sample-fetch '%s' needs an HTTP parser which "
3363 "is not available in Lua services", f->kw);
3364 WILL_LJMP(lua_error(L));
3365 }
3366
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003367 /* Get extra arguments. */
3368 for (i = 0; i < lua_gettop(L) - 1; i++) {
3369 if (i >= ARGM_NBARGS)
3370 break;
3371 hlua_lua2arg(L, i + 2, &args[i]);
3372 }
3373 args[i].type = ARGT_STOP;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003374 args[i].data.str.area = NULL;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003375
3376 /* Check arguments. */
Willy Tarreaub2ccb562015-04-06 11:11:15 +02003377 MAY_LJMP(hlua_lua2arg_check(L, 2, args, f->arg_mask, hsmp->p));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003378
3379 /* Run the special args checker. */
Willy Tarreau2ec22742015-03-10 14:27:20 +01003380 if (f->val_args && !f->val_args(args, NULL)) {
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003381 lua_pushfstring(L, "error in arguments");
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003382 goto error;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003383 }
3384
3385 /* Initialise the sample. */
3386 memset(&smp, 0, sizeof(smp));
3387
3388 /* Run the sample fetch process. */
Willy Tarreau1777ea62016-03-10 16:15:46 +01003389 smp_set_owner(&smp, hsmp->p, hsmp->s->sess, hsmp->s, hsmp->dir & SMP_OPT_DIR);
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003390 if (!f->process(args, &smp, f->kw, f->private)) {
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003391 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003392 lua_pushstring(L, "");
3393 else
3394 lua_pushnil(L);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003395 goto end;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003396 }
3397
3398 /* Convert the returned sample in lua value. */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003399 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003400 hlua_smp2lua_str(L, &smp);
3401 else
3402 hlua_smp2lua(L, &smp);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003403
3404 end:
3405 for (i = 0; args[i].type != ARGT_STOP; i++) {
3406 if (args[i].type == ARGT_STR)
3407 chunk_destroy(&args[i].data.str);
Christopher Fauletfd2e9062020-08-06 11:10:57 +02003408 else if (args[i].type == ARGT_REG)
3409 regex_free(args[i].data.reg);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003410 }
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003411 return 1;
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003412
3413 error:
3414 for (i = 0; args[i].type != ARGT_STOP; i++) {
3415 if (args[i].type == ARGT_STR)
3416 chunk_destroy(&args[i].data.str);
Christopher Fauletfd2e9062020-08-06 11:10:57 +02003417 else if (args[i].type == ARGT_REG)
3418 regex_free(args[i].data.reg);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003419 }
3420 WILL_LJMP(lua_error(L));
3421 return 0; /* Never reached */
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003422}
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003423
3424/*
3425 *
3426 *
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003427 * Class Converters
3428 *
3429 *
3430 */
3431
3432/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02003433 * a class stream, otherwise it throws an error.
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003434 */
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003435__LJMP static struct hlua_smp *hlua_checkconverters(lua_State *L, int ud)
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003436{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003437 return MAY_LJMP(hlua_checkudata(L, ud, class_converters_ref));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003438}
3439
3440/* This function creates and push in the stack a Converters object
3441 * according with a current TXN.
3442 */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003443static int hlua_converters_new(lua_State *L, struct hlua_txn *txn, unsigned int flags)
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003444{
Willy Tarreau7073c472015-04-06 11:15:40 +02003445 struct hlua_smp *hsmp;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003446
3447 /* Check stack size. */
3448 if (!lua_checkstack(L, 3))
3449 return 0;
3450
3451 /* Create the object: obj[0] = userdata.
3452 * Note that the base of the Converters object is the
3453 * same than the TXN object.
3454 */
3455 lua_newtable(L);
Willy Tarreau7073c472015-04-06 11:15:40 +02003456 hsmp = lua_newuserdata(L, sizeof(*hsmp));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003457 lua_rawseti(L, -2, 0);
3458
Willy Tarreau7073c472015-04-06 11:15:40 +02003459 hsmp->s = txn->s;
3460 hsmp->p = txn->p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01003461 hsmp->dir = txn->dir;
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003462 hsmp->flags = flags;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003463
Willy Tarreau87b09662015-04-03 00:22:06 +02003464 /* Pop a class stream metatable and affect it to the table. */
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003465 lua_rawgeti(L, LUA_REGISTRYINDEX, class_converters_ref);
3466 lua_setmetatable(L, -2);
3467
3468 return 1;
3469}
3470
3471/* This function is an LUA binding. It is called with each converter.
3472 * It uses closure argument to store the associated converter. It
3473 * returns only one argument or throws an error. An error is thrown
3474 * only if an error is encountered during the argument parsing. If
3475 * the converter function function fails, nil is returned.
3476 */
3477__LJMP static int hlua_run_sample_conv(lua_State *L)
3478{
Willy Tarreauda5f1082015-04-06 11:17:13 +02003479 struct hlua_smp *hsmp;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003480 struct sample_conv *conv;
Frédéric Lécaillef874a832018-06-15 13:56:04 +02003481 struct arg args[ARGM_NBARGS + 1] = {{0}};
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003482 int i;
3483 struct sample smp;
3484
3485 /* Get closure arguments. */
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003486 conv = lua_touserdata(L, lua_upvalueindex(1));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003487
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003488 /* Get traditional arguments. */
Willy Tarreauda5f1082015-04-06 11:17:13 +02003489 hsmp = MAY_LJMP(hlua_checkconverters(L, 1));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003490
3491 /* Get extra arguments. */
3492 for (i = 0; i < lua_gettop(L) - 2; i++) {
3493 if (i >= ARGM_NBARGS)
3494 break;
3495 hlua_lua2arg(L, i + 3, &args[i]);
3496 }
3497 args[i].type = ARGT_STOP;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003498 args[i].data.str.area = NULL;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003499
3500 /* Check arguments. */
Willy Tarreauda5f1082015-04-06 11:17:13 +02003501 MAY_LJMP(hlua_lua2arg_check(L, 3, args, conv->arg_mask, hsmp->p));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003502
3503 /* Run the special args checker. */
3504 if (conv->val_args && !conv->val_args(args, conv, "", 0, NULL)) {
3505 hlua_pusherror(L, "error in arguments");
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003506 goto error;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003507 }
3508
3509 /* Initialise the sample. */
3510 if (!hlua_lua2smp(L, 2, &smp)) {
3511 hlua_pusherror(L, "error in the input argument");
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003512 goto error;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003513 }
3514
Willy Tarreau1777ea62016-03-10 16:15:46 +01003515 smp_set_owner(&smp, hsmp->p, hsmp->s->sess, hsmp->s, hsmp->dir & SMP_OPT_DIR);
3516
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003517 /* Apply expected cast. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003518 if (!sample_casts[smp.data.type][conv->in_type]) {
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003519 hlua_pusherror(L, "invalid input argument: cannot cast '%s' to '%s'",
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003520 smp_to_type[smp.data.type], smp_to_type[conv->in_type]);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003521 goto error;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003522 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003523 if (sample_casts[smp.data.type][conv->in_type] != c_none &&
3524 !sample_casts[smp.data.type][conv->in_type](&smp)) {
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003525 hlua_pusherror(L, "error during the input argument casting");
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003526 goto error;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003527 }
3528
3529 /* Run the sample conversion process. */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003530 if (!conv->process(args, &smp, conv->private)) {
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003531 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003532 lua_pushstring(L, "");
3533 else
Willy Tarreaua678b432015-08-28 10:14:59 +02003534 lua_pushnil(L);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003535 goto end;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003536 }
3537
3538 /* Convert the returned sample in lua value. */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003539 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003540 hlua_smp2lua_str(L, &smp);
3541 else
3542 hlua_smp2lua(L, &smp);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003543 end:
3544 for (i = 0; args[i].type != ARGT_STOP; i++) {
3545 if (args[i].type == ARGT_STR)
3546 chunk_destroy(&args[i].data.str);
Christopher Fauletfd2e9062020-08-06 11:10:57 +02003547 else if (args[i].type == ARGT_REG)
3548 regex_free(args[i].data.reg);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003549 }
Willy Tarreaua678b432015-08-28 10:14:59 +02003550 return 1;
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003551
3552 error:
3553 for (i = 0; args[i].type != ARGT_STOP; i++) {
3554 if (args[i].type == ARGT_STR)
3555 chunk_destroy(&args[i].data.str);
Christopher Fauletfd2e9062020-08-06 11:10:57 +02003556 else if (args[i].type == ARGT_REG)
3557 regex_free(args[i].data.reg);
Christopher Fauletaec27ef2020-08-06 08:54:25 +02003558 }
3559 WILL_LJMP(lua_error(L));
3560 return 0; /* Never reached */
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003561}
3562
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003563/*
3564 *
3565 *
3566 * Class AppletTCP
3567 *
3568 *
3569 */
3570
3571/* Returns a struct hlua_txn if the stack entry "ud" is
3572 * a class stream, otherwise it throws an error.
3573 */
3574__LJMP static struct hlua_appctx *hlua_checkapplet_tcp(lua_State *L, int ud)
3575{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003576 return MAY_LJMP(hlua_checkudata(L, ud, class_applet_tcp_ref));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003577}
3578
3579/* This function creates and push in the stack an Applet object
3580 * according with a current TXN.
3581 */
3582static int hlua_applet_tcp_new(lua_State *L, struct appctx *ctx)
3583{
3584 struct hlua_appctx *appctx;
3585 struct stream_interface *si = ctx->owner;
3586 struct stream *s = si_strm(si);
3587 struct proxy *p = s->be;
3588
3589 /* Check stack size. */
3590 if (!lua_checkstack(L, 3))
3591 return 0;
3592
3593 /* Create the object: obj[0] = userdata.
3594 * Note that the base of the Converters object is the
3595 * same than the TXN object.
3596 */
3597 lua_newtable(L);
3598 appctx = lua_newuserdata(L, sizeof(*appctx));
3599 lua_rawseti(L, -2, 0);
3600 appctx->appctx = ctx;
3601 appctx->htxn.s = s;
3602 appctx->htxn.p = p;
3603
3604 /* Create the "f" field that contains a list of fetches. */
3605 lua_pushstring(L, "f");
3606 if (!hlua_fetches_new(L, &appctx->htxn, 0))
3607 return 0;
3608 lua_settable(L, -3);
3609
3610 /* Create the "sf" field that contains a list of stringsafe fetches. */
3611 lua_pushstring(L, "sf");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003612 if (!hlua_fetches_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003613 return 0;
3614 lua_settable(L, -3);
3615
3616 /* Create the "c" field that contains a list of converters. */
3617 lua_pushstring(L, "c");
3618 if (!hlua_converters_new(L, &appctx->htxn, 0))
3619 return 0;
3620 lua_settable(L, -3);
3621
3622 /* Create the "sc" field that contains a list of stringsafe converters. */
3623 lua_pushstring(L, "sc");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003624 if (!hlua_converters_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003625 return 0;
3626 lua_settable(L, -3);
3627
3628 /* Pop a class stream metatable and affect it to the table. */
3629 lua_rawgeti(L, LUA_REGISTRYINDEX, class_applet_tcp_ref);
3630 lua_setmetatable(L, -2);
3631
3632 return 1;
3633}
3634
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003635__LJMP static int hlua_applet_tcp_set_var(lua_State *L)
3636{
3637 struct hlua_appctx *appctx;
3638 struct stream *s;
3639 const char *name;
3640 size_t len;
3641 struct sample smp;
3642
Tim Duesterhus4e172c92020-05-19 13:49:42 +02003643 if (lua_gettop(L) < 3 || lua_gettop(L) > 4)
3644 WILL_LJMP(luaL_error(L, "'set_var' needs between 3 and 4 arguments"));
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003645
3646 /* It is useles to retrieve the stream, but this function
3647 * runs only in a stream context.
3648 */
3649 appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3650 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3651 s = appctx->htxn.s;
3652
3653 /* Converts the third argument in a sample. */
3654 hlua_lua2smp(L, 3, &smp);
3655
3656 /* Store the sample in a variable. */
3657 smp_set_owner(&smp, s->be, s->sess, s, 0);
Tim Duesterhus4e172c92020-05-19 13:49:42 +02003658
3659 if (lua_gettop(L) == 4 && lua_toboolean(L, 4))
3660 lua_pushboolean(L, vars_set_by_name_ifexist(name, len, &smp) != 0);
3661 else
3662 lua_pushboolean(L, vars_set_by_name(name, len, &smp) != 0);
3663
Tim Duesterhus84ebc132020-05-19 13:49:41 +02003664 return 1;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003665}
3666
3667__LJMP static int hlua_applet_tcp_unset_var(lua_State *L)
3668{
3669 struct hlua_appctx *appctx;
3670 struct stream *s;
3671 const char *name;
3672 size_t len;
3673 struct sample smp;
3674
3675 MAY_LJMP(check_args(L, 2, "unset_var"));
3676
3677 /* It is useles to retrieve the stream, but this function
3678 * runs only in a stream context.
3679 */
3680 appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3681 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3682 s = appctx->htxn.s;
3683
3684 /* Unset the variable. */
3685 smp_set_owner(&smp, s->be, s->sess, s, 0);
Tim Duesterhus84ebc132020-05-19 13:49:41 +02003686 lua_pushboolean(L, vars_unset_by_name_ifexist(name, len, &smp) != 0);
3687 return 1;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003688}
3689
3690__LJMP static int hlua_applet_tcp_get_var(lua_State *L)
3691{
3692 struct hlua_appctx *appctx;
3693 struct stream *s;
3694 const char *name;
3695 size_t len;
3696 struct sample smp;
3697
3698 MAY_LJMP(check_args(L, 2, "get_var"));
3699
3700 /* It is useles to retrieve the stream, but this function
3701 * runs only in a stream context.
3702 */
3703 appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3704 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3705 s = appctx->htxn.s;
3706
3707 smp_set_owner(&smp, s->be, s->sess, s, 0);
3708 if (!vars_get_by_name(name, len, &smp)) {
3709 lua_pushnil(L);
3710 return 1;
3711 }
3712
3713 return hlua_smp2lua(L, &smp);
3714}
3715
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003716__LJMP static int hlua_applet_tcp_set_priv(lua_State *L)
3717{
3718 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3719 struct stream *s = appctx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01003720 struct hlua *hlua;
3721
3722 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01003723 if (!s->hlua)
3724 return 0;
3725 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003726
3727 MAY_LJMP(check_args(L, 2, "set_priv"));
3728
3729 /* Remove previous value. */
Thierry FOURNIERe068b602017-04-26 13:27:05 +02003730 luaL_unref(L, LUA_REGISTRYINDEX, hlua->Mref);
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003731
3732 /* Get and store new value. */
3733 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
3734 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
3735
3736 return 0;
3737}
3738
3739__LJMP static int hlua_applet_tcp_get_priv(lua_State *L)
3740{
3741 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3742 struct stream *s = appctx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01003743 struct hlua *hlua;
3744
3745 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01003746 if (!s->hlua) {
3747 lua_pushnil(L);
3748 return 1;
3749 }
3750 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003751
3752 /* Push configuration index in the stack. */
3753 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
3754
3755 return 1;
3756}
3757
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003758/* If expected data not yet available, it returns a yield. This function
3759 * consumes the data in the buffer. It returns a string containing the
3760 * data. This string can be empty.
3761 */
3762__LJMP static int hlua_applet_tcp_getline_yield(lua_State *L, int status, lua_KContext ctx)
3763{
3764 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3765 struct stream_interface *si = appctx->appctx->owner;
3766 int ret;
Willy Tarreau206ba832018-06-14 15:27:31 +02003767 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003768 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02003769 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003770 size_t len2;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003771
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003772 /* Read the maximum amount of data available. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003773 ret = co_getline_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003774
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003775 /* Data not yet available. return yield. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003776 if (ret == 0) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01003777 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003778 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_getline_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003779 }
3780
3781 /* End of data: commit the total strings and return. */
3782 if (ret < 0) {
3783 luaL_pushresult(&appctx->b);
3784 return 1;
3785 }
3786
3787 /* Ensure that the block 2 length is usable. */
3788 if (ret == 1)
3789 len2 = 0;
3790
3791 /* dont check the max length read and dont check. */
3792 luaL_addlstring(&appctx->b, blk1, len1);
3793 luaL_addlstring(&appctx->b, blk2, len2);
3794
3795 /* Consume input channel output buffer data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003796 co_skip(si_oc(si), len1 + len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003797 luaL_pushresult(&appctx->b);
3798 return 1;
3799}
3800
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003801/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003802__LJMP static int hlua_applet_tcp_getline(lua_State *L)
3803{
3804 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3805
3806 /* Initialise the string catenation. */
3807 luaL_buffinit(L, &appctx->b);
3808
3809 return MAY_LJMP(hlua_applet_tcp_getline_yield(L, 0, 0));
3810}
3811
3812/* If expected data not yet available, it returns a yield. This function
3813 * consumes the data in the buffer. It returns a string containing the
3814 * data. This string can be empty.
3815 */
3816__LJMP static int hlua_applet_tcp_recv_yield(lua_State *L, int status, lua_KContext ctx)
3817{
3818 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3819 struct stream_interface *si = appctx->appctx->owner;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003820 size_t len = MAY_LJMP(luaL_checkinteger(L, 2));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003821 int ret;
Willy Tarreau206ba832018-06-14 15:27:31 +02003822 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003823 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02003824 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003825 size_t len2;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003826
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003827 /* Read the maximum amount of data available. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003828 ret = co_getblk_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003829
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003830 /* Data not yet available. return yield. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003831 if (ret == 0) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01003832 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003833 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003834 }
3835
3836 /* End of data: commit the total strings and return. */
3837 if (ret < 0) {
3838 luaL_pushresult(&appctx->b);
3839 return 1;
3840 }
3841
3842 /* Ensure that the block 2 length is usable. */
3843 if (ret == 1)
3844 len2 = 0;
3845
3846 if (len == -1) {
3847
3848 /* If len == -1, catenate all the data avalaile and
3849 * yield because we want to get all the data until
3850 * the end of data stream.
3851 */
3852 luaL_addlstring(&appctx->b, blk1, len1);
3853 luaL_addlstring(&appctx->b, blk2, len2);
Willy Tarreau06d80a92017-10-19 14:32:15 +02003854 co_skip(si_oc(si), len1 + len2);
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01003855 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003856 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003857
3858 } else {
3859
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05003860 /* Copy the first block caping to the length required. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003861 if (len1 > len)
3862 len1 = len;
3863 luaL_addlstring(&appctx->b, blk1, len1);
3864 len -= len1;
3865
3866 /* Copy the second block. */
3867 if (len2 > len)
3868 len2 = len;
3869 luaL_addlstring(&appctx->b, blk2, len2);
3870 len -= len2;
3871
3872 /* Consume input channel output buffer data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003873 co_skip(si_oc(si), len1 + len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003874
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003875 /* If there is no other data available, yield waiting for new data. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003876 if (len > 0) {
3877 lua_pushinteger(L, len);
3878 lua_replace(L, 2);
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01003879 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003880 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003881 }
3882
3883 /* return the result. */
3884 luaL_pushresult(&appctx->b);
3885 return 1;
3886 }
3887
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003888 /* we never execute this */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003889 hlua_pusherror(L, "Lua: internal error");
3890 WILL_LJMP(lua_error(L));
3891 return 0;
3892}
3893
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003894/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003895__LJMP static int hlua_applet_tcp_recv(lua_State *L)
3896{
3897 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3898 int len = -1;
3899
3900 if (lua_gettop(L) > 2)
3901 WILL_LJMP(luaL_error(L, "The 'recv' function requires between 1 and 2 arguments."));
3902 if (lua_gettop(L) >= 2) {
3903 len = MAY_LJMP(luaL_checkinteger(L, 2));
3904 lua_pop(L, 1);
3905 }
3906
3907 /* Confirm or set the required length */
3908 lua_pushinteger(L, len);
3909
3910 /* Initialise the string catenation. */
3911 luaL_buffinit(L, &appctx->b);
3912
3913 return MAY_LJMP(hlua_applet_tcp_recv_yield(L, 0, 0));
3914}
3915
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003916/* Append data in the output side of the buffer. This data is immediately
3917 * sent. The function returns the amount of data written. If the buffer
3918 * cannot contain the data, the function yields. The function returns -1
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003919 * if the channel is closed.
3920 */
3921__LJMP static int hlua_applet_tcp_send_yield(lua_State *L, int status, lua_KContext ctx)
3922{
3923 size_t len;
3924 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3925 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
3926 int l = MAY_LJMP(luaL_checkinteger(L, 3));
3927 struct stream_interface *si = appctx->appctx->owner;
3928 struct channel *chn = si_ic(si);
3929 int max;
3930
3931 /* Get the max amount of data which can write as input in the channel. */
3932 max = channel_recv_max(chn);
3933 if (max > (len - l))
3934 max = len - l;
3935
3936 /* Copy data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003937 ci_putblk(chn, str + l, max);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003938
3939 /* update counters. */
3940 l += max;
3941 lua_pop(L, 1);
3942 lua_pushinteger(L, l);
3943
3944 /* If some data is not send, declares the situation to the
3945 * applet, and returns a yield.
3946 */
3947 if (l < len) {
Willy Tarreaudb398432018-11-15 11:08:52 +01003948 si_rx_room_blk(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003949 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003950 }
3951
3952 return 1;
3953}
3954
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05003955/* Just a wrapper of "hlua_applet_tcp_send_yield". This wrapper permits
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003956 * yield the LUA process, and resume it without checking the
3957 * input arguments.
3958 */
3959__LJMP static int hlua_applet_tcp_send(lua_State *L)
3960{
3961 MAY_LJMP(check_args(L, 2, "send"));
3962 lua_pushinteger(L, 0);
3963
3964 return MAY_LJMP(hlua_applet_tcp_send_yield(L, 0, 0));
3965}
3966
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003967/*
3968 *
3969 *
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003970 * Class AppletHTTP
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003971 *
3972 *
3973 */
3974
3975/* Returns a struct hlua_txn if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02003976 * a class stream, otherwise it throws an error.
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003977 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003978__LJMP static struct hlua_appctx *hlua_checkapplet_http(lua_State *L, int ud)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003979{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003980 return MAY_LJMP(hlua_checkudata(L, ud, class_applet_http_ref));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003981}
3982
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003983/* This function creates and push in the stack an Applet object
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003984 * according with a current TXN.
3985 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003986static int hlua_applet_http_new(lua_State *L, struct appctx *ctx)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003987{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003988 struct hlua_appctx *appctx;
Thierry FOURNIER841475e2015-12-11 17:10:09 +01003989 struct hlua_txn htxn;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003990 struct stream_interface *si = ctx->owner;
3991 struct stream *s = si_strm(si);
3992 struct proxy *px = s->be;
Christopher Fauleta2097962019-07-15 16:25:33 +02003993 struct htx *htx;
3994 struct htx_blk *blk;
3995 struct htx_sl *sl;
3996 struct ist path;
3997 unsigned long long len = 0;
3998 int32_t pos;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003999
4000 /* Check stack size. */
4001 if (!lua_checkstack(L, 3))
4002 return 0;
4003
4004 /* Create the object: obj[0] = userdata.
4005 * Note that the base of the Converters object is the
4006 * same than the TXN object.
4007 */
4008 lua_newtable(L);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004009 appctx = lua_newuserdata(L, sizeof(*appctx));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004010 lua_rawseti(L, -2, 0);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004011 appctx->appctx = ctx;
4012 appctx->appctx->ctx.hlua_apphttp.status = 200; /* Default status code returned. */
Robin H. Johnson52f5db22017-01-01 13:10:52 -08004013 appctx->appctx->ctx.hlua_apphttp.reason = NULL; /* Use default reason based on status */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004014 appctx->htxn.s = s;
4015 appctx->htxn.p = px;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004016
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004017 /* Create the "f" field that contains a list of fetches. */
4018 lua_pushstring(L, "f");
4019 if (!hlua_fetches_new(L, &appctx->htxn, 0))
4020 return 0;
4021 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004022
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004023 /* Create the "sf" field that contains a list of stringsafe fetches. */
4024 lua_pushstring(L, "sf");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01004025 if (!hlua_fetches_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004026 return 0;
4027 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004028
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004029 /* Create the "c" field that contains a list of converters. */
4030 lua_pushstring(L, "c");
4031 if (!hlua_converters_new(L, &appctx->htxn, 0))
4032 return 0;
4033 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004034
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004035 /* Create the "sc" field that contains a list of stringsafe converters. */
4036 lua_pushstring(L, "sc");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01004037 if (!hlua_converters_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004038 return 0;
4039 lua_settable(L, -3);
Willy Tarreaueee5b512015-04-03 23:46:31 +02004040
Christopher Fauleta2097962019-07-15 16:25:33 +02004041 htx = htxbuf(&s->req.buf);
4042 blk = htx_get_first_blk(htx);
Christopher Fauletea009732019-11-18 15:50:25 +01004043 BUG_ON(!blk || htx_get_blk_type(blk) != HTX_BLK_REQ_SL);
Christopher Fauleta2097962019-07-15 16:25:33 +02004044 sl = htx_get_blk_ptr(htx, blk);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004045
Christopher Fauleta2097962019-07-15 16:25:33 +02004046 /* Stores the request method. */
4047 lua_pushstring(L, "method");
4048 lua_pushlstring(L, HTX_SL_REQ_MPTR(sl), HTX_SL_REQ_MLEN(sl));
4049 lua_settable(L, -3);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004050
Christopher Fauleta2097962019-07-15 16:25:33 +02004051 /* Stores the http version. */
4052 lua_pushstring(L, "version");
4053 lua_pushlstring(L, HTX_SL_REQ_VPTR(sl), HTX_SL_REQ_VLEN(sl));
4054 lua_settable(L, -3);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004055
Christopher Fauleta2097962019-07-15 16:25:33 +02004056 /* creates an array of headers. hlua_http_get_headers() crates and push
4057 * the array on the top of the stack.
4058 */
4059 lua_pushstring(L, "headers");
4060 htxn.s = s;
4061 htxn.p = px;
4062 htxn.dir = SMP_OPT_DIR_REQ;
Christopher Faulet9d1332b2020-02-24 16:46:16 +01004063 if (!hlua_http_get_headers(L, &htxn.s->txn->req))
Christopher Fauleta2097962019-07-15 16:25:33 +02004064 return 0;
4065 lua_settable(L, -3);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004066
Christopher Fauleta2097962019-07-15 16:25:33 +02004067 path = http_get_path(htx_sl_req_uri(sl));
Tim Duesterhused526372020-03-05 17:56:33 +01004068 if (isttest(path)) {
Christopher Fauleta2097962019-07-15 16:25:33 +02004069 char *p, *q, *end;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004070
Christopher Fauleta2097962019-07-15 16:25:33 +02004071 p = path.ptr;
4072 end = path.ptr + path.len;
4073 q = p;
4074 while (q < end && *q != '?')
4075 q++;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004076
Thierry FOURNIER7d388632017-02-22 02:06:16 +01004077 /* Stores the request path. */
Christopher Fauleta2097962019-07-15 16:25:33 +02004078 lua_pushstring(L, "path");
4079 lua_pushlstring(L, p, q - p);
Thierry FOURNIER7d388632017-02-22 02:06:16 +01004080 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01004081
Christopher Fauleta2097962019-07-15 16:25:33 +02004082 /* Stores the query string. */
4083 lua_pushstring(L, "qs");
4084 if (*q == '?')
4085 q++;
4086 lua_pushlstring(L, q, end - q);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004087 lua_settable(L, -3);
Christopher Fauleta2097962019-07-15 16:25:33 +02004088 }
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004089
Christopher Fauleta2097962019-07-15 16:25:33 +02004090 for (pos = htx_get_first(htx); pos != -1; pos = htx_get_next(htx, pos)) {
4091 struct htx_blk *blk = htx_get_blk(htx, pos);
4092 enum htx_blk_type type = htx_get_blk_type(blk);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004093
Christopher Fauleta2097962019-07-15 16:25:33 +02004094 if (type == HTX_BLK_EOM || type == HTX_BLK_TLR || type == HTX_BLK_EOT)
4095 break;
4096 if (type == HTX_BLK_DATA)
4097 len += htx_get_blksz(blk);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004098 }
Christopher Fauleta2097962019-07-15 16:25:33 +02004099 if (htx->extra != ULLONG_MAX)
4100 len += htx->extra;
4101
4102 /* Stores the request path. */
4103 lua_pushstring(L, "length");
4104 lua_pushinteger(L, len);
4105 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01004106
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004107 /* Create an empty array of HTTP request headers. */
4108 lua_pushstring(L, "response");
4109 lua_newtable(L);
4110 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01004111
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004112 /* Pop a class stream metatable and affect it to the table. */
4113 lua_rawgeti(L, LUA_REGISTRYINDEX, class_applet_http_ref);
4114 lua_setmetatable(L, -2);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004115
4116 return 1;
4117}
4118
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004119__LJMP static int hlua_applet_http_set_var(lua_State *L)
4120{
4121 struct hlua_appctx *appctx;
4122 struct stream *s;
4123 const char *name;
4124 size_t len;
4125 struct sample smp;
4126
Tim Duesterhus4e172c92020-05-19 13:49:42 +02004127 if (lua_gettop(L) < 3 || lua_gettop(L) > 4)
4128 WILL_LJMP(luaL_error(L, "'set_var' needs between 3 and 4 arguments"));
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004129
4130 /* It is useles to retrieve the stream, but this function
4131 * runs only in a stream context.
4132 */
4133 appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4134 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
4135 s = appctx->htxn.s;
4136
4137 /* Converts the third argument in a sample. */
4138 hlua_lua2smp(L, 3, &smp);
4139
4140 /* Store the sample in a variable. */
4141 smp_set_owner(&smp, s->be, s->sess, s, 0);
Tim Duesterhus4e172c92020-05-19 13:49:42 +02004142
4143 if (lua_gettop(L) == 4 && lua_toboolean(L, 4))
4144 lua_pushboolean(L, vars_set_by_name_ifexist(name, len, &smp) != 0);
4145 else
4146 lua_pushboolean(L, vars_set_by_name(name, len, &smp) != 0);
4147
Tim Duesterhus84ebc132020-05-19 13:49:41 +02004148 return 1;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004149}
4150
4151__LJMP static int hlua_applet_http_unset_var(lua_State *L)
4152{
4153 struct hlua_appctx *appctx;
4154 struct stream *s;
4155 const char *name;
4156 size_t len;
4157 struct sample smp;
4158
4159 MAY_LJMP(check_args(L, 2, "unset_var"));
4160
4161 /* It is useles to retrieve the stream, but this function
4162 * runs only in a stream context.
4163 */
4164 appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4165 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
4166 s = appctx->htxn.s;
4167
4168 /* Unset the variable. */
4169 smp_set_owner(&smp, s->be, s->sess, s, 0);
Tim Duesterhus84ebc132020-05-19 13:49:41 +02004170 lua_pushboolean(L, vars_unset_by_name_ifexist(name, len, &smp) != 0);
4171 return 1;
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004172}
4173
4174__LJMP static int hlua_applet_http_get_var(lua_State *L)
4175{
4176 struct hlua_appctx *appctx;
4177 struct stream *s;
4178 const char *name;
4179 size_t len;
4180 struct sample smp;
4181
4182 MAY_LJMP(check_args(L, 2, "get_var"));
4183
4184 /* It is useles to retrieve the stream, but this function
4185 * runs only in a stream context.
4186 */
4187 appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4188 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
4189 s = appctx->htxn.s;
4190
4191 smp_set_owner(&smp, s->be, s->sess, s, 0);
4192 if (!vars_get_by_name(name, len, &smp)) {
4193 lua_pushnil(L);
4194 return 1;
4195 }
4196
4197 return hlua_smp2lua(L, &smp);
4198}
4199
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01004200__LJMP static int hlua_applet_http_set_priv(lua_State *L)
4201{
4202 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4203 struct stream *s = appctx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01004204 struct hlua *hlua;
4205
4206 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01004207 if (!s->hlua)
4208 return 0;
4209 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01004210
4211 MAY_LJMP(check_args(L, 2, "set_priv"));
4212
4213 /* Remove previous value. */
Thierry FOURNIERe068b602017-04-26 13:27:05 +02004214 luaL_unref(L, LUA_REGISTRYINDEX, hlua->Mref);
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01004215
4216 /* Get and store new value. */
4217 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
4218 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
4219
4220 return 0;
4221}
4222
4223__LJMP static int hlua_applet_http_get_priv(lua_State *L)
4224{
4225 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4226 struct stream *s = appctx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01004227 struct hlua *hlua;
4228
4229 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01004230 if (!s->hlua) {
4231 lua_pushnil(L);
4232 return 1;
4233 }
4234 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01004235
4236 /* Push configuration index in the stack. */
4237 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
4238
4239 return 1;
4240}
4241
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004242/* If expected data not yet available, it returns a yield. This function
4243 * consumes the data in the buffer. It returns a string containing the
4244 * data. This string can be empty.
4245 */
Christopher Fauleta2097962019-07-15 16:25:33 +02004246__LJMP static int hlua_applet_http_getline_yield(lua_State *L, int status, lua_KContext ctx)
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004247{
4248 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4249 struct stream_interface *si = appctx->appctx->owner;
4250 struct channel *req = si_oc(si);
4251 struct htx *htx;
4252 struct htx_blk *blk;
4253 size_t count;
4254 int stop = 0;
4255
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004256 htx = htx_from_buf(&req->buf);
4257 count = co_data(req);
Christopher Fauleta3f15502019-05-13 15:27:23 +02004258 blk = htx_get_first_blk(htx);
Christopher Fauletcc26b132018-12-18 21:20:57 +01004259
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004260 while (count && !stop && blk) {
4261 enum htx_blk_type type = htx_get_blk_type(blk);
4262 uint32_t sz = htx_get_blksz(blk);
4263 struct ist v;
4264 uint32_t vlen;
4265 char *nl;
4266
Christopher Faulete461e342018-12-18 16:43:35 +01004267 if (type == HTX_BLK_EOM) {
4268 stop = 1;
4269 break;
4270 }
4271
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004272 vlen = sz;
4273 if (vlen > count) {
4274 if (type != HTX_BLK_DATA)
4275 break;
4276 vlen = count;
4277 }
4278
4279 switch (type) {
4280 case HTX_BLK_UNUSED:
4281 break;
4282
4283 case HTX_BLK_DATA:
4284 v = htx_get_blk_value(htx, blk);
4285 v.len = vlen;
4286 nl = istchr(v, '\n');
4287 if (nl != NULL) {
4288 stop = 1;
4289 vlen = nl - v.ptr + 1;
4290 }
4291 luaL_addlstring(&appctx->b, v.ptr, vlen);
4292 break;
4293
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004294 case HTX_BLK_TLR:
4295 case HTX_BLK_EOM:
4296 stop = 1;
4297 break;
4298
4299 default:
4300 break;
4301 }
4302
4303 co_set_data(req, co_data(req) - vlen);
4304 count -= vlen;
4305 if (sz == vlen)
4306 blk = htx_remove_blk(htx, blk);
4307 else {
4308 htx_cut_data_blk(htx, blk, vlen);
4309 break;
4310 }
4311 }
4312
Christopher Faulet0ae79d02019-02-27 21:36:59 +01004313 htx_to_buf(htx, &req->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004314 if (!stop) {
4315 si_cant_get(si);
Christopher Fauleta2097962019-07-15 16:25:33 +02004316 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_getline_yield, TICK_ETERNITY, 0));
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004317 }
4318
4319 /* return the result. */
4320 luaL_pushresult(&appctx->b);
4321 return 1;
4322}
4323
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004324
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004325/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004326__LJMP static int hlua_applet_http_getline(lua_State *L)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004327{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004328 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004329
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004330 /* Initialise the string catenation. */
4331 luaL_buffinit(L, &appctx->b);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004332
Christopher Fauleta2097962019-07-15 16:25:33 +02004333 return MAY_LJMP(hlua_applet_http_getline_yield(L, 0, 0));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004334}
4335
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004336/* If expected data not yet available, it returns a yield. This function
4337 * consumes the data in the buffer. It returns a string containing the
4338 * data. This string can be empty.
4339 */
Christopher Fauleta2097962019-07-15 16:25:33 +02004340__LJMP static int hlua_applet_http_recv_yield(lua_State *L, int status, lua_KContext ctx)
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004341{
4342 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4343 struct stream_interface *si = appctx->appctx->owner;
4344 struct channel *req = si_oc(si);
4345 struct htx *htx;
4346 struct htx_blk *blk;
4347 size_t count;
4348 int len;
4349
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004350 htx = htx_from_buf(&req->buf);
4351 len = MAY_LJMP(luaL_checkinteger(L, 2));
4352 count = co_data(req);
Christopher Faulet29f17582019-05-23 11:03:26 +02004353 blk = htx_get_head_blk(htx);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004354 while (count && len && blk) {
4355 enum htx_blk_type type = htx_get_blk_type(blk);
4356 uint32_t sz = htx_get_blksz(blk);
4357 struct ist v;
4358 uint32_t vlen;
4359
Christopher Faulete461e342018-12-18 16:43:35 +01004360 if (type == HTX_BLK_EOM) {
4361 len = 0;
4362 break;
4363 }
4364
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004365 vlen = sz;
4366 if (len > 0 && vlen > len)
4367 vlen = len;
4368 if (vlen > count) {
4369 if (type != HTX_BLK_DATA)
4370 break;
4371 vlen = count;
4372 }
4373
4374 switch (type) {
4375 case HTX_BLK_UNUSED:
4376 break;
4377
4378 case HTX_BLK_DATA:
4379 v = htx_get_blk_value(htx, blk);
4380 luaL_addlstring(&appctx->b, v.ptr, vlen);
4381 break;
4382
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004383 case HTX_BLK_TLR:
4384 case HTX_BLK_EOM:
4385 len = 0;
4386 break;
4387
4388 default:
4389 break;
4390 }
4391
4392 co_set_data(req, co_data(req) - vlen);
4393 count -= vlen;
4394 if (len > 0)
4395 len -= vlen;
4396 if (sz == vlen)
4397 blk = htx_remove_blk(htx, blk);
4398 else {
4399 htx_cut_data_blk(htx, blk, vlen);
4400 break;
4401 }
4402 }
4403
Christopher Faulet0ae79d02019-02-27 21:36:59 +01004404 htx_to_buf(htx, &req->buf);
4405
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004406 /* If we are no other data available, yield waiting for new data. */
4407 if (len) {
4408 if (len > 0) {
4409 lua_pushinteger(L, len);
4410 lua_replace(L, 2);
4411 }
4412 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02004413 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004414 }
4415
4416 /* return the result. */
4417 luaL_pushresult(&appctx->b);
4418 return 1;
4419}
4420
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004421/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004422__LJMP static int hlua_applet_http_recv(lua_State *L)
4423{
4424 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4425 int len = -1;
4426
4427 /* Check arguments. */
4428 if (lua_gettop(L) > 2)
4429 WILL_LJMP(luaL_error(L, "The 'recv' function requires between 1 and 2 arguments."));
4430 if (lua_gettop(L) >= 2) {
4431 len = MAY_LJMP(luaL_checkinteger(L, 2));
4432 lua_pop(L, 1);
4433 }
4434
Christopher Fauleta2097962019-07-15 16:25:33 +02004435 lua_pushinteger(L, len);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004436
Christopher Fauleta2097962019-07-15 16:25:33 +02004437 /* Initialise the string catenation. */
4438 luaL_buffinit(L, &appctx->b);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004439
Christopher Fauleta2097962019-07-15 16:25:33 +02004440 return MAY_LJMP(hlua_applet_http_recv_yield(L, 0, 0));
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004441}
4442
4443/* Append data in the output side of the buffer. This data is immediately
4444 * sent. The function returns the amount of data written. If the buffer
4445 * cannot contain the data, the function yields. The function returns -1
4446 * if the channel is closed.
4447 */
Christopher Fauleta2097962019-07-15 16:25:33 +02004448__LJMP static int hlua_applet_http_send_yield(lua_State *L, int status, lua_KContext ctx)
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004449{
4450 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4451 struct stream_interface *si = appctx->appctx->owner;
4452 struct channel *res = si_ic(si);
4453 struct htx *htx = htx_from_buf(&res->buf);
4454 const char *data;
4455 size_t len;
4456 int l = MAY_LJMP(luaL_checkinteger(L, 3));
4457 int max;
4458
Christopher Faulet9060fc02019-07-03 11:39:30 +02004459 max = htx_get_max_blksz(htx, channel_htx_recv_max(res, htx));
Christopher Faulet4b0e9b22019-01-09 12:16:58 +01004460 if (!max)
4461 goto snd_yield;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004462
4463 data = MAY_LJMP(luaL_checklstring(L, 2, &len));
4464
4465 /* Get the max amount of data which can write as input in the channel. */
4466 if (max > (len - l))
4467 max = len - l;
4468
4469 /* Copy data. */
Willy Tarreau0a7ef022019-05-28 10:30:11 +02004470 max = htx_add_data(htx, ist2(data + l, max));
Christopher Fauletf6cce3f2019-02-27 21:20:09 +01004471 channel_add_input(res, max);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004472
4473 /* update counters. */
4474 l += max;
4475 lua_pop(L, 1);
4476 lua_pushinteger(L, l);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004477
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004478 /* If some data is not send, declares the situation to the
4479 * applet, and returns a yield.
4480 */
4481 if (l < len) {
Christopher Faulet4b0e9b22019-01-09 12:16:58 +01004482 snd_yield:
Christopher Faulet0ae79d02019-02-27 21:36:59 +01004483 htx_to_buf(htx, &res->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004484 si_rx_room_blk(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02004485 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004486 }
4487
Christopher Fauleta2097962019-07-15 16:25:33 +02004488 htx_to_buf(htx, &res->buf);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004489 return 1;
4490}
4491
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05004492/* Just a wrapper of "hlua_applet_send_yield". This wrapper permits
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004493 * yield the LUA process, and resume it without checking the
4494 * input arguments.
4495 */
4496__LJMP static int hlua_applet_http_send(lua_State *L)
4497{
4498 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004499
4500 /* We want to send some data. Headers must be sent. */
4501 if (!(appctx->appctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT)) {
4502 hlua_pusherror(L, "Lua: 'send' you must call start_response() before sending data.");
4503 WILL_LJMP(lua_error(L));
4504 }
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004505
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05004506 /* This integer is used for followinf the amount of data sent. */
Christopher Fauleta2097962019-07-15 16:25:33 +02004507 lua_pushinteger(L, 0);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004508
Christopher Fauleta2097962019-07-15 16:25:33 +02004509 return MAY_LJMP(hlua_applet_http_send_yield(L, 0, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004510}
4511
4512__LJMP static int hlua_applet_http_addheader(lua_State *L)
4513{
4514 const char *name;
4515 int ret;
4516
4517 MAY_LJMP(hlua_checkapplet_http(L, 1));
4518 name = MAY_LJMP(luaL_checkstring(L, 2));
4519 MAY_LJMP(luaL_checkstring(L, 3));
4520
4521 /* Push in the stack the "response" entry. */
4522 ret = lua_getfield(L, 1, "response");
4523 if (ret != LUA_TTABLE) {
4524 hlua_pusherror(L, "Lua: 'add_header' internal error: AppletHTTP['response'] "
4525 "is expected as an array. %s found", lua_typename(L, ret));
4526 WILL_LJMP(lua_error(L));
4527 }
4528
4529 /* check if the header is already registered if it is not
4530 * the case, register it.
4531 */
4532 ret = lua_getfield(L, -1, name);
4533 if (ret == LUA_TNIL) {
4534
4535 /* Entry not found. */
4536 lua_pop(L, 1); /* remove the nil. The "response" table is the top of the stack. */
4537
4538 /* Insert the new header name in the array in the top of the stack.
4539 * It left the new array in the top of the stack.
4540 */
4541 lua_newtable(L);
4542 lua_pushvalue(L, 2);
4543 lua_pushvalue(L, -2);
4544 lua_settable(L, -4);
4545
4546 } else if (ret != LUA_TTABLE) {
4547
4548 /* corruption error. */
4549 hlua_pusherror(L, "Lua: 'add_header' internal error: AppletHTTP['response']['%s'] "
4550 "is expected as an array. %s found", name, lua_typename(L, ret));
4551 WILL_LJMP(lua_error(L));
4552 }
4553
4554 /* Now the top od thestack is an array of values. We push
4555 * the header value as new entry.
4556 */
4557 lua_pushvalue(L, 3);
4558 ret = lua_rawlen(L, -2);
4559 lua_rawseti(L, -2, ret + 1);
4560 lua_pushboolean(L, 1);
4561 return 1;
4562}
4563
4564__LJMP static int hlua_applet_http_status(lua_State *L)
4565{
4566 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4567 int status = MAY_LJMP(luaL_checkinteger(L, 2));
Robin H. Johnson52f5db22017-01-01 13:10:52 -08004568 const char *reason = MAY_LJMP(luaL_optlstring(L, 3, NULL, NULL));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004569
4570 if (status < 100 || status > 599) {
4571 lua_pushboolean(L, 0);
4572 return 1;
4573 }
4574
4575 appctx->appctx->ctx.hlua_apphttp.status = status;
Robin H. Johnson52f5db22017-01-01 13:10:52 -08004576 appctx->appctx->ctx.hlua_apphttp.reason = reason;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004577 lua_pushboolean(L, 1);
4578 return 1;
4579}
4580
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004581
Christopher Fauleta2097962019-07-15 16:25:33 +02004582__LJMP static int hlua_applet_http_send_response(lua_State *L)
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004583{
4584 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4585 struct stream_interface *si = appctx->appctx->owner;
4586 struct channel *res = si_ic(si);
4587 struct htx *htx;
4588 struct htx_sl *sl;
4589 struct h1m h1m;
4590 const char *status, *reason;
4591 const char *name, *value;
4592 size_t nlen, vlen;
4593 unsigned int flags;
4594
4595 /* Send the message at once. */
4596 htx = htx_from_buf(&res->buf);
4597 h1m_init_res(&h1m);
4598
4599 /* Use the same http version than the request. */
4600 status = ultoa_r(appctx->appctx->ctx.hlua_apphttp.status, trash.area, trash.size);
4601 reason = appctx->appctx->ctx.hlua_apphttp.reason;
4602 if (reason == NULL)
4603 reason = http_get_reason(appctx->appctx->ctx.hlua_apphttp.status);
4604 if (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_HTTP11) {
4605 flags = (HTX_SL_F_IS_RESP|HTX_SL_F_VER_11);
4606 sl = htx_add_stline(htx, HTX_BLK_RES_SL, flags, ist("HTTP/1.1"), ist(status), ist(reason));
4607 }
4608 else {
4609 flags = HTX_SL_F_IS_RESP;
4610 sl = htx_add_stline(htx, HTX_BLK_RES_SL, flags, ist("HTTP/1.0"), ist(status), ist(reason));
4611 }
4612 if (!sl) {
4613 hlua_pusherror(L, "Lua applet http '%s': Failed to create response.\n",
4614 appctx->appctx->rule->arg.hlua_rule->fcn.name);
4615 WILL_LJMP(lua_error(L));
4616 }
4617 sl->info.res.status = appctx->appctx->ctx.hlua_apphttp.status;
4618
4619 /* Get the array associated to the field "response" in the object AppletHTTP. */
4620 lua_pushvalue(L, 0);
4621 if (lua_getfield(L, 1, "response") != LUA_TTABLE) {
4622 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response'] missing.\n",
4623 appctx->appctx->rule->arg.hlua_rule->fcn.name);
4624 WILL_LJMP(lua_error(L));
4625 }
4626
4627 /* Browse the list of headers. */
4628 lua_pushnil(L);
4629 while(lua_next(L, -2) != 0) {
4630 /* We expect a string as -2. */
4631 if (lua_type(L, -2) != LUA_TSTRING) {
4632 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response'][] element must be a string. got %s.\n",
4633 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4634 lua_typename(L, lua_type(L, -2)));
4635 WILL_LJMP(lua_error(L));
4636 }
4637 name = lua_tolstring(L, -2, &nlen);
4638
4639 /* We expect an array as -1. */
4640 if (lua_type(L, -1) != LUA_TTABLE) {
4641 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'] element must be an table. got %s.\n",
4642 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4643 name,
4644 lua_typename(L, lua_type(L, -1)));
4645 WILL_LJMP(lua_error(L));
4646 }
4647
4648 /* Browse the table who is on the top of the stack. */
4649 lua_pushnil(L);
4650 while(lua_next(L, -2) != 0) {
4651 int id;
4652
4653 /* We expect a number as -2. */
4654 if (lua_type(L, -2) != LUA_TNUMBER) {
4655 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'][] element must be a number. got %s.\n",
4656 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4657 name,
4658 lua_typename(L, lua_type(L, -2)));
4659 WILL_LJMP(lua_error(L));
4660 }
4661 id = lua_tointeger(L, -2);
4662
4663 /* We expect a string as -2. */
4664 if (lua_type(L, -1) != LUA_TSTRING) {
4665 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'][%d] element must be a string. got %s.\n",
4666 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4667 name, id,
4668 lua_typename(L, lua_type(L, -1)));
4669 WILL_LJMP(lua_error(L));
4670 }
4671 value = lua_tolstring(L, -1, &vlen);
4672
4673 /* Simple Protocol checks. */
4674 if (isteqi(ist2(name, nlen), ist("transfer-encoding")))
Christopher Faulet700d9e82020-01-31 12:21:52 +01004675 h1_parse_xfer_enc_header(&h1m, ist2(value, vlen));
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004676 else if (isteqi(ist2(name, nlen), ist("content-length"))) {
4677 struct ist v = ist2(value, vlen);
4678 int ret;
4679
4680 ret = h1_parse_cont_len_header(&h1m, &v);
4681 if (ret < 0) {
4682 hlua_pusherror(L, "Lua applet http '%s': Invalid '%s' header.\n",
4683 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4684 name);
4685 WILL_LJMP(lua_error(L));
4686 }
4687 else if (ret == 0)
4688 goto next; /* Skip it */
4689 }
4690
4691 /* Add a new header */
4692 if (!htx_add_header(htx, ist2(name, nlen), ist2(value, vlen))) {
4693 hlua_pusherror(L, "Lua applet http '%s': Failed to add header '%s' in the response.\n",
4694 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4695 name);
4696 WILL_LJMP(lua_error(L));
4697 }
4698 next:
4699 /* Remove the array from the stack, and get next element with a remaining string. */
4700 lua_pop(L, 1);
4701 }
4702
4703 /* Remove the array from the stack, and get next element with a remaining string. */
4704 lua_pop(L, 1);
4705 }
4706
4707 if (h1m.flags & H1_MF_CHNK)
4708 h1m.flags &= ~H1_MF_CLEN;
4709 if (h1m.flags & (H1_MF_CLEN|H1_MF_CHNK))
4710 h1m.flags |= H1_MF_XFER_LEN;
4711
4712 /* Uset HTX start-line flags */
4713 if (h1m.flags & H1_MF_XFER_ENC)
4714 flags |= HTX_SL_F_XFER_ENC;
4715 if (h1m.flags & H1_MF_XFER_LEN) {
4716 flags |= HTX_SL_F_XFER_LEN;
4717 if (h1m.flags & H1_MF_CHNK)
4718 flags |= HTX_SL_F_CHNK;
4719 else if (h1m.flags & H1_MF_CLEN)
4720 flags |= HTX_SL_F_CLEN;
4721 if (h1m.body_len == 0)
4722 flags |= HTX_SL_F_BODYLESS;
4723 }
4724 sl->flags |= flags;
4725
4726 /* If we dont have a content-length set, and the HTTP version is 1.1
4727 * and the status code implies the presence of a message body, we must
4728 * announce a transfer encoding chunked. This is required by haproxy
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05004729 * for the keepalive compliance. If the applet announces a transfer-encoding
4730 * chunked itself, don't do anything.
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004731 */
4732 if ((flags & (HTX_SL_F_VER_11|HTX_SL_F_XFER_LEN)) == HTX_SL_F_VER_11 &&
4733 appctx->appctx->ctx.hlua_apphttp.status >= 200 &&
4734 appctx->appctx->ctx.hlua_apphttp.status != 204 &&
4735 appctx->appctx->ctx.hlua_apphttp.status != 304) {
4736 /* Add a new header */
4737 sl->flags |= (HTX_SL_F_XFER_ENC|H1_MF_CHNK|H1_MF_XFER_LEN);
4738 if (!htx_add_header(htx, ist("transfer-encoding"), ist("chunked"))) {
4739 hlua_pusherror(L, "Lua applet http '%s': Failed to add header 'transfer-encoding' in the response.\n",
4740 appctx->appctx->rule->arg.hlua_rule->fcn.name);
4741 WILL_LJMP(lua_error(L));
4742 }
4743 }
4744
4745 /* Finalize headers. */
4746 if (!htx_add_endof(htx, HTX_BLK_EOH)) {
4747 hlua_pusherror(L, "Lua applet http '%s': Failed create the response.\n",
4748 appctx->appctx->rule->arg.hlua_rule->fcn.name);
4749 WILL_LJMP(lua_error(L));
4750 }
4751
4752 if (htx_used_space(htx) > b_size(&res->buf) - global.tune.maxrewrite) {
4753 b_reset(&res->buf);
4754 hlua_pusherror(L, "Lua: 'start_response': response header block too big");
4755 WILL_LJMP(lua_error(L));
4756 }
4757
4758 htx_to_buf(htx, &res->buf);
Christopher Fauletf6cce3f2019-02-27 21:20:09 +01004759 channel_add_input(res, htx->data);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004760
4761 /* Headers sent, set the flag. */
4762 appctx->appctx->ctx.hlua_apphttp.flags |= APPLET_HDR_SENT;
4763 return 0;
4764
4765}
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004766/* We will build the status line and the headers of the HTTP response.
4767 * We will try send at once if its not possible, we give back the hand
4768 * waiting for more room.
4769 */
Christopher Fauleta2097962019-07-15 16:25:33 +02004770__LJMP static int hlua_applet_http_start_response_yield(lua_State *L, int status, lua_KContext ctx)
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004771{
4772 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4773 struct stream_interface *si = appctx->appctx->owner;
4774 struct channel *res = si_ic(si);
4775
4776 if (co_data(res)) {
4777 si_rx_room_blk(si);
Christopher Fauleta2097962019-07-15 16:25:33 +02004778 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_start_response_yield, TICK_ETERNITY, 0));
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004779 }
Christopher Fauleta2097962019-07-15 16:25:33 +02004780 return MAY_LJMP(hlua_applet_http_send_response(L));
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004781}
4782
4783
Christopher Fauleta2097962019-07-15 16:25:33 +02004784__LJMP static int hlua_applet_http_start_response(lua_State *L)
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004785{
Christopher Fauleta2097962019-07-15 16:25:33 +02004786 return MAY_LJMP(hlua_applet_http_start_response_yield(L, 0, 0));
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004787}
4788
Christopher Fauleta2097962019-07-15 16:25:33 +02004789/*
4790 *
4791 *
4792 * Class HTTP
4793 *
4794 *
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004795 */
Christopher Fauleta2097962019-07-15 16:25:33 +02004796
4797/* Returns a struct hlua_txn if the stack entry "ud" is
4798 * a class stream, otherwise it throws an error.
4799 */
4800__LJMP static struct hlua_txn *hlua_checkhttp(lua_State *L, int ud)
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004801{
Christopher Fauleta2097962019-07-15 16:25:33 +02004802 return MAY_LJMP(hlua_checkudata(L, ud, class_http_ref));
4803}
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004804
Christopher Fauleta2097962019-07-15 16:25:33 +02004805/* This function creates and push in the stack a HTTP object
4806 * according with a current TXN.
4807 */
4808static int hlua_http_new(lua_State *L, struct hlua_txn *txn)
4809{
4810 struct hlua_txn *htxn;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004811
Christopher Fauleta2097962019-07-15 16:25:33 +02004812 /* Check stack size. */
4813 if (!lua_checkstack(L, 3))
4814 return 0;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004815
Christopher Fauleta2097962019-07-15 16:25:33 +02004816 /* Create the object: obj[0] = userdata.
4817 * Note that the base of the Converters object is the
4818 * same than the TXN object.
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004819 */
Christopher Fauleta2097962019-07-15 16:25:33 +02004820 lua_newtable(L);
4821 htxn = lua_newuserdata(L, sizeof(*htxn));
4822 lua_rawseti(L, -2, 0);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004823
4824 htxn->s = txn->s;
4825 htxn->p = txn->p;
Christopher Faulet256b69a2019-05-23 11:14:21 +02004826 htxn->dir = txn->dir;
4827 htxn->flags = txn->flags;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004828
4829 /* Pop a class stream metatable and affect it to the table. */
4830 lua_rawgeti(L, LUA_REGISTRYINDEX, class_http_ref);
4831 lua_setmetatable(L, -2);
4832
4833 return 1;
4834}
4835
4836/* This function creates ans returns an array of HTTP headers.
4837 * This function does not fails. It is used as wrapper with the
4838 * 2 following functions.
4839 */
Christopher Faulet9d1332b2020-02-24 16:46:16 +01004840__LJMP static int hlua_http_get_headers(lua_State *L, struct http_msg *msg)
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004841{
Christopher Fauleta2097962019-07-15 16:25:33 +02004842 struct htx *htx;
4843 int32_t pos;
4844
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004845 /* Create the table. */
4846 lua_newtable(L);
4847
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004848
Christopher Fauleta2097962019-07-15 16:25:33 +02004849 htx = htxbuf(&msg->chn->buf);
4850 for (pos = htx_get_first(htx); pos != -1; pos = htx_get_next(htx, pos)) {
4851 struct htx_blk *blk = htx_get_blk(htx, pos);
4852 enum htx_blk_type type = htx_get_blk_type(blk);
4853 struct ist n, v;
4854 int len;
Christopher Faulet724a12c2018-12-13 22:12:15 +01004855
Christopher Fauleta2097962019-07-15 16:25:33 +02004856 if (type == HTX_BLK_HDR) {
4857 n = htx_get_blk_name(htx,blk);
4858 v = htx_get_blk_value(htx, blk);
Christopher Faulet724a12c2018-12-13 22:12:15 +01004859 }
Christopher Fauleta2097962019-07-15 16:25:33 +02004860 else if (type == HTX_BLK_EOH)
4861 break;
4862 else
4863 continue;
Christopher Faulet724a12c2018-12-13 22:12:15 +01004864
Christopher Fauleta2097962019-07-15 16:25:33 +02004865 /* Check for existing entry:
4866 * assume that the table is on the top of the stack, and
4867 * push the key in the stack, the function lua_gettable()
4868 * perform the lookup.
4869 */
4870 lua_pushlstring(L, n.ptr, n.len);
4871 lua_gettable(L, -2);
Christopher Faulet724a12c2018-12-13 22:12:15 +01004872
Christopher Fauleta2097962019-07-15 16:25:33 +02004873 switch (lua_type(L, -1)) {
4874 case LUA_TNIL:
4875 /* Table not found, create it. */
4876 lua_pop(L, 1); /* remove the nil value. */
4877 lua_pushlstring(L, n.ptr, n.len); /* push the header name as key. */
4878 lua_newtable(L); /* create and push empty table. */
4879 lua_pushlstring(L, v.ptr, v.len); /* push header value. */
4880 lua_rawseti(L, -2, 0); /* index header value (pop it). */
4881 lua_rawset(L, -3); /* index new table with header name (pop the values). */
Christopher Faulet724a12c2018-12-13 22:12:15 +01004882 break;
Christopher Faulet724a12c2018-12-13 22:12:15 +01004883
Christopher Fauleta2097962019-07-15 16:25:33 +02004884 case LUA_TTABLE:
4885 /* Entry found: push the value in the table. */
4886 len = lua_rawlen(L, -1);
4887 lua_pushlstring(L, v.ptr, v.len); /* push header value. */
4888 lua_rawseti(L, -2, len+1); /* index header value (pop it). */
4889 lua_pop(L, 1); /* remove the table (it is stored in the main table). */
4890 break;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004891
Christopher Fauleta2097962019-07-15 16:25:33 +02004892 default:
4893 /* Other cases are errors. */
4894 hlua_pusherror(L, "internal error during the parsing of headers.");
4895 WILL_LJMP(lua_error(L));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004896 }
4897 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004898 return 1;
4899}
4900
4901__LJMP static int hlua_http_req_get_headers(lua_State *L)
4902{
4903 struct hlua_txn *htxn;
4904
4905 MAY_LJMP(check_args(L, 1, "req_get_headers"));
4906 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4907
Christopher Fauletd8f0e072020-02-25 09:45:51 +01004908 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02004909 WILL_LJMP(lua_error(L));
4910
Christopher Faulet9d1332b2020-02-24 16:46:16 +01004911 return hlua_http_get_headers(L, &htxn->s->txn->req);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004912}
4913
4914__LJMP static int hlua_http_res_get_headers(lua_State *L)
4915{
4916 struct hlua_txn *htxn;
4917
4918 MAY_LJMP(check_args(L, 1, "res_get_headers"));
4919 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4920
Christopher Fauletd8f0e072020-02-25 09:45:51 +01004921 if (htxn->dir != SMP_OPT_DIR_RES || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02004922 WILL_LJMP(lua_error(L));
4923
Christopher Faulet9d1332b2020-02-24 16:46:16 +01004924 return hlua_http_get_headers(L, &htxn->s->txn->rsp);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004925}
4926
4927/* This function replace full header, or just a value in
4928 * the request or in the response. It is a wrapper fir the
4929 * 4 following functions.
4930 */
Christopher Fauletd1914aa2020-02-24 16:52:46 +01004931__LJMP static inline int hlua_http_rep_hdr(lua_State *L, struct http_msg *msg, int full)
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004932{
4933 size_t name_len;
4934 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
4935 const char *reg = MAY_LJMP(luaL_checkstring(L, 3));
4936 const char *value = MAY_LJMP(luaL_checkstring(L, 4));
Christopher Fauleta2097962019-07-15 16:25:33 +02004937 struct htx *htx;
Dragan Dosen26743032019-04-30 15:54:36 +02004938 struct my_regex *re;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004939
Dragan Dosen26743032019-04-30 15:54:36 +02004940 if (!(re = regex_comp(reg, 1, 1, NULL)))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004941 WILL_LJMP(luaL_argerror(L, 3, "invalid regex"));
4942
Christopher Fauleta2097962019-07-15 16:25:33 +02004943 htx = htxbuf(&msg->chn->buf);
Christopher Fauletd1914aa2020-02-24 16:52:46 +01004944 http_replace_hdrs(chn_strm(msg->chn), htx, ist2(name, name_len), value, re, full);
Dragan Dosen26743032019-04-30 15:54:36 +02004945 regex_free(re);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004946 return 0;
4947}
4948
4949__LJMP static int hlua_http_req_rep_hdr(lua_State *L)
4950{
4951 struct hlua_txn *htxn;
4952
4953 MAY_LJMP(check_args(L, 4, "req_rep_hdr"));
4954 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4955
Christopher Fauletd8f0e072020-02-25 09:45:51 +01004956 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02004957 WILL_LJMP(lua_error(L));
4958
Christopher Fauletd1914aa2020-02-24 16:52:46 +01004959 return MAY_LJMP(hlua_http_rep_hdr(L, &htxn->s->txn->req, 1));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004960}
4961
4962__LJMP static int hlua_http_res_rep_hdr(lua_State *L)
4963{
4964 struct hlua_txn *htxn;
4965
4966 MAY_LJMP(check_args(L, 4, "res_rep_hdr"));
4967 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4968
Christopher Fauletd8f0e072020-02-25 09:45:51 +01004969 if (htxn->dir != SMP_OPT_DIR_RES || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02004970 WILL_LJMP(lua_error(L));
4971
Christopher Fauletd1914aa2020-02-24 16:52:46 +01004972 return MAY_LJMP(hlua_http_rep_hdr(L, &htxn->s->txn->rsp, 1));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004973}
4974
4975__LJMP static int hlua_http_req_rep_val(lua_State *L)
4976{
4977 struct hlua_txn *htxn;
4978
4979 MAY_LJMP(check_args(L, 4, "req_rep_hdr"));
4980 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4981
Christopher Fauletd8f0e072020-02-25 09:45:51 +01004982 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02004983 WILL_LJMP(lua_error(L));
4984
Christopher Fauletd1914aa2020-02-24 16:52:46 +01004985 return MAY_LJMP(hlua_http_rep_hdr(L, &htxn->s->txn->req, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004986}
4987
4988__LJMP static int hlua_http_res_rep_val(lua_State *L)
4989{
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004990 struct hlua_txn *htxn;
4991
4992 MAY_LJMP(check_args(L, 4, "res_rep_val"));
4993 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
4994
Christopher Fauletd8f0e072020-02-25 09:45:51 +01004995 if (htxn->dir != SMP_OPT_DIR_RES || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02004996 WILL_LJMP(lua_error(L));
4997
Christopher Fauletd1914aa2020-02-24 16:52:46 +01004998 return MAY_LJMP(hlua_http_rep_hdr(L, &htxn->s->txn->rsp, 0));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004999}
5000
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08005001/* This function deletes all the occurrences of an header.
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005002 * It is a wrapper for the 2 following functions.
5003 */
Christopher Fauletd31c7b32020-02-25 09:37:57 +01005004__LJMP static inline int hlua_http_del_hdr(lua_State *L, struct http_msg *msg)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005005{
5006 size_t len;
5007 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &len));
Christopher Fauleta2097962019-07-15 16:25:33 +02005008 struct htx *htx = htxbuf(&msg->chn->buf);
5009 struct http_hdr_ctx ctx;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005010
Christopher Fauleta2097962019-07-15 16:25:33 +02005011 ctx.blk = NULL;
5012 while (http_find_header(htx, ist2(name, len), &ctx, 1))
5013 http_remove_header(htx, &ctx);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005014 return 0;
5015}
5016
5017__LJMP static int hlua_http_req_del_hdr(lua_State *L)
5018{
5019 struct hlua_txn *htxn;
5020
5021 MAY_LJMP(check_args(L, 2, "req_del_hdr"));
5022 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5023
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005024 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005025 WILL_LJMP(lua_error(L));
5026
Christopher Fauletd31c7b32020-02-25 09:37:57 +01005027 return hlua_http_del_hdr(L, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005028}
5029
5030__LJMP static int hlua_http_res_del_hdr(lua_State *L)
5031{
5032 struct hlua_txn *htxn;
5033
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005034 MAY_LJMP(check_args(L, 2, "res_del_hdr"));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005035 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5036
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005037 if (htxn->dir != SMP_OPT_DIR_RES || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005038 WILL_LJMP(lua_error(L));
5039
Christopher Fauletd31c7b32020-02-25 09:37:57 +01005040 return hlua_http_del_hdr(L, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005041}
5042
5043/* This function adds an header. It is a wrapper used by
5044 * the 2 following functions.
5045 */
Christopher Fauletd31c7b32020-02-25 09:37:57 +01005046__LJMP static inline int hlua_http_add_hdr(lua_State *L, struct http_msg *msg)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005047{
5048 size_t name_len;
5049 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
5050 size_t value_len;
5051 const char *value = MAY_LJMP(luaL_checklstring(L, 3, &value_len));
Christopher Fauleta2097962019-07-15 16:25:33 +02005052 struct htx *htx = htxbuf(&msg->chn->buf);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005053
Christopher Fauleta2097962019-07-15 16:25:33 +02005054 lua_pushboolean(L, http_add_header(htx, ist2(name, name_len),
5055 ist2(value, value_len)));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005056 return 0;
5057}
5058
5059__LJMP static int hlua_http_req_add_hdr(lua_State *L)
5060{
5061 struct hlua_txn *htxn;
5062
5063 MAY_LJMP(check_args(L, 3, "req_add_hdr"));
5064 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5065
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005066 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005067 WILL_LJMP(lua_error(L));
5068
Christopher Fauletd31c7b32020-02-25 09:37:57 +01005069 return hlua_http_add_hdr(L, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005070}
5071
5072__LJMP static int hlua_http_res_add_hdr(lua_State *L)
5073{
5074 struct hlua_txn *htxn;
5075
5076 MAY_LJMP(check_args(L, 3, "res_add_hdr"));
5077 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5078
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005079 if (htxn->dir != SMP_OPT_DIR_RES || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005080 WILL_LJMP(lua_error(L));
5081
Christopher Fauletd31c7b32020-02-25 09:37:57 +01005082 return hlua_http_add_hdr(L, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005083}
5084
5085static int hlua_http_req_set_hdr(lua_State *L)
5086{
5087 struct hlua_txn *htxn;
5088
5089 MAY_LJMP(check_args(L, 3, "req_set_hdr"));
5090 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5091
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005092 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005093 WILL_LJMP(lua_error(L));
5094
Christopher Fauletd31c7b32020-02-25 09:37:57 +01005095 hlua_http_del_hdr(L, &htxn->s->txn->req);
5096 return hlua_http_add_hdr(L, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005097}
5098
5099static int hlua_http_res_set_hdr(lua_State *L)
5100{
5101 struct hlua_txn *htxn;
5102
5103 MAY_LJMP(check_args(L, 3, "res_set_hdr"));
5104 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5105
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005106 if (htxn->dir != SMP_OPT_DIR_RES || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005107 WILL_LJMP(lua_error(L));
5108
Christopher Fauletd31c7b32020-02-25 09:37:57 +01005109 hlua_http_del_hdr(L, &htxn->s->txn->rsp);
5110 return hlua_http_add_hdr(L, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005111}
5112
5113/* This function set the method. */
5114static int hlua_http_req_set_meth(lua_State *L)
5115{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02005116 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005117 size_t name_len;
5118 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005119
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005120 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005121 WILL_LJMP(lua_error(L));
5122
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02005123 lua_pushboolean(L, http_req_replace_stline(0, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005124 return 1;
5125}
5126
5127/* This function set the method. */
5128static int hlua_http_req_set_path(lua_State *L)
5129{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02005130 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005131 size_t name_len;
5132 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER / OZON.IOb84ae922016-08-02 23:44:58 +02005133
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005134 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005135 WILL_LJMP(lua_error(L));
5136
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02005137 lua_pushboolean(L, http_req_replace_stline(1, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005138 return 1;
5139}
5140
5141/* This function set the query-string. */
5142static int hlua_http_req_set_query(lua_State *L)
5143{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02005144 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005145 size_t name_len;
5146 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005147
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005148 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005149 WILL_LJMP(lua_error(L));
5150
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005151 /* Check length. */
5152 if (name_len > trash.size - 1) {
5153 lua_pushboolean(L, 0);
5154 return 1;
5155 }
5156
5157 /* Add the mark question as prefix. */
5158 chunk_reset(&trash);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005159 trash.area[trash.data++] = '?';
5160 memcpy(trash.area + trash.data, name, name_len);
5161 trash.data += name_len;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005162
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005163 lua_pushboolean(L,
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02005164 http_req_replace_stline(2, trash.area, trash.data, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005165 return 1;
5166}
5167
5168/* This function set the uri. */
5169static int hlua_http_req_set_uri(lua_State *L)
5170{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02005171 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005172 size_t name_len;
5173 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005174
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005175 if (htxn->dir != SMP_OPT_DIR_REQ || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005176 WILL_LJMP(lua_error(L));
5177
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02005178 lua_pushboolean(L, http_req_replace_stline(3, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005179 return 1;
5180}
5181
Robin H. Johnson52f5db22017-01-01 13:10:52 -08005182/* This function set the response code & optionally reason. */
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02005183static int hlua_http_res_set_status(lua_State *L)
5184{
5185 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5186 unsigned int code = MAY_LJMP(luaL_checkinteger(L, 2));
Christopher Faulet96bff762019-12-17 13:46:18 +01005187 const char *str = MAY_LJMP(luaL_optlstring(L, 3, NULL, NULL));
5188 const struct ist reason = ist2(str, (str ? strlen(str) : 0));
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02005189
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005190 if (htxn->dir != SMP_OPT_DIR_RES || !IS_HTX_STRM(htxn->s))
Christopher Faulet84a6d5b2019-07-26 16:17:01 +02005191 WILL_LJMP(lua_error(L));
5192
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02005193 http_res_set_status(code, reason, htxn->s);
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02005194 return 0;
5195}
5196
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005197/*
5198 *
5199 *
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005200 * Class TXN
5201 *
5202 *
5203 */
5204
5205/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02005206 * a class stream, otherwise it throws an error.
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005207 */
5208__LJMP static struct hlua_txn *hlua_checktxn(lua_State *L, int ud)
5209{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02005210 return MAY_LJMP(hlua_checkudata(L, ud, class_txn_ref));
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005211}
5212
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005213__LJMP static int hlua_set_var(lua_State *L)
5214{
5215 struct hlua_txn *htxn;
5216 const char *name;
5217 size_t len;
5218 struct sample smp;
5219
Tim Duesterhus4e172c92020-05-19 13:49:42 +02005220 if (lua_gettop(L) < 3 || lua_gettop(L) > 4)
5221 WILL_LJMP(luaL_error(L, "'set_var' needs between 3 and 4 arguments"));
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005222
5223 /* It is useles to retrieve the stream, but this function
5224 * runs only in a stream context.
5225 */
5226 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5227 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
5228
5229 /* Converts the third argument in a sample. */
5230 hlua_lua2smp(L, 3, &smp);
5231
5232 /* Store the sample in a variable. */
Willy Tarreau7560dd42016-03-10 16:28:58 +01005233 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
Tim Duesterhus4e172c92020-05-19 13:49:42 +02005234
5235 if (lua_gettop(L) == 4 && lua_toboolean(L, 4))
5236 lua_pushboolean(L, vars_set_by_name_ifexist(name, len, &smp) != 0);
5237 else
5238 lua_pushboolean(L, vars_set_by_name(name, len, &smp) != 0);
5239
Tim Duesterhus84ebc132020-05-19 13:49:41 +02005240 return 1;
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005241}
5242
Christopher Faulet85d79c92016-11-09 16:54:56 +01005243__LJMP static int hlua_unset_var(lua_State *L)
5244{
5245 struct hlua_txn *htxn;
5246 const char *name;
5247 size_t len;
5248 struct sample smp;
5249
5250 MAY_LJMP(check_args(L, 2, "unset_var"));
5251
5252 /* It is useles to retrieve the stream, but this function
5253 * runs only in a stream context.
5254 */
5255 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5256 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
5257
5258 /* Unset the variable. */
5259 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
Tim Duesterhus84ebc132020-05-19 13:49:41 +02005260 lua_pushboolean(L, vars_unset_by_name_ifexist(name, len, &smp) != 0);
5261 return 1;
Christopher Faulet85d79c92016-11-09 16:54:56 +01005262}
5263
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005264__LJMP static int hlua_get_var(lua_State *L)
5265{
5266 struct hlua_txn *htxn;
5267 const char *name;
5268 size_t len;
5269 struct sample smp;
5270
5271 MAY_LJMP(check_args(L, 2, "get_var"));
5272
5273 /* It is useles to retrieve the stream, but this function
5274 * runs only in a stream context.
5275 */
5276 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5277 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
5278
Willy Tarreau7560dd42016-03-10 16:28:58 +01005279 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
Willy Tarreau6204cd92016-03-10 16:33:04 +01005280 if (!vars_get_by_name(name, len, &smp)) {
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005281 lua_pushnil(L);
5282 return 1;
5283 }
5284
5285 return hlua_smp2lua(L, &smp);
5286}
5287
Willy Tarreau59551662015-03-10 14:23:13 +01005288__LJMP static int hlua_set_priv(lua_State *L)
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005289{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005290 struct hlua *hlua;
5291
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005292 MAY_LJMP(check_args(L, 2, "set_priv"));
5293
Willy Tarreau87b09662015-04-03 00:22:06 +02005294 /* It is useles to retrieve the stream, but this function
5295 * runs only in a stream context.
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005296 */
5297 MAY_LJMP(hlua_checktxn(L, 1));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005298 hlua = hlua_gethlua(L);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005299
5300 /* Remove previous value. */
Thierry FOURNIERe068b602017-04-26 13:27:05 +02005301 luaL_unref(L, LUA_REGISTRYINDEX, hlua->Mref);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005302
5303 /* Get and store new value. */
5304 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
5305 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
5306
5307 return 0;
5308}
5309
Willy Tarreau59551662015-03-10 14:23:13 +01005310__LJMP static int hlua_get_priv(lua_State *L)
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005311{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005312 struct hlua *hlua;
5313
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005314 MAY_LJMP(check_args(L, 1, "get_priv"));
5315
Willy Tarreau87b09662015-04-03 00:22:06 +02005316 /* It is useles to retrieve the stream, but this function
5317 * runs only in a stream context.
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005318 */
5319 MAY_LJMP(hlua_checktxn(L, 1));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005320 hlua = hlua_gethlua(L);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005321
5322 /* Push configuration index in the stack. */
5323 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
5324
5325 return 1;
5326}
5327
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005328/* Create stack entry containing a class TXN. This function
5329 * return 0 if the stack does not contains free slots,
5330 * otherwise it returns 1.
5331 */
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005332static int hlua_txn_new(lua_State *L, struct stream *s, struct proxy *p, int dir, int flags)
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005333{
Willy Tarreaude491382015-04-06 11:04:28 +02005334 struct hlua_txn *htxn;
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005335
5336 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01005337 if (!lua_checkstack(L, 3))
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005338 return 0;
5339
5340 /* NOTE: The allocation never fails. The failure
5341 * throw an error, and the function never returns.
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08005342 * if the throw is not available, the process is aborted.
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005343 */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01005344 /* Create the object: obj[0] = userdata. */
5345 lua_newtable(L);
Willy Tarreaude491382015-04-06 11:04:28 +02005346 htxn = lua_newuserdata(L, sizeof(*htxn));
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01005347 lua_rawseti(L, -2, 0);
5348
Willy Tarreaude491382015-04-06 11:04:28 +02005349 htxn->s = s;
5350 htxn->p = p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01005351 htxn->dir = dir;
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005352 htxn->flags = flags;
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005353
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01005354 /* Create the "f" field that contains a list of fetches. */
5355 lua_pushstring(L, "f");
Thierry FOURNIERca988662015-12-20 18:43:03 +01005356 if (!hlua_fetches_new(L, htxn, HLUA_F_MAY_USE_HTTP))
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01005357 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005358 lua_rawset(L, -3);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01005359
5360 /* Create the "sf" field that contains a list of stringsafe fetches. */
5361 lua_pushstring(L, "sf");
Thierry FOURNIERca988662015-12-20 18:43:03 +01005362 if (!hlua_fetches_new(L, htxn, HLUA_F_MAY_USE_HTTP | HLUA_F_AS_STRING))
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01005363 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005364 lua_rawset(L, -3);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01005365
Thierry FOURNIER594afe72015-03-10 23:58:30 +01005366 /* Create the "c" field that contains a list of converters. */
5367 lua_pushstring(L, "c");
Willy Tarreaude491382015-04-06 11:04:28 +02005368 if (!hlua_converters_new(L, htxn, 0))
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01005369 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005370 lua_rawset(L, -3);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01005371
5372 /* Create the "sc" field that contains a list of stringsafe converters. */
5373 lua_pushstring(L, "sc");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01005374 if (!hlua_converters_new(L, htxn, HLUA_F_AS_STRING))
Thierry FOURNIER594afe72015-03-10 23:58:30 +01005375 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005376 lua_rawset(L, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01005377
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005378 /* Create the "req" field that contains the request channel object. */
5379 lua_pushstring(L, "req");
Willy Tarreau2a71af42015-03-10 13:51:50 +01005380 if (!hlua_channel_new(L, &s->req))
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005381 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005382 lua_rawset(L, -3);
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005383
5384 /* Create the "res" field that contains the response channel object. */
5385 lua_pushstring(L, "res");
Willy Tarreau2a71af42015-03-10 13:51:50 +01005386 if (!hlua_channel_new(L, &s->res))
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005387 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005388 lua_rawset(L, -3);
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005389
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005390 /* Creates the HTTP object is the current proxy allows http. */
5391 lua_pushstring(L, "http");
5392 if (p->mode == PR_MODE_HTTP) {
Willy Tarreaude491382015-04-06 11:04:28 +02005393 if (!hlua_http_new(L, htxn))
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005394 return 0;
5395 }
5396 else
5397 lua_pushnil(L);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005398 lua_rawset(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005399
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005400 /* Pop a class sesison metatable and affect it to the userdata. */
5401 lua_rawgeti(L, LUA_REGISTRYINDEX, class_txn_ref);
5402 lua_setmetatable(L, -2);
5403
5404 return 1;
5405}
5406
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01005407__LJMP static int hlua_txn_deflog(lua_State *L)
5408{
5409 const char *msg;
5410 struct hlua_txn *htxn;
5411
5412 MAY_LJMP(check_args(L, 2, "deflog"));
5413 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5414 msg = MAY_LJMP(luaL_checkstring(L, 2));
5415
5416 hlua_sendlog(htxn->s->be, htxn->s->logs.level, msg);
5417 return 0;
5418}
5419
5420__LJMP static int hlua_txn_log(lua_State *L)
5421{
5422 int level;
5423 const char *msg;
5424 struct hlua_txn *htxn;
5425
5426 MAY_LJMP(check_args(L, 3, "log"));
5427 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5428 level = MAY_LJMP(luaL_checkinteger(L, 2));
5429 msg = MAY_LJMP(luaL_checkstring(L, 3));
5430
5431 if (level < 0 || level >= NB_LOG_LEVELS)
5432 WILL_LJMP(luaL_argerror(L, 1, "Invalid loglevel."));
5433
5434 hlua_sendlog(htxn->s->be, level, msg);
5435 return 0;
5436}
5437
5438__LJMP static int hlua_txn_log_debug(lua_State *L)
5439{
5440 const char *msg;
5441 struct hlua_txn *htxn;
5442
5443 MAY_LJMP(check_args(L, 2, "Debug"));
5444 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5445 msg = MAY_LJMP(luaL_checkstring(L, 2));
5446 hlua_sendlog(htxn->s->be, LOG_DEBUG, msg);
5447 return 0;
5448}
5449
5450__LJMP static int hlua_txn_log_info(lua_State *L)
5451{
5452 const char *msg;
5453 struct hlua_txn *htxn;
5454
5455 MAY_LJMP(check_args(L, 2, "Info"));
5456 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5457 msg = MAY_LJMP(luaL_checkstring(L, 2));
5458 hlua_sendlog(htxn->s->be, LOG_INFO, msg);
5459 return 0;
5460}
5461
5462__LJMP static int hlua_txn_log_warning(lua_State *L)
5463{
5464 const char *msg;
5465 struct hlua_txn *htxn;
5466
5467 MAY_LJMP(check_args(L, 2, "Warning"));
5468 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5469 msg = MAY_LJMP(luaL_checkstring(L, 2));
5470 hlua_sendlog(htxn->s->be, LOG_WARNING, msg);
5471 return 0;
5472}
5473
5474__LJMP static int hlua_txn_log_alert(lua_State *L)
5475{
5476 const char *msg;
5477 struct hlua_txn *htxn;
5478
5479 MAY_LJMP(check_args(L, 2, "Alert"));
5480 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5481 msg = MAY_LJMP(luaL_checkstring(L, 2));
5482 hlua_sendlog(htxn->s->be, LOG_ALERT, msg);
5483 return 0;
5484}
5485
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005486__LJMP static int hlua_txn_set_loglevel(lua_State *L)
5487{
5488 struct hlua_txn *htxn;
5489 int ll;
5490
5491 MAY_LJMP(check_args(L, 2, "set_loglevel"));
5492 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5493 ll = MAY_LJMP(luaL_checkinteger(L, 2));
5494
5495 if (ll < 0 || ll > 7)
5496 WILL_LJMP(luaL_argerror(L, 2, "Bad log level. It must be between 0 and 7"));
5497
5498 htxn->s->logs.level = ll;
5499 return 0;
5500}
5501
5502__LJMP static int hlua_txn_set_tos(lua_State *L)
5503{
5504 struct hlua_txn *htxn;
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005505 int tos;
5506
5507 MAY_LJMP(check_args(L, 2, "set_tos"));
5508 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5509 tos = MAY_LJMP(luaL_checkinteger(L, 2));
5510
Willy Tarreau1a18b542018-12-11 16:37:42 +01005511 conn_set_tos(objt_conn(htxn->s->sess->origin), tos);
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005512 return 0;
5513}
5514
5515__LJMP static int hlua_txn_set_mark(lua_State *L)
5516{
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005517 struct hlua_txn *htxn;
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005518 int mark;
5519
5520 MAY_LJMP(check_args(L, 2, "set_mark"));
5521 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5522 mark = MAY_LJMP(luaL_checkinteger(L, 2));
5523
Lukas Tribus579e3e32019-08-11 18:03:45 +02005524 conn_set_mark(objt_conn(htxn->s->sess->origin), mark);
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005525 return 0;
5526}
5527
Patrick Hemmer268a7072018-05-11 12:52:31 -04005528__LJMP static int hlua_txn_set_priority_class(lua_State *L)
5529{
5530 struct hlua_txn *htxn;
5531
5532 MAY_LJMP(check_args(L, 2, "set_priority_class"));
5533 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5534 htxn->s->priority_class = queue_limit_class(MAY_LJMP(luaL_checkinteger(L, 2)));
5535 return 0;
5536}
5537
5538__LJMP static int hlua_txn_set_priority_offset(lua_State *L)
5539{
5540 struct hlua_txn *htxn;
5541
5542 MAY_LJMP(check_args(L, 2, "set_priority_offset"));
5543 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5544 htxn->s->priority_offset = queue_limit_offset(MAY_LJMP(luaL_checkinteger(L, 2)));
5545 return 0;
5546}
5547
Christopher Faulet700d9e82020-01-31 12:21:52 +01005548/* Forward the Reply object to the client. This function converts the reply in
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05005549 * HTX an push it to into the response channel. It is response to forward the
Christopher Faulet700d9e82020-01-31 12:21:52 +01005550 * message and terminate the transaction. It returns 1 on success and 0 on
5551 * error. The Reply must be on top of the stack.
5552 */
5553__LJMP static int hlua_txn_forward_reply(lua_State *L, struct stream *s)
5554{
5555 struct htx *htx;
5556 struct htx_sl *sl;
5557 struct h1m h1m;
5558 const char *status, *reason, *body;
5559 size_t status_len, reason_len, body_len;
5560 int ret, code, flags;
5561
5562 code = 200;
5563 status = "200";
5564 status_len = 3;
5565 ret = lua_getfield(L, -1, "status");
5566 if (ret == LUA_TNUMBER) {
5567 code = lua_tointeger(L, -1);
5568 status = lua_tolstring(L, -1, &status_len);
5569 }
5570 lua_pop(L, 1);
5571
5572 reason = http_get_reason(code);
5573 reason_len = strlen(reason);
5574 ret = lua_getfield(L, -1, "reason");
5575 if (ret == LUA_TSTRING)
5576 reason = lua_tolstring(L, -1, &reason_len);
5577 lua_pop(L, 1);
5578
5579 body = NULL;
5580 body_len = 0;
5581 ret = lua_getfield(L, -1, "body");
5582 if (ret == LUA_TSTRING)
5583 body = lua_tolstring(L, -1, &body_len);
5584 lua_pop(L, 1);
5585
5586 /* Prepare the response before inserting the headers */
5587 h1m_init_res(&h1m);
5588 htx = htx_from_buf(&s->res.buf);
5589 channel_htx_truncate(&s->res, htx);
5590 if (s->txn->req.flags & HTTP_MSGF_VER_11) {
5591 flags = (HTX_SL_F_IS_RESP|HTX_SL_F_VER_11);
5592 sl = htx_add_stline(htx, HTX_BLK_RES_SL, flags, ist("HTTP/1.1"),
5593 ist2(status, status_len), ist2(reason, reason_len));
5594 }
5595 else {
5596 flags = HTX_SL_F_IS_RESP;
5597 sl = htx_add_stline(htx, HTX_BLK_RES_SL, flags, ist("HTTP/1.0"),
5598 ist2(status, status_len), ist2(reason, reason_len));
5599 }
5600 if (!sl)
5601 goto fail;
5602 sl->info.res.status = code;
5603
5604 /* Push in the stack the "headers" entry. */
5605 ret = lua_getfield(L, -1, "headers");
5606 if (ret != LUA_TTABLE)
5607 goto skip_headers;
5608
5609 lua_pushnil(L);
5610 while (lua_next(L, -2) != 0) {
5611 struct ist name, value;
5612 const char *n, *v;
5613 size_t nlen, vlen;
5614
5615 if (!lua_isstring(L, -2) || !lua_istable(L, -1)) {
5616 /* Skip element if the key is not a string or if the value is not a table */
5617 goto next_hdr;
5618 }
5619
5620 n = lua_tolstring(L, -2, &nlen);
5621 name = ist2(n, nlen);
5622 if (isteqi(name, ist("content-length"))) {
5623 /* Always skip content-length header. It will be added
5624 * later with the correct len
5625 */
5626 goto next_hdr;
5627 }
5628
5629 /* Loop on header's values */
5630 lua_pushnil(L);
5631 while (lua_next(L, -2)) {
5632 if (!lua_isstring(L, -1)) {
5633 /* Skip the value if it is not a string */
5634 goto next_value;
5635 }
5636
5637 v = lua_tolstring(L, -1, &vlen);
5638 value = ist2(v, vlen);
5639
5640 if (isteqi(name, ist("transfer-encoding")))
5641 h1_parse_xfer_enc_header(&h1m, value);
5642 if (!htx_add_header(htx, ist2(n, nlen), ist2(v, vlen)))
5643 goto fail;
5644
5645 next_value:
5646 lua_pop(L, 1);
5647 }
5648
5649 next_hdr:
5650 lua_pop(L, 1);
5651 }
5652 skip_headers:
5653 lua_pop(L, 1);
5654
5655 /* Update h1m flags: CLEN is set if CHNK is not present */
5656 if (!(h1m.flags & H1_MF_CHNK)) {
5657 const char *clen = ultoa(body_len);
5658
5659 h1m.flags |= H1_MF_CLEN;
5660 if (!htx_add_header(htx, ist("content-length"), ist(clen)))
5661 goto fail;
5662 }
5663 if (h1m.flags & (H1_MF_CLEN|H1_MF_CHNK))
5664 h1m.flags |= H1_MF_XFER_LEN;
5665
5666 /* Update HTX start-line flags */
5667 if (h1m.flags & H1_MF_XFER_ENC)
5668 flags |= HTX_SL_F_XFER_ENC;
5669 if (h1m.flags & H1_MF_XFER_LEN) {
5670 flags |= HTX_SL_F_XFER_LEN;
5671 if (h1m.flags & H1_MF_CHNK)
5672 flags |= HTX_SL_F_CHNK;
5673 else if (h1m.flags & H1_MF_CLEN)
5674 flags |= HTX_SL_F_CLEN;
5675 if (h1m.body_len == 0)
5676 flags |= HTX_SL_F_BODYLESS;
5677 }
5678 sl->flags |= flags;
5679
5680
5681 if (!htx_add_endof(htx, HTX_BLK_EOH) ||
5682 (body_len && !htx_add_data_atonce(htx, ist2(body, body_len))) ||
5683 !htx_add_endof(htx, HTX_BLK_EOM))
5684 goto fail;
5685
5686 /* Now, forward the response and terminate the transaction */
5687 s->txn->status = code;
5688 htx_to_buf(htx, &s->res.buf);
5689 if (!http_forward_proxy_resp(s, 1))
5690 goto fail;
5691
5692 return 1;
5693
5694 fail:
5695 channel_htx_truncate(&s->res, htx);
5696 return 0;
5697}
5698
5699/* Terminate a transaction if called from a lua action. For TCP streams,
5700 * processing is just aborted. Nothing is returned to the client and all
5701 * arguments are ignored. For HTTP streams, if a reply is passed as argument, it
5702 * is forwarded to the client before terminating the transaction. On success,
5703 * the function exits with ACT_RET_DONE code. If an error occurred, it exits
5704 * with ACT_RET_ERR code. If this function is not called from a lua action, it
5705 * just exits without any processing.
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005706 */
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02005707__LJMP static int hlua_txn_done(lua_State *L)
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005708{
Willy Tarreaub2ccb562015-04-06 11:11:15 +02005709 struct hlua_txn *htxn;
Christopher Faulet700d9e82020-01-31 12:21:52 +01005710 struct stream *s;
5711 int finst;
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005712
Willy Tarreaub2ccb562015-04-06 11:11:15 +02005713 htxn = MAY_LJMP(hlua_checktxn(L, 1));
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005714
Christopher Faulet700d9e82020-01-31 12:21:52 +01005715 /* If the flags NOTERM is set, we cannot terminate the session, so we
5716 * just end the execution of the current lua code. */
5717 if (htxn->flags & HLUA_TXN_NOTERM)
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005718 WILL_LJMP(hlua_done(L));
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005719
Christopher Faulet700d9e82020-01-31 12:21:52 +01005720 s = htxn->s;
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005721 if (!IS_HTX_STRM(htxn->s)) {
Christopher Faulet700d9e82020-01-31 12:21:52 +01005722 struct channel *req = &s->req;
5723 struct channel *res = &s->res;
Willy Tarreau81389672015-03-10 12:03:52 +01005724
Christopher Faulet700d9e82020-01-31 12:21:52 +01005725 channel_auto_read(req);
5726 channel_abort(req);
5727 channel_auto_close(req);
5728 channel_erase(req);
5729
5730 res->wex = tick_add_ifset(now_ms, res->wto);
5731 channel_auto_read(res);
5732 channel_auto_close(res);
5733 channel_shutr_now(res);
5734
5735 finst = ((htxn->dir == SMP_OPT_DIR_REQ) ? SF_FINST_R : SF_FINST_D);
5736 goto done;
Christopher Fauletfe6a71b2019-07-26 16:40:24 +02005737 }
Thierry FOURNIER10ec2142015-08-24 17:23:45 +02005738
Christopher Faulet700d9e82020-01-31 12:21:52 +01005739 if (lua_gettop(L) == 1 || !lua_istable(L, 2)) {
5740 /* No reply or invalid reply */
5741 s->txn->status = 0;
5742 http_reply_and_close(s, 0, NULL);
5743 }
5744 else {
5745 /* Remove extra args to have the reply on top of the stack */
5746 if (lua_gettop(L) > 2)
5747 lua_pop(L, lua_gettop(L) - 2);
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005748
Christopher Faulet700d9e82020-01-31 12:21:52 +01005749 if (!hlua_txn_forward_reply(L, s)) {
5750 if (!(s->flags & SF_ERR_MASK))
5751 s->flags |= SF_ERR_PRXCOND;
5752 lua_pushinteger(L, ACT_RET_ERR);
5753 WILL_LJMP(hlua_done(L));
5754 return 0; /* Never reached */
5755 }
Christopher Faulet4d0e2632019-07-16 10:52:40 +02005756 }
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02005757
Christopher Faulet700d9e82020-01-31 12:21:52 +01005758 finst = ((htxn->dir == SMP_OPT_DIR_REQ) ? SF_FINST_R : SF_FINST_H);
5759 if (htxn->dir == SMP_OPT_DIR_REQ) {
5760 /* let's log the request time */
5761 s->logs.tv_request = now;
5762 if (s->sess->fe == s->be) /* report it if the request was intercepted by the frontend */
5763 _HA_ATOMIC_ADD(&s->sess->fe->fe_counters.intercepted_req, 1);
5764 }
Christopher Fauletfe6a71b2019-07-26 16:40:24 +02005765
Christopher Faulet700d9e82020-01-31 12:21:52 +01005766 done:
5767 if (!(s->flags & SF_ERR_MASK))
5768 s->flags |= SF_ERR_LOCAL;
5769 if (!(s->flags & SF_FINST_MASK))
5770 s->flags |= finst;
Christopher Fauletfe6a71b2019-07-26 16:40:24 +02005771
Christopher Faulet4ad73102020-03-05 11:07:31 +01005772 lua_pushinteger(L, ACT_RET_ABRT);
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02005773 WILL_LJMP(hlua_done(L));
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01005774 return 0;
5775}
5776
Christopher Faulet700d9e82020-01-31 12:21:52 +01005777/*
5778 *
5779 *
5780 * Class REPLY
5781 *
5782 *
5783 */
5784
5785/* Pushes the TXN reply onto the top of the stack. If the stask does not have a
5786 * free slots, the function fails and returns 0;
5787 */
5788static int hlua_txn_reply_new(lua_State *L)
5789{
5790 struct hlua_txn *htxn;
5791 const char *reason, *body = NULL;
5792 int ret, status;
5793
5794 htxn = MAY_LJMP(hlua_checktxn(L, 1));
Christopher Fauletd8f0e072020-02-25 09:45:51 +01005795 if (!IS_HTX_STRM(htxn->s)) {
Christopher Faulet700d9e82020-01-31 12:21:52 +01005796 hlua_pusherror(L, "txn object is not an HTTP transaction.");
5797 WILL_LJMP(lua_error(L));
5798 }
5799
5800 /* Default value */
5801 status = 200;
5802 reason = http_get_reason(status);
5803
5804 if (lua_istable(L, 2)) {
5805 /* load status and reason from the table argument at index 2 */
5806 ret = lua_getfield(L, 2, "status");
5807 if (ret == LUA_TNIL)
5808 goto reason;
5809 else if (ret != LUA_TNUMBER) {
5810 /* invalid status: ignore the reason */
5811 goto body;
5812 }
5813 status = lua_tointeger(L, -1);
5814
5815 reason:
5816 lua_pop(L, 1); /* restore the stack: remove status */
5817 ret = lua_getfield(L, 2, "reason");
5818 if (ret == LUA_TSTRING)
5819 reason = lua_tostring(L, -1);
5820
5821 body:
5822 lua_pop(L, 1); /* restore the stack: remove invalid status or reason */
5823 ret = lua_getfield(L, 2, "body");
5824 if (ret == LUA_TSTRING)
5825 body = lua_tostring(L, -1);
5826 lua_pop(L, 1); /* restore the stack: remove body */
5827 }
5828
5829 /* Create the Reply table */
5830 lua_newtable(L);
5831
5832 /* Add status element */
5833 lua_pushstring(L, "status");
5834 lua_pushinteger(L, status);
5835 lua_settable(L, -3);
5836
5837 /* Add reason element */
5838 reason = http_get_reason(status);
5839 lua_pushstring(L, "reason");
5840 lua_pushstring(L, reason);
5841 lua_settable(L, -3);
5842
5843 /* Add body element, nil if undefined */
5844 lua_pushstring(L, "body");
5845 if (body)
5846 lua_pushstring(L, body);
5847 else
5848 lua_pushnil(L);
5849 lua_settable(L, -3);
5850
5851 /* Add headers element */
5852 lua_pushstring(L, "headers");
5853 lua_newtable(L);
5854
5855 /* stack: [ txn, <Arg:table>, <Reply:table>, "headers", <headers:table> ] */
5856 if (lua_istable(L, 2)) {
5857 /* load headers from the table argument at index 2. If it is a table, copy it. */
5858 ret = lua_getfield(L, 2, "headers");
5859 if (ret == LUA_TTABLE) {
5860 /* stack: [ ... <headers:table>, <table> ] */
5861 lua_pushnil(L);
5862 while (lua_next(L, -2) != 0) {
5863 /* stack: [ ... <headers:table>, <table>, k, v] */
5864 if (!lua_isstring(L, -1) && !lua_istable(L, -1)) {
5865 /* invalid value type, skip it */
5866 lua_pop(L, 1);
5867 continue;
5868 }
5869
5870
5871 /* Duplicate the key and swap it with the value. */
5872 lua_pushvalue(L, -2);
5873 lua_insert(L, -2);
5874 /* stack: [ ... <headers:table>, <table>, k, k, v ] */
5875
5876 lua_newtable(L);
5877 lua_insert(L, -2);
5878 /* stack: [ ... <headers:table>, <table>, k, k, <inner:table>, v ] */
5879
5880 if (lua_isstring(L, -1)) {
5881 /* push the value in the inner table */
5882 lua_rawseti(L, -2, 1);
5883 }
5884 else { /* table */
5885 lua_pushnil(L);
5886 while (lua_next(L, -2) != 0) {
5887 /* stack: [ ... <headers:table>, <table>, k, k, <inner:table>, <v:table>, k2, v2 ] */
5888 if (!lua_isstring(L, -1)) {
5889 /* invalid value type, skip it*/
5890 lua_pop(L, 1);
5891 continue;
5892 }
5893 /* push the value in the inner table */
5894 lua_rawseti(L, -4, lua_rawlen(L, -4) + 1);
5895 /* stack: [ ... <headers:table>, <table>, k, k, <inner:table>, <v:table>, k2 ] */
5896 }
5897 lua_pop(L, 1);
5898 /* stack: [ ... <headers:table>, <table>, k, k, <inner:table> ] */
5899 }
5900
5901 /* push (k,v) on the stack in the headers table:
5902 * stack: [ ... <headers:table>, <table>, k, k, v ]
5903 */
5904 lua_settable(L, -5);
5905 /* stack: [ ... <headers:table>, <table>, k ] */
5906 }
5907 }
5908 lua_pop(L, 1);
5909 }
5910 /* stack: [ txn, <Arg:table>, <Reply:table>, "headers", <headers:table> ] */
5911 lua_settable(L, -3);
5912 /* stack: [ txn, <Arg:table>, <Reply:table> ] */
5913
5914 /* Pop a class sesison metatable and affect it to the userdata. */
5915 lua_rawgeti(L, LUA_REGISTRYINDEX, class_txn_reply_ref);
5916 lua_setmetatable(L, -2);
5917 return 1;
5918}
5919
5920/* Set the reply status code, and optionally the reason. If no reason is
5921 * provided, the default one corresponding to the status code is used.
5922 */
5923__LJMP static int hlua_txn_reply_set_status(lua_State *L)
5924{
5925 int status = MAY_LJMP(luaL_checkinteger(L, 2));
5926 const char *reason = MAY_LJMP(luaL_optlstring(L, 3, NULL, NULL));
5927
5928 /* First argument (self) must be a table */
5929 luaL_checktype(L, 1, LUA_TTABLE);
5930
5931 if (status < 100 || status > 599) {
5932 lua_pushboolean(L, 0);
5933 return 1;
5934 }
5935 if (!reason)
5936 reason = http_get_reason(status);
5937
5938 lua_pushinteger(L, status);
5939 lua_setfield(L, 1, "status");
5940
5941 lua_pushstring(L, reason);
5942 lua_setfield(L, 1, "reason");
5943
5944 lua_pushboolean(L, 1);
5945 return 1;
5946}
5947
5948/* Add a header into the reply object. Each header name is associated to an
5949 * array of values in the "headers" table. If the header name is not found, a
5950 * new entry is created.
5951 */
5952__LJMP static int hlua_txn_reply_add_header(lua_State *L)
5953{
5954 const char *name = MAY_LJMP(luaL_checkstring(L, 2));
5955 const char *value = MAY_LJMP(luaL_checkstring(L, 3));
5956 int ret;
5957
5958 /* First argument (self) must be a table */
5959 luaL_checktype(L, 1, LUA_TTABLE);
5960
5961 /* Push in the stack the "headers" entry. */
5962 ret = lua_getfield(L, 1, "headers");
5963 if (ret != LUA_TTABLE) {
5964 hlua_pusherror(L, "Reply['headers'] is expected to a an array. %s found", lua_typename(L, ret));
5965 WILL_LJMP(lua_error(L));
5966 }
5967
5968 /* check if the header is already registered. If not, register it. */
5969 ret = lua_getfield(L, -1, name);
5970 if (ret == LUA_TNIL) {
5971 /* Entry not found. */
5972 lua_pop(L, 1); /* remove the nil. The "headers" table is the top of the stack. */
5973
5974 /* Insert the new header name in the array in the top of the stack.
5975 * It left the new array in the top of the stack.
5976 */
5977 lua_newtable(L);
5978 lua_pushstring(L, name);
5979 lua_pushvalue(L, -2);
5980 lua_settable(L, -4);
5981 }
5982 else if (ret != LUA_TTABLE) {
5983 hlua_pusherror(L, "Reply['headers']['%s'] is expected to be an array. %s found", name, lua_typename(L, ret));
5984 WILL_LJMP(lua_error(L));
5985 }
5986
5987 /* Now the top od thestack is an array of values. We push
5988 * the header value as new entry.
5989 */
5990 lua_pushstring(L, value);
5991 ret = lua_rawlen(L, -2);
5992 lua_rawseti(L, -2, ret + 1);
5993
5994 lua_pushboolean(L, 1);
5995 return 1;
5996}
5997
5998/* Remove all occurrences of a given header name. */
5999__LJMP static int hlua_txn_reply_del_header(lua_State *L)
6000{
6001 const char *name = MAY_LJMP(luaL_checkstring(L, 2));
6002 int ret;
6003
6004 /* First argument (self) must be a table */
6005 luaL_checktype(L, 1, LUA_TTABLE);
6006
6007 /* Push in the stack the "headers" entry. */
6008 ret = lua_getfield(L, 1, "headers");
6009 if (ret != LUA_TTABLE) {
6010 hlua_pusherror(L, "Reply['headers'] is expected to be an array. %s found", lua_typename(L, ret));
6011 WILL_LJMP(lua_error(L));
6012 }
6013
6014 lua_pushstring(L, name);
6015 lua_pushnil(L);
6016 lua_settable(L, -3);
6017
6018 lua_pushboolean(L, 1);
6019 return 1;
6020}
6021
6022/* Set the reply's body. Overwrite any existing entry. */
6023__LJMP static int hlua_txn_reply_set_body(lua_State *L)
6024{
6025 const char *payload = MAY_LJMP(luaL_checkstring(L, 2));
6026
6027 /* First argument (self) must be a table */
6028 luaL_checktype(L, 1, LUA_TTABLE);
6029
6030 lua_pushstring(L, payload);
6031 lua_setfield(L, 1, "body");
6032
6033 lua_pushboolean(L, 1);
6034 return 1;
6035}
6036
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01006037__LJMP static int hlua_log(lua_State *L)
6038{
6039 int level;
6040 const char *msg;
6041
6042 MAY_LJMP(check_args(L, 2, "log"));
6043 level = MAY_LJMP(luaL_checkinteger(L, 1));
6044 msg = MAY_LJMP(luaL_checkstring(L, 2));
6045
6046 if (level < 0 || level >= NB_LOG_LEVELS)
6047 WILL_LJMP(luaL_argerror(L, 1, "Invalid loglevel."));
6048
6049 hlua_sendlog(NULL, level, msg);
6050 return 0;
6051}
6052
6053__LJMP static int hlua_log_debug(lua_State *L)
6054{
6055 const char *msg;
6056
6057 MAY_LJMP(check_args(L, 1, "debug"));
6058 msg = MAY_LJMP(luaL_checkstring(L, 1));
6059 hlua_sendlog(NULL, LOG_DEBUG, msg);
6060 return 0;
6061}
6062
6063__LJMP static int hlua_log_info(lua_State *L)
6064{
6065 const char *msg;
6066
6067 MAY_LJMP(check_args(L, 1, "info"));
6068 msg = MAY_LJMP(luaL_checkstring(L, 1));
6069 hlua_sendlog(NULL, LOG_INFO, msg);
6070 return 0;
6071}
6072
6073__LJMP static int hlua_log_warning(lua_State *L)
6074{
6075 const char *msg;
6076
6077 MAY_LJMP(check_args(L, 1, "warning"));
6078 msg = MAY_LJMP(luaL_checkstring(L, 1));
6079 hlua_sendlog(NULL, LOG_WARNING, msg);
6080 return 0;
6081}
6082
6083__LJMP static int hlua_log_alert(lua_State *L)
6084{
6085 const char *msg;
6086
6087 MAY_LJMP(check_args(L, 1, "alert"));
6088 msg = MAY_LJMP(luaL_checkstring(L, 1));
6089 hlua_sendlog(NULL, LOG_ALERT, msg);
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01006090 return 0;
6091}
6092
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01006093__LJMP static int hlua_sleep_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006094{
6095 int wakeup_ms = lua_tointeger(L, -1);
6096 if (now_ms < wakeup_ms)
Willy Tarreau9635e032018-10-16 17:52:55 +02006097 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006098 return 0;
6099}
6100
6101__LJMP static int hlua_sleep(lua_State *L)
6102{
6103 unsigned int delay;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006104 unsigned int wakeup_ms;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006105
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006106 MAY_LJMP(check_args(L, 1, "sleep"));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006107
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01006108 delay = MAY_LJMP(luaL_checkinteger(L, 1)) * 1000;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006109 wakeup_ms = tick_add(now_ms, delay);
6110 lua_pushinteger(L, wakeup_ms);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006111
Willy Tarreau9635e032018-10-16 17:52:55 +02006112 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006113 return 0;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006114}
6115
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006116__LJMP static int hlua_msleep(lua_State *L)
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006117{
6118 unsigned int delay;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006119 unsigned int wakeup_ms;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006120
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006121 MAY_LJMP(check_args(L, 1, "msleep"));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006122
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01006123 delay = MAY_LJMP(luaL_checkinteger(L, 1));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006124 wakeup_ms = tick_add(now_ms, delay);
6125 lua_pushinteger(L, wakeup_ms);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006126
Willy Tarreau9635e032018-10-16 17:52:55 +02006127 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006128 return 0;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006129}
6130
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01006131/* This functionis an LUA binding. it permits to give back
6132 * the hand at the HAProxy scheduler. It is used when the
6133 * LUA processing consumes a lot of time.
6134 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01006135__LJMP static int hlua_yield_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006136{
6137 return 0;
6138}
6139
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01006140__LJMP static int hlua_yield(lua_State *L)
6141{
Willy Tarreau9635e032018-10-16 17:52:55 +02006142 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_yield_yield, TICK_ETERNITY, HLUA_CTRLYIELD));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006143 return 0;
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01006144}
6145
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006146/* This function change the nice of the currently executed
6147 * task. It is used set low or high priority at the current
6148 * task.
6149 */
Willy Tarreau59551662015-03-10 14:23:13 +01006150__LJMP static int hlua_set_nice(lua_State *L)
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006151{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006152 struct hlua *hlua;
6153 int nice;
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006154
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006155 MAY_LJMP(check_args(L, 1, "set_nice"));
6156 hlua = hlua_gethlua(L);
6157 nice = MAY_LJMP(luaL_checkinteger(L, 1));
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006158
6159 /* If he task is not set, I'm in a start mode. */
6160 if (!hlua || !hlua->task)
6161 return 0;
6162
6163 if (nice < -1024)
6164 nice = -1024;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006165 else if (nice > 1024)
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006166 nice = 1024;
6167
6168 hlua->task->nice = nice;
6169 return 0;
6170}
6171
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08006172/* This function is used as a callback of a task. It is called by the
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006173 * HAProxy task subsystem when the task is awaked. The LUA runtime can
6174 * return an E_AGAIN signal, the emmiter of this signal must set a
6175 * signal to wake the task.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006176 *
6177 * Task wrapper are longjmp safe because the only one Lua code
6178 * executed is the safe hlua_ctx_resume();
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006179 */
Willy Tarreau60409db2019-08-21 14:14:50 +02006180struct task *hlua_process_task(struct task *task, void *context, unsigned short state)
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006181{
Olivier Houchard9f6af332018-05-25 14:04:04 +02006182 struct hlua *hlua = context;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006183 enum hlua_exec status;
6184
Christopher Faulet5bc99722018-04-25 10:34:45 +02006185 if (task->thread_mask == MAX_THREADS_MASK)
6186 task_set_affinity(task, tid_bit);
6187
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006188 /* If it is the first call to the task, we must initialize the
6189 * execution timeouts.
6190 */
6191 if (!HLUA_IS_RUNNING(hlua))
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02006192 hlua->max_time = hlua_timeout_task;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006193
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006194 /* Execute the Lua code. */
6195 status = hlua_ctx_resume(hlua, 1);
6196
6197 switch (status) {
6198 /* finished or yield */
6199 case HLUA_E_OK:
6200 hlua_ctx_destroy(hlua);
Olivier Houchard3f795f72019-04-17 22:51:06 +02006201 task_destroy(task);
Tim Duesterhuscd235c62018-04-24 13:56:01 +02006202 task = NULL;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006203 break;
6204
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01006205 case HLUA_E_AGAIN: /* co process or timeout wake me later. */
Thierry FOURNIERcb146882017-12-10 17:10:57 +01006206 notification_gc(&hlua->com);
PiBa-NLfe971b32018-05-02 22:27:14 +02006207 task->expire = hlua->wake_time;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006208 break;
6209
6210 /* finished with error. */
6211 case HLUA_E_ERRMSG:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006212 SEND_ERR(NULL, "Lua task: %s.\n", lua_tostring(hlua->T, -1));
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006213 hlua_ctx_destroy(hlua);
Olivier Houchard3f795f72019-04-17 22:51:06 +02006214 task_destroy(task);
Emeric Brun253e53e2017-10-17 18:58:40 +02006215 task = NULL;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006216 break;
6217
6218 case HLUA_E_ERR:
6219 default:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006220 SEND_ERR(NULL, "Lua task: unknown error.\n");
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006221 hlua_ctx_destroy(hlua);
Olivier Houchard3f795f72019-04-17 22:51:06 +02006222 task_destroy(task);
Emeric Brun253e53e2017-10-17 18:58:40 +02006223 task = NULL;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006224 break;
6225 }
Emeric Brun253e53e2017-10-17 18:58:40 +02006226 return task;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006227}
6228
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006229/* This function is an LUA binding that register LUA function to be
6230 * executed after the HAProxy configuration parsing and before the
6231 * HAProxy scheduler starts. This function expect only one LUA
6232 * argument that is a function. This function returns nothing, but
6233 * throws if an error is encountered.
6234 */
6235__LJMP static int hlua_register_init(lua_State *L)
6236{
6237 struct hlua_init_function *init;
6238 int ref;
6239
6240 MAY_LJMP(check_args(L, 1, "register_init"));
6241
6242 ref = MAY_LJMP(hlua_checkfunction(L, 1));
6243
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006244 init = calloc(1, sizeof(*init));
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006245 if (!init)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006246 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006247
6248 init->function_ref = ref;
6249 LIST_ADDQ(&hlua_init_functions, &init->l);
6250 return 0;
6251}
6252
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006253/* This functio is an LUA binding. It permits to register a task
6254 * executed in parallel of the main HAroxy activity. The task is
6255 * created and it is set in the HAProxy scheduler. It can be called
6256 * from the "init" section, "post init" or during the runtime.
6257 *
6258 * Lua prototype:
6259 *
6260 * <none> core.register_task(<function>)
6261 */
6262static int hlua_register_task(lua_State *L)
6263{
6264 struct hlua *hlua;
6265 struct task *task;
6266 int ref;
6267
6268 MAY_LJMP(check_args(L, 1, "register_task"));
6269
6270 ref = MAY_LJMP(hlua_checkfunction(L, 1));
6271
Willy Tarreaubafbe012017-11-24 17:34:44 +01006272 hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006273 if (!hlua)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006274 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006275
Emeric Brunc60def82017-09-27 14:59:38 +02006276 task = task_new(MAX_THREADS_MASK);
Willy Tarreaue09101e2018-10-16 17:37:12 +02006277 if (!task)
6278 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
6279
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006280 task->context = hlua;
6281 task->process = hlua_process_task;
6282
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01006283 if (!hlua_ctx_init(hlua, task, 1))
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006284 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006285
6286 /* Restore the function in the stack. */
6287 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ref);
6288 hlua->nargs = 0;
6289
6290 /* Schedule task. */
6291 task_schedule(task, now_ms);
6292
6293 return 0;
6294}
6295
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006296/* Wrapper called by HAProxy to execute an LUA converter. This wrapper
6297 * doesn't allow "yield" functions because the HAProxy engine cannot
6298 * resume converters.
6299 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006300static int hlua_sample_conv_wrapper(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006301{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02006302 struct hlua_function *fcn = private;
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006303 struct stream *stream = smp->strm;
Thierry Fournierfd107a22016-02-19 19:57:23 +01006304 const char *error;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006305
Willy Tarreaube508f12016-03-10 11:47:01 +01006306 if (!stream)
6307 return 0;
6308
Willy Tarreau87b09662015-04-03 00:22:06 +02006309 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006310 * Lua context can be not initialized. This behavior
6311 * permits to save performances because a systematic
6312 * Lua initialization cause 5% performances loss.
6313 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006314 if (!stream->hlua) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01006315 stream->hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006316 if (!stream->hlua) {
6317 SEND_ERR(stream->be, "Lua converter '%s': can't initialize Lua context.\n", fcn->name);
6318 return 0;
6319 }
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01006320 if (!hlua_ctx_init(stream->hlua, stream->task, 0)) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006321 SEND_ERR(stream->be, "Lua converter '%s': can't initialize Lua context.\n", fcn->name);
6322 return 0;
6323 }
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006324 }
6325
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006326 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006327 if (!HLUA_IS_RUNNING(stream->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006328
6329 /* The following Lua calls can fail. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006330 if (!SET_SAFE_LJMP(stream->hlua->T)) {
6331 if (lua_type(stream->hlua->T, -1) == LUA_TSTRING)
6332 error = lua_tostring(stream->hlua->T, -1);
Thierry Fournierfd107a22016-02-19 19:57:23 +01006333 else
6334 error = "critical error";
6335 SEND_ERR(stream->be, "Lua converter '%s': %s.\n", fcn->name, error);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006336 return 0;
6337 }
6338
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006339 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006340 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006341 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006342 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006343 return 0;
6344 }
6345
6346 /* Restore the function in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006347 lua_rawgeti(stream->hlua->T, LUA_REGISTRYINDEX, fcn->function_ref);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006348
6349 /* convert input sample and pust-it in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006350 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006351 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006352 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006353 return 0;
6354 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006355 hlua_smp2lua(stream->hlua->T, smp);
6356 stream->hlua->nargs = 1;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006357
6358 /* push keywords in the stack. */
6359 if (arg_p) {
6360 for (; arg_p->type != ARGT_STOP; arg_p++) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006361 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006362 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006363 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006364 return 0;
6365 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006366 hlua_arg2lua(stream->hlua->T, arg_p);
6367 stream->hlua->nargs++;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006368 }
6369 }
6370
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006371 /* We must initialize the execution timeouts. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006372 stream->hlua->max_time = hlua_timeout_session;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006373
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006374 /* At this point the execution is safe. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006375 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006376 }
6377
6378 /* Execute the function. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006379 switch (hlua_ctx_resume(stream->hlua, 0)) {
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006380 /* finished. */
6381 case HLUA_E_OK:
Thierry FOURNIERfd80df12017-05-12 16:32:20 +02006382 /* If the stack is empty, the function fails. */
6383 if (lua_gettop(stream->hlua->T) <= 0)
6384 return 0;
6385
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006386 /* Convert the returned value in sample. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006387 hlua_lua2smp(stream->hlua->T, -1, smp);
6388 lua_pop(stream->hlua->T, 1);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006389 return 1;
6390
6391 /* yield. */
6392 case HLUA_E_AGAIN:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006393 SEND_ERR(stream->be, "Lua converter '%s': cannot use yielded functions.\n", fcn->name);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006394 return 0;
6395
6396 /* finished with error. */
6397 case HLUA_E_ERRMSG:
6398 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006399 SEND_ERR(stream->be, "Lua converter '%s': %s.\n",
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006400 fcn->name, lua_tostring(stream->hlua->T, -1));
6401 lua_pop(stream->hlua->T, 1);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006402 return 0;
6403
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006404 case HLUA_E_ETMOUT:
6405 SEND_ERR(stream->be, "Lua converter '%s': execution timeout.\n", fcn->name);
6406 return 0;
6407
6408 case HLUA_E_NOMEM:
6409 SEND_ERR(stream->be, "Lua converter '%s': out of memory error.\n", fcn->name);
6410 return 0;
6411
6412 case HLUA_E_YIELD:
6413 SEND_ERR(stream->be, "Lua converter '%s': yield functions like core.tcp() or core.sleep() are not allowed.\n", fcn->name);
6414 return 0;
6415
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006416 case HLUA_E_ERR:
6417 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006418 SEND_ERR(stream->be, "Lua converter '%s' returns an unknown error.\n", fcn->name);
Tim Duesterhus588b3142020-05-29 14:35:51 +02006419 /* fall through */
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006420
6421 default:
6422 return 0;
6423 }
6424}
6425
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006426/* Wrapper called by HAProxy to execute a sample-fetch. this wrapper
6427 * doesn't allow "yield" functions because the HAProxy engine cannot
Willy Tarreaube508f12016-03-10 11:47:01 +01006428 * resume sample-fetches. This function will be called by the sample
6429 * fetch engine to call lua-based fetch operations.
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006430 */
Thierry FOURNIER0786d052015-05-11 15:42:45 +02006431static int hlua_sample_fetch_wrapper(const struct arg *arg_p, struct sample *smp,
6432 const char *kw, void *private)
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006433{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02006434 struct hlua_function *fcn = private;
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006435 struct stream *stream = smp->strm;
Thierry Fournierfd107a22016-02-19 19:57:23 +01006436 const char *error;
Christopher Fauletbfab2dd2019-07-26 15:09:53 +02006437 unsigned int hflags = HLUA_TXN_NOTERM;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006438
Willy Tarreaube508f12016-03-10 11:47:01 +01006439 if (!stream)
6440 return 0;
Christopher Fauletafd8f102018-11-08 11:34:21 +01006441
Willy Tarreau87b09662015-04-03 00:22:06 +02006442 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006443 * Lua context can be not initialized. This behavior
6444 * permits to save performances because a systematic
6445 * Lua initialization cause 5% performances loss.
6446 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006447 if (!stream->hlua) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01006448 stream->hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006449 if (!stream->hlua) {
6450 SEND_ERR(stream->be, "Lua sample-fetch '%s': can't initialize Lua context.\n", fcn->name);
6451 return 0;
6452 }
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01006453 if (!hlua_ctx_init(stream->hlua, stream->task, 0)) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006454 SEND_ERR(stream->be, "Lua sample-fetch '%s': can't initialize Lua context.\n", fcn->name);
6455 return 0;
6456 }
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006457 }
6458
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006459 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006460 if (!HLUA_IS_RUNNING(stream->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006461
6462 /* The following Lua calls can fail. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006463 if (!SET_SAFE_LJMP(stream->hlua->T)) {
6464 if (lua_type(stream->hlua->T, -1) == LUA_TSTRING)
6465 error = lua_tostring(stream->hlua->T, -1);
Thierry Fournierfd107a22016-02-19 19:57:23 +01006466 else
6467 error = "critical error";
6468 SEND_ERR(smp->px, "Lua sample-fetch '%s': %s.\n", fcn->name, error);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006469 return 0;
6470 }
6471
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006472 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006473 if (!lua_checkstack(stream->hlua->T, 2)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006474 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006475 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006476 return 0;
6477 }
6478
6479 /* Restore the function in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006480 lua_rawgeti(stream->hlua->T, LUA_REGISTRYINDEX, fcn->function_ref);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006481
6482 /* push arguments in the stack. */
Christopher Fauletbfab2dd2019-07-26 15:09:53 +02006483 if (!hlua_txn_new(stream->hlua->T, stream, smp->px, smp->opt & SMP_OPT_DIR, hflags)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006484 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006485 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006486 return 0;
6487 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006488 stream->hlua->nargs = 1;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006489
6490 /* push keywords in the stack. */
6491 for (; arg_p && arg_p->type != ARGT_STOP; arg_p++) {
6492 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006493 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006494 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006495 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006496 return 0;
6497 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006498 hlua_arg2lua(stream->hlua->T, arg_p);
6499 stream->hlua->nargs++;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006500 }
6501
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006502 /* We must initialize the execution timeouts. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006503 stream->hlua->max_time = hlua_timeout_session;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006504
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006505 /* At this point the execution is safe. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006506 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006507 }
6508
6509 /* Execute the function. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006510 switch (hlua_ctx_resume(stream->hlua, 0)) {
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006511 /* finished. */
6512 case HLUA_E_OK:
Thierry FOURNIERfd80df12017-05-12 16:32:20 +02006513 /* If the stack is empty, the function fails. */
6514 if (lua_gettop(stream->hlua->T) <= 0)
6515 return 0;
6516
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006517 /* Convert the returned value in sample. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006518 hlua_lua2smp(stream->hlua->T, -1, smp);
6519 lua_pop(stream->hlua->T, 1);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006520
6521 /* Set the end of execution flag. */
6522 smp->flags &= ~SMP_F_MAY_CHANGE;
6523 return 1;
6524
6525 /* yield. */
6526 case HLUA_E_AGAIN:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006527 SEND_ERR(smp->px, "Lua sample-fetch '%s': cannot use yielded functions.\n", fcn->name);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006528 return 0;
6529
6530 /* finished with error. */
6531 case HLUA_E_ERRMSG:
6532 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006533 SEND_ERR(smp->px, "Lua sample-fetch '%s': %s.\n",
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006534 fcn->name, lua_tostring(stream->hlua->T, -1));
6535 lua_pop(stream->hlua->T, 1);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006536 return 0;
6537
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006538 case HLUA_E_ETMOUT:
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006539 SEND_ERR(smp->px, "Lua sample-fetch '%s': execution timeout.\n", fcn->name);
6540 return 0;
6541
6542 case HLUA_E_NOMEM:
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006543 SEND_ERR(smp->px, "Lua sample-fetch '%s': out of memory error.\n", fcn->name);
6544 return 0;
6545
6546 case HLUA_E_YIELD:
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006547 SEND_ERR(smp->px, "Lua sample-fetch '%s': yield not allowed.\n", fcn->name);
6548 return 0;
6549
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006550 case HLUA_E_ERR:
6551 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006552 SEND_ERR(smp->px, "Lua sample-fetch '%s' returns an unknown error.\n", fcn->name);
Tim Duesterhus588b3142020-05-29 14:35:51 +02006553 /* fall through */
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006554
6555 default:
6556 return 0;
6557 }
6558}
6559
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006560/* This function is an LUA binding used for registering
6561 * "sample-conv" functions. It expects a converter name used
6562 * in the haproxy configuration file, and an LUA function.
6563 */
6564__LJMP static int hlua_register_converters(lua_State *L)
6565{
6566 struct sample_conv_kw_list *sck;
6567 const char *name;
6568 int ref;
6569 int len;
6570 struct hlua_function *fcn;
6571
6572 MAY_LJMP(check_args(L, 2, "register_converters"));
6573
6574 /* First argument : converter name. */
6575 name = MAY_LJMP(luaL_checkstring(L, 1));
6576
6577 /* Second argument : lua function. */
6578 ref = MAY_LJMP(hlua_checkfunction(L, 2));
6579
6580 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006581 sck = calloc(1, sizeof(*sck) + sizeof(struct sample_conv) * 2);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006582 if (!sck)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006583 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006584 fcn = calloc(1, sizeof(*fcn));
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006585 if (!fcn)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006586 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006587
6588 /* Fill fcn. */
6589 fcn->name = strdup(name);
6590 if (!fcn->name)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006591 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006592 fcn->function_ref = ref;
6593
6594 /* List head */
6595 sck->list.n = sck->list.p = NULL;
6596
6597 /* converter keyword. */
6598 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006599 sck->kw[0].kw = calloc(1, len);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006600 if (!sck->kw[0].kw)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006601 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006602
6603 snprintf((char *)sck->kw[0].kw, len, "lua.%s", name);
6604 sck->kw[0].process = hlua_sample_conv_wrapper;
David Carlier0c437f42016-04-27 16:21:56 +01006605 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 +01006606 sck->kw[0].val_args = NULL;
6607 sck->kw[0].in_type = SMP_T_STR;
6608 sck->kw[0].out_type = SMP_T_STR;
6609 sck->kw[0].private = fcn;
6610
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006611 /* Register this new converter */
6612 sample_register_convs(sck);
6613
6614 return 0;
6615}
6616
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08006617/* This function is an LUA binding used for registering
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006618 * "sample-fetch" functions. It expects a converter name used
6619 * in the haproxy configuration file, and an LUA function.
6620 */
6621__LJMP static int hlua_register_fetches(lua_State *L)
6622{
6623 const char *name;
6624 int ref;
6625 int len;
6626 struct sample_fetch_kw_list *sfk;
6627 struct hlua_function *fcn;
6628
6629 MAY_LJMP(check_args(L, 2, "register_fetches"));
6630
6631 /* First argument : sample-fetch name. */
6632 name = MAY_LJMP(luaL_checkstring(L, 1));
6633
6634 /* Second argument : lua function. */
6635 ref = MAY_LJMP(hlua_checkfunction(L, 2));
6636
6637 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006638 sfk = calloc(1, sizeof(*sfk) + sizeof(struct sample_fetch) * 2);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006639 if (!sfk)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006640 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006641 fcn = calloc(1, sizeof(*fcn));
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006642 if (!fcn)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006643 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006644
6645 /* Fill fcn. */
6646 fcn->name = strdup(name);
6647 if (!fcn->name)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006648 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006649 fcn->function_ref = ref;
6650
6651 /* List head */
6652 sfk->list.n = sfk->list.p = NULL;
6653
6654 /* sample-fetch keyword. */
6655 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006656 sfk->kw[0].kw = calloc(1, len);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006657 if (!sfk->kw[0].kw)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006658 return luaL_error(L, "Lua out of memory error.");
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006659
6660 snprintf((char *)sfk->kw[0].kw, len, "lua.%s", name);
6661 sfk->kw[0].process = hlua_sample_fetch_wrapper;
David Carlier0c437f42016-04-27 16:21:56 +01006662 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 +01006663 sfk->kw[0].val_args = NULL;
6664 sfk->kw[0].out_type = SMP_T_STR;
6665 sfk->kw[0].use = SMP_USE_HTTP_ANY;
6666 sfk->kw[0].val = 0;
6667 sfk->kw[0].private = fcn;
6668
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006669 /* Register this new fetch. */
6670 sample_register_fetches(sfk);
6671
6672 return 0;
6673}
6674
Christopher Faulet501465d2020-02-26 14:54:16 +01006675/* This function is a lua binding to set the wake_time.
Christopher Faulet2c2c2e32020-01-31 19:07:52 +01006676 */
Christopher Faulet501465d2020-02-26 14:54:16 +01006677__LJMP static int hlua_set_wake_time(lua_State *L)
Christopher Faulet2c2c2e32020-01-31 19:07:52 +01006678{
6679 struct hlua *hlua = hlua_gethlua(L);
6680 unsigned int delay;
6681 unsigned int wakeup_ms;
6682
6683 MAY_LJMP(check_args(L, 1, "wake_time"));
6684
6685 delay = MAY_LJMP(luaL_checkinteger(L, 1));
6686 wakeup_ms = tick_add(now_ms, delay);
6687 hlua->wake_time = wakeup_ms;
6688 return 0;
6689}
6690
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006691/* This function is a wrapper to execute each LUA function declared as an action
6692 * wrapper during the initialisation period. This function may return any
6693 * ACT_RET_* value. On error ACT_RET_CONT is returned and the action is
6694 * ignored. If the lua action yields, ACT_RET_YIELD is returned. On success, the
6695 * return value is the first element on the stack.
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006696 */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006697static enum act_return hlua_action(struct act_rule *rule, struct proxy *px,
Willy Tarreau658b85b2015-09-27 10:00:49 +02006698 struct session *sess, struct stream *s, int flags)
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006699{
6700 char **arg;
Christopher Fauletbfab2dd2019-07-26 15:09:53 +02006701 unsigned int hflags = 0;
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006702 int dir, act_ret = ACT_RET_CONT;
Thierry Fournierfd107a22016-02-19 19:57:23 +01006703 const char *error;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006704
6705 switch (rule->from) {
Christopher Fauletd8f0e072020-02-25 09:45:51 +01006706 case ACT_F_TCP_REQ_CNT: dir = SMP_OPT_DIR_REQ; break;
6707 case ACT_F_TCP_RES_CNT: dir = SMP_OPT_DIR_RES; break;
6708 case ACT_F_HTTP_REQ: dir = SMP_OPT_DIR_REQ; break;
6709 case ACT_F_HTTP_RES: dir = SMP_OPT_DIR_RES; break;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006710 default:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006711 SEND_ERR(px, "Lua: internal error while execute action.\n");
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006712 goto end;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006713 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006714
Willy Tarreau87b09662015-04-03 00:22:06 +02006715 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006716 * Lua context can be not initialized. This behavior
6717 * permits to save performances because a systematic
6718 * Lua initialization cause 5% performances loss.
6719 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006720 if (!s->hlua) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01006721 s->hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006722 if (!s->hlua) {
6723 SEND_ERR(px, "Lua action '%s': can't initialize Lua context.\n",
6724 rule->arg.hlua_rule->fcn.name);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006725 goto end;
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006726 }
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01006727 if (!hlua_ctx_init(s->hlua, s->task, 0)) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006728 SEND_ERR(px, "Lua action '%s': can't initialize Lua context.\n",
6729 rule->arg.hlua_rule->fcn.name);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006730 goto end;
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006731 }
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006732 }
6733
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006734 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006735 if (!HLUA_IS_RUNNING(s->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006736
6737 /* The following Lua calls can fail. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006738 if (!SET_SAFE_LJMP(s->hlua->T)) {
6739 if (lua_type(s->hlua->T, -1) == LUA_TSTRING)
6740 error = lua_tostring(s->hlua->T, -1);
Thierry Fournierfd107a22016-02-19 19:57:23 +01006741 else
6742 error = "critical error";
6743 SEND_ERR(px, "Lua function '%s': %s.\n",
6744 rule->arg.hlua_rule->fcn.name, error);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006745 goto end;
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006746 }
6747
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006748 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006749 if (!lua_checkstack(s->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006750 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006751 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006752 RESET_SAFE_LJMP(s->hlua->T);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006753 goto end;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006754 }
6755
6756 /* Restore the function in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006757 lua_rawgeti(s->hlua->T, LUA_REGISTRYINDEX, rule->arg.hlua_rule->fcn.function_ref);
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006758
Willy Tarreau87b09662015-04-03 00:22:06 +02006759 /* Create and and push object stream in the stack. */
Christopher Fauletbfab2dd2019-07-26 15:09:53 +02006760 if (!hlua_txn_new(s->hlua->T, s, px, dir, hflags)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006761 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006762 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006763 RESET_SAFE_LJMP(s->hlua->T);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006764 goto end;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006765 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006766 s->hlua->nargs = 1;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006767
6768 /* push keywords in the stack. */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006769 for (arg = rule->arg.hlua_rule->args; arg && *arg; arg++) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006770 if (!lua_checkstack(s->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006771 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006772 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006773 RESET_SAFE_LJMP(s->hlua->T);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006774 goto end;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006775 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006776 lua_pushstring(s->hlua->T, *arg);
6777 s->hlua->nargs++;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006778 }
6779
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006780 /* Now the execution is safe. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006781 RESET_SAFE_LJMP(s->hlua->T);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006782
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006783 /* We must initialize the execution timeouts. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006784 s->hlua->max_time = hlua_timeout_session;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006785 }
6786
6787 /* Execute the function. */
Christopher Faulet105ba6c2019-12-18 14:41:51 +01006788 switch (hlua_ctx_resume(s->hlua, !(flags & ACT_OPT_FINAL))) {
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006789 /* finished. */
6790 case HLUA_E_OK:
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006791 /* Catch the return value */
6792 if (lua_gettop(s->hlua->T) > 0)
6793 act_ret = lua_tointeger(s->hlua->T, -1);
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006794
Christopher Faulet2c2c2e32020-01-31 19:07:52 +01006795 /* Set timeout in the required channel. */
Christopher Faulet498c4832020-07-28 11:59:58 +02006796 if (act_ret == ACT_RET_YIELD) {
6797 if (flags & ACT_OPT_FINAL)
6798 goto err_yield;
6799
Christopher Faulet8f587ea2020-07-28 12:01:55 +02006800 if (dir == SMP_OPT_DIR_REQ)
6801 s->req.analyse_exp = tick_first((tick_is_expired(s->req.analyse_exp, now_ms) ? 0 : s->req.analyse_exp),
6802 s->hlua->wake_time);
6803 else
6804 s->res.analyse_exp = tick_first((tick_is_expired(s->res.analyse_exp, now_ms) ? 0 : s->res.analyse_exp),
6805 s->hlua->wake_time);
Christopher Faulet2c2c2e32020-01-31 19:07:52 +01006806 }
6807 goto end;
6808
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006809 /* yield. */
6810 case HLUA_E_AGAIN:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01006811 /* Set timeout in the required channel. */
Christopher Faulet8f587ea2020-07-28 12:01:55 +02006812 if (dir == SMP_OPT_DIR_REQ)
6813 s->req.analyse_exp = tick_first((tick_is_expired(s->req.analyse_exp, now_ms) ? 0 : s->req.analyse_exp),
6814 s->hlua->wake_time);
6815 else
6816 s->res.analyse_exp = tick_first((tick_is_expired(s->res.analyse_exp, now_ms) ? 0 : s->res.analyse_exp),
6817 s->hlua->wake_time);
6818
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006819 /* Some actions can be wake up when a "write" event
6820 * is detected on a response channel. This is useful
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08006821 * only for actions targeted on the requests.
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006822 */
Christopher Faulet51fa3582019-07-26 14:54:52 +02006823 if (HLUA_IS_WAKERESWR(s->hlua))
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01006824 s->res.flags |= CF_WAKE_WRITE;
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006825 if (HLUA_IS_WAKEREQWR(s->hlua))
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01006826 s->req.flags |= CF_WAKE_WRITE;
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006827 act_ret = ACT_RET_YIELD;
6828 goto end;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006829
6830 /* finished with error. */
6831 case HLUA_E_ERRMSG:
6832 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006833 SEND_ERR(px, "Lua function '%s': %s.\n",
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006834 rule->arg.hlua_rule->fcn.name, lua_tostring(s->hlua->T, -1));
6835 lua_pop(s->hlua->T, 1);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006836 goto end;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006837
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006838 case HLUA_E_ETMOUT:
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006839 SEND_ERR(px, "Lua function '%s': execution timeout.\n", rule->arg.hlua_rule->fcn.name);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006840 goto end;
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006841
6842 case HLUA_E_NOMEM:
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006843 SEND_ERR(px, "Lua function '%s': out of memory error.\n", rule->arg.hlua_rule->fcn.name);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006844 goto end;
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006845
6846 case HLUA_E_YIELD:
Christopher Faulet498c4832020-07-28 11:59:58 +02006847 err_yield:
6848 act_ret = ACT_RET_CONT;
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006849 SEND_ERR(px, "Lua function '%s': aborting Lua processing on expired timeout.\n",
6850 rule->arg.hlua_rule->fcn.name);
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006851 goto end;
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006852
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006853 case HLUA_E_ERR:
6854 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006855 SEND_ERR(px, "Lua function '%s' return an unknown error.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006856 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006857
6858 default:
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006859 goto end;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006860 }
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006861
6862 end:
Christopher Faulet2361fd92020-07-30 10:40:58 +02006863 if (act_ret != ACT_RET_YIELD && s->hlua)
Christopher Faulet8f587ea2020-07-28 12:01:55 +02006864 s->hlua->wake_time = TICK_ETERNITY;
Christopher Faulet7716cdf2020-01-29 11:53:30 +01006865 return act_ret;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006866}
6867
Olivier Houchard9f6af332018-05-25 14:04:04 +02006868struct task *hlua_applet_wakeup(struct task *t, void *context, unsigned short state)
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006869{
Olivier Houchard9f6af332018-05-25 14:04:04 +02006870 struct appctx *ctx = context;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006871
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006872 appctx_wakeup(ctx);
Willy Tarreaud9587412017-08-23 16:07:33 +02006873 t->expire = TICK_ETERNITY;
Willy Tarreaud1aa41f2017-07-21 16:41:56 +02006874 return t;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006875}
6876
6877static int hlua_applet_tcp_init(struct appctx *ctx, struct proxy *px, struct stream *strm)
6878{
6879 struct stream_interface *si = ctx->owner;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006880 struct hlua *hlua;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006881 struct task *task;
6882 char **arg;
Thierry Fournierfd107a22016-02-19 19:57:23 +01006883 const char *error;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006884
Willy Tarreaubafbe012017-11-24 17:34:44 +01006885 hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006886 if (!hlua) {
6887 SEND_ERR(px, "Lua applet tcp '%s': out of memory.\n",
6888 ctx->rule->arg.hlua_rule->fcn.name);
6889 return 0;
6890 }
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006891 HLUA_INIT(hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006892 ctx->ctx.hlua_apptcp.hlua = hlua;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006893 ctx->ctx.hlua_apptcp.flags = 0;
6894
6895 /* Create task used by signal to wakeup applets. */
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01006896 task = task_new(tid_bit);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006897 if (!task) {
6898 SEND_ERR(px, "Lua applet tcp '%s': out of memory.\n",
6899 ctx->rule->arg.hlua_rule->fcn.name);
6900 return 0;
6901 }
6902 task->nice = 0;
6903 task->context = ctx;
6904 task->process = hlua_applet_wakeup;
6905 ctx->ctx.hlua_apptcp.task = task;
6906
6907 /* In the execution wrappers linked with a stream, the
6908 * Lua context can be not initialized. This behavior
6909 * permits to save performances because a systematic
6910 * Lua initialization cause 5% performances loss.
6911 */
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01006912 if (!hlua_ctx_init(hlua, task, 0)) {
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006913 SEND_ERR(px, "Lua applet tcp '%s': can't initialize Lua context.\n",
6914 ctx->rule->arg.hlua_rule->fcn.name);
6915 return 0;
6916 }
6917
6918 /* Set timeout according with the applet configuration. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02006919 hlua->max_time = ctx->applet->timeout;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006920
6921 /* The following Lua calls can fail. */
6922 if (!SET_SAFE_LJMP(hlua->T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01006923 if (lua_type(hlua->T, -1) == LUA_TSTRING)
6924 error = lua_tostring(hlua->T, -1);
6925 else
6926 error = "critical error";
6927 SEND_ERR(px, "Lua applet tcp '%s': %s.\n",
6928 ctx->rule->arg.hlua_rule->fcn.name, error);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006929 return 0;
6930 }
6931
6932 /* Check stack available size. */
6933 if (!lua_checkstack(hlua->T, 1)) {
6934 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
6935 ctx->rule->arg.hlua_rule->fcn.name);
6936 RESET_SAFE_LJMP(hlua->T);
6937 return 0;
6938 }
6939
6940 /* Restore the function in the stack. */
6941 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ctx->rule->arg.hlua_rule->fcn.function_ref);
6942
6943 /* Create and and push object stream in the stack. */
6944 if (!hlua_applet_tcp_new(hlua->T, ctx)) {
6945 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
6946 ctx->rule->arg.hlua_rule->fcn.name);
6947 RESET_SAFE_LJMP(hlua->T);
6948 return 0;
6949 }
6950 hlua->nargs = 1;
6951
6952 /* push keywords in the stack. */
6953 for (arg = ctx->rule->arg.hlua_rule->args; arg && *arg; arg++) {
6954 if (!lua_checkstack(hlua->T, 1)) {
6955 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
6956 ctx->rule->arg.hlua_rule->fcn.name);
6957 RESET_SAFE_LJMP(hlua->T);
6958 return 0;
6959 }
6960 lua_pushstring(hlua->T, *arg);
6961 hlua->nargs++;
6962 }
6963
6964 RESET_SAFE_LJMP(hlua->T);
6965
6966 /* Wakeup the applet ASAP. */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01006967 si_cant_get(si);
Willy Tarreau3367d412018-11-15 10:57:41 +01006968 si_rx_endp_more(si);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006969
6970 return 1;
6971}
6972
Willy Tarreau60409db2019-08-21 14:14:50 +02006973void hlua_applet_tcp_fct(struct appctx *ctx)
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006974{
6975 struct stream_interface *si = ctx->owner;
6976 struct stream *strm = si_strm(si);
6977 struct channel *res = si_ic(si);
6978 struct act_rule *rule = ctx->rule;
6979 struct proxy *px = strm->be;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006980 struct hlua *hlua = ctx->ctx.hlua_apptcp.hlua;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006981
6982 /* The applet execution is already done. */
Olivier Houchard594c8c52018-08-28 14:41:31 +02006983 if (ctx->ctx.hlua_apptcp.flags & APPLET_DONE) {
6984 /* eat the whole request */
6985 co_skip(si_oc(si), co_data(si_oc(si)));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006986 return;
Olivier Houchard594c8c52018-08-28 14:41:31 +02006987 }
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006988
6989 /* If the stream is disconnect or closed, ldo nothing. */
6990 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
6991 return;
6992
6993 /* Execute the function. */
6994 switch (hlua_ctx_resume(hlua, 1)) {
6995 /* finished. */
6996 case HLUA_E_OK:
6997 ctx->ctx.hlua_apptcp.flags |= APPLET_DONE;
6998
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006999 /* eat the whole request */
Willy Tarreaua79021a2018-06-15 18:07:57 +02007000 co_skip(si_oc(si), co_data(si_oc(si)));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007001 res->flags |= CF_READ_NULL;
7002 si_shutr(si);
7003 return;
7004
7005 /* yield. */
7006 case HLUA_E_AGAIN:
Thierry Fournier0164f202016-02-20 17:47:43 +01007007 if (hlua->wake_time != TICK_ETERNITY)
7008 task_schedule(ctx->ctx.hlua_apptcp.task, hlua->wake_time);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007009 return;
7010
7011 /* finished with error. */
7012 case HLUA_E_ERRMSG:
7013 /* Display log. */
7014 SEND_ERR(px, "Lua applet tcp '%s': %s.\n",
7015 rule->arg.hlua_rule->fcn.name, lua_tostring(hlua->T, -1));
7016 lua_pop(hlua->T, 1);
7017 goto error;
7018
Thierry Fournierd5b073c2018-05-21 19:42:47 +02007019 case HLUA_E_ETMOUT:
7020 SEND_ERR(px, "Lua applet tcp '%s': execution timeout.\n",
7021 rule->arg.hlua_rule->fcn.name);
7022 goto error;
7023
7024 case HLUA_E_NOMEM:
7025 SEND_ERR(px, "Lua applet tcp '%s': out of memory error.\n",
7026 rule->arg.hlua_rule->fcn.name);
7027 goto error;
7028
7029 case HLUA_E_YIELD: /* unexpected */
7030 SEND_ERR(px, "Lua applet tcp '%s': yield not allowed.\n",
7031 rule->arg.hlua_rule->fcn.name);
7032 goto error;
7033
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007034 case HLUA_E_ERR:
7035 /* Display log. */
7036 SEND_ERR(px, "Lua applet tcp '%s' return an unknown error.\n",
7037 rule->arg.hlua_rule->fcn.name);
7038 goto error;
7039
7040 default:
7041 goto error;
7042 }
7043
7044error:
7045
7046 /* For all other cases, just close the stream. */
7047 si_shutw(si);
7048 si_shutr(si);
7049 ctx->ctx.hlua_apptcp.flags |= APPLET_DONE;
7050}
7051
7052static void hlua_applet_tcp_release(struct appctx *ctx)
7053{
Olivier Houchard3f795f72019-04-17 22:51:06 +02007054 task_destroy(ctx->ctx.hlua_apptcp.task);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007055 ctx->ctx.hlua_apptcp.task = NULL;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007056 hlua_ctx_destroy(ctx->ctx.hlua_apptcp.hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007057 ctx->ctx.hlua_apptcp.hlua = NULL;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007058}
7059
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007060/* The function returns 1 if the initialisation is complete, 0 if
7061 * an errors occurs and -1 if more data are required for initializing
7062 * the applet.
7063 */
7064static int hlua_applet_http_init(struct appctx *ctx, struct proxy *px, struct stream *strm)
7065{
7066 struct stream_interface *si = ctx->owner;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007067 struct http_txn *txn;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007068 struct hlua *hlua;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007069 char **arg;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007070 struct task *task;
Thierry Fournierfd107a22016-02-19 19:57:23 +01007071 const char *error;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007072
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007073 txn = strm->txn;
Willy Tarreaubafbe012017-11-24 17:34:44 +01007074 hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007075 if (!hlua) {
7076 SEND_ERR(px, "Lua applet http '%s': out of memory.\n",
7077 ctx->rule->arg.hlua_rule->fcn.name);
7078 return 0;
7079 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007080 HLUA_INIT(hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007081 ctx->ctx.hlua_apphttp.hlua = hlua;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007082 ctx->ctx.hlua_apphttp.left_bytes = -1;
7083 ctx->ctx.hlua_apphttp.flags = 0;
7084
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +01007085 if (txn->req.flags & HTTP_MSGF_VER_11)
7086 ctx->ctx.hlua_apphttp.flags |= APPLET_HTTP11;
7087
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007088 /* Create task used by signal to wakeup applets. */
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01007089 task = task_new(tid_bit);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007090 if (!task) {
7091 SEND_ERR(px, "Lua applet http '%s': out of memory.\n",
7092 ctx->rule->arg.hlua_rule->fcn.name);
7093 return 0;
7094 }
7095 task->nice = 0;
7096 task->context = ctx;
7097 task->process = hlua_applet_wakeup;
7098 ctx->ctx.hlua_apphttp.task = task;
7099
7100 /* In the execution wrappers linked with a stream, the
7101 * Lua context can be not initialized. This behavior
7102 * permits to save performances because a systematic
7103 * Lua initialization cause 5% performances loss.
7104 */
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01007105 if (!hlua_ctx_init(hlua, task, 0)) {
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007106 SEND_ERR(px, "Lua applet http '%s': can't initialize Lua context.\n",
7107 ctx->rule->arg.hlua_rule->fcn.name);
7108 return 0;
7109 }
7110
7111 /* Set timeout according with the applet configuration. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02007112 hlua->max_time = ctx->applet->timeout;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007113
7114 /* The following Lua calls can fail. */
7115 if (!SET_SAFE_LJMP(hlua->T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01007116 if (lua_type(hlua->T, -1) == LUA_TSTRING)
7117 error = lua_tostring(hlua->T, -1);
7118 else
7119 error = "critical error";
7120 SEND_ERR(px, "Lua applet http '%s': %s.\n",
7121 ctx->rule->arg.hlua_rule->fcn.name, error);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007122 return 0;
7123 }
7124
7125 /* Check stack available size. */
7126 if (!lua_checkstack(hlua->T, 1)) {
7127 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
7128 ctx->rule->arg.hlua_rule->fcn.name);
7129 RESET_SAFE_LJMP(hlua->T);
7130 return 0;
7131 }
7132
7133 /* Restore the function in the stack. */
7134 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ctx->rule->arg.hlua_rule->fcn.function_ref);
7135
7136 /* Create and and push object stream in the stack. */
7137 if (!hlua_applet_http_new(hlua->T, ctx)) {
7138 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
7139 ctx->rule->arg.hlua_rule->fcn.name);
7140 RESET_SAFE_LJMP(hlua->T);
7141 return 0;
7142 }
7143 hlua->nargs = 1;
7144
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007145 /* push keywords in the stack. */
7146 for (arg = ctx->rule->arg.hlua_rule->args; arg && *arg; arg++) {
7147 if (!lua_checkstack(hlua->T, 1)) {
7148 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
7149 ctx->rule->arg.hlua_rule->fcn.name);
7150 RESET_SAFE_LJMP(hlua->T);
7151 return 0;
7152 }
7153 lua_pushstring(hlua->T, *arg);
7154 hlua->nargs++;
7155 }
7156
7157 RESET_SAFE_LJMP(hlua->T);
7158
7159 /* Wakeup the applet when data is ready for read. */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01007160 si_cant_get(si);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007161
7162 return 1;
7163}
7164
Willy Tarreau60409db2019-08-21 14:14:50 +02007165void hlua_applet_http_fct(struct appctx *ctx)
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007166{
7167 struct stream_interface *si = ctx->owner;
7168 struct stream *strm = si_strm(si);
7169 struct channel *req = si_oc(si);
7170 struct channel *res = si_ic(si);
7171 struct act_rule *rule = ctx->rule;
7172 struct proxy *px = strm->be;
7173 struct hlua *hlua = ctx->ctx.hlua_apphttp.hlua;
7174 struct htx *req_htx, *res_htx;
7175
7176 res_htx = htx_from_buf(&res->buf);
7177
7178 /* If the stream is disconnect or closed, ldo nothing. */
7179 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
7180 goto out;
7181
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05007182 /* Check if the input buffer is available. */
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007183 if (!b_size(&res->buf)) {
7184 si_rx_room_blk(si);
7185 goto out;
7186 }
7187 /* check that the output is not closed */
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007188 if (res->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_SHUTR))
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007189 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
7190
7191 /* Set the currently running flag. */
7192 if (!HLUA_IS_RUNNING(hlua) &&
7193 !(ctx->ctx.hlua_apphttp.flags & APPLET_DONE)) {
7194 struct htx_blk *blk;
7195 size_t count = co_data(req);
7196
7197 if (!count) {
7198 si_cant_get(si);
7199 goto out;
7200 }
7201
7202 /* We need to flush the request header. This left the body for
7203 * the Lua.
7204 */
7205 req_htx = htx_from_buf(&req->buf);
Christopher Fauleta3f15502019-05-13 15:27:23 +02007206 blk = htx_get_first_blk(req_htx);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007207 while (count && blk) {
7208 enum htx_blk_type type = htx_get_blk_type(blk);
7209 uint32_t sz = htx_get_blksz(blk);
7210
7211 if (sz > count) {
7212 si_cant_get(si);
Christopher Faulet0ae79d02019-02-27 21:36:59 +01007213 htx_to_buf(req_htx, &req->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007214 goto out;
7215 }
7216
7217 count -= sz;
7218 co_set_data(req, co_data(req) - sz);
7219 blk = htx_remove_blk(req_htx, blk);
7220
7221 if (type == HTX_BLK_EOH)
7222 break;
7223 }
Christopher Faulet0ae79d02019-02-27 21:36:59 +01007224 htx_to_buf(req_htx, &req->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007225 }
7226
7227 /* Executes The applet if it is not done. */
7228 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_DONE)) {
7229
7230 /* Execute the function. */
7231 switch (hlua_ctx_resume(hlua, 1)) {
7232 /* finished. */
7233 case HLUA_E_OK:
7234 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
7235 break;
7236
7237 /* yield. */
7238 case HLUA_E_AGAIN:
7239 if (hlua->wake_time != TICK_ETERNITY)
7240 task_schedule(ctx->ctx.hlua_apphttp.task, hlua->wake_time);
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007241 goto out;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007242
7243 /* finished with error. */
7244 case HLUA_E_ERRMSG:
7245 /* Display log. */
7246 SEND_ERR(px, "Lua applet http '%s': %s.\n",
7247 rule->arg.hlua_rule->fcn.name, lua_tostring(hlua->T, -1));
7248 lua_pop(hlua->T, 1);
7249 goto error;
7250
7251 case HLUA_E_ETMOUT:
7252 SEND_ERR(px, "Lua applet http '%s': execution timeout.\n",
7253 rule->arg.hlua_rule->fcn.name);
7254 goto error;
7255
7256 case HLUA_E_NOMEM:
7257 SEND_ERR(px, "Lua applet http '%s': out of memory error.\n",
7258 rule->arg.hlua_rule->fcn.name);
7259 goto error;
7260
7261 case HLUA_E_YIELD: /* unexpected */
7262 SEND_ERR(px, "Lua applet http '%s': yield not allowed.\n",
7263 rule->arg.hlua_rule->fcn.name);
7264 goto error;
7265
7266 case HLUA_E_ERR:
7267 /* Display log. */
7268 SEND_ERR(px, "Lua applet http '%s' return an unknown error.\n",
7269 rule->arg.hlua_rule->fcn.name);
7270 goto error;
7271
7272 default:
7273 goto error;
7274 }
7275 }
7276
7277 if (ctx->ctx.hlua_apphttp.flags & APPLET_DONE) {
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007278 if (ctx->ctx.hlua_apphttp.flags & APPLET_RSP_SENT)
7279 goto done;
7280
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007281 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT))
7282 goto error;
7283
Christopher Faulet54b5e212019-06-04 10:08:28 +02007284 /* Don't add TLR because mux-h1 will take care of it */
Willy Tarreauf1ea47d2020-07-23 06:53:27 +02007285 res_htx->flags |= HTX_FL_EOI; /* no more data are expected. Only EOM remains to add now */
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007286 if (!htx_add_endof(res_htx, HTX_BLK_EOM)) {
7287 si_rx_room_blk(si);
7288 goto out;
7289 }
Christopher Fauletf6cce3f2019-02-27 21:20:09 +01007290 channel_add_input(res, 1);
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007291 strm->txn->status = ctx->ctx.hlua_apphttp.status;
7292 ctx->ctx.hlua_apphttp.flags |= APPLET_RSP_SENT;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007293 }
7294
7295 done:
7296 if (ctx->ctx.hlua_apphttp.flags & APPLET_DONE) {
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007297 if (!(res->flags & CF_SHUTR)) {
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007298 res->flags |= CF_READ_NULL;
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007299 si_shutr(si);
7300 }
7301
7302 /* eat the whole request */
7303 if (co_data(req)) {
7304 req_htx = htx_from_buf(&req->buf);
7305 co_htx_skip(req, req_htx, co_data(req));
7306 htx_to_buf(req_htx, &req->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007307 }
7308 }
7309
7310 out:
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007311 htx_to_buf(res_htx, &res->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007312 return;
7313
7314 error:
7315
7316 /* If we are in HTTP mode, and we are not send any
7317 * data, return a 500 server error in best effort:
7318 * if there is no room available in the buffer,
7319 * just close the connection.
7320 */
7321 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT)) {
Christopher Fauletf7346382019-07-17 22:02:08 +02007322 struct buffer *err = &http_err_chunks[HTTP_ERR_500];
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007323
7324 channel_erase(res);
7325 res->buf.data = b_data(err);
7326 memcpy(res->buf.area, b_head(err), b_data(err));
7327 res_htx = htx_from_buf(&res->buf);
Christopher Fauletf6cce3f2019-02-27 21:20:09 +01007328 channel_add_input(res, res_htx->data);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007329 }
7330 if (!(strm->flags & SF_ERR_MASK))
7331 strm->flags |= SF_ERR_RESOURCE;
7332 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
7333 goto done;
7334}
7335
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007336static void hlua_applet_http_release(struct appctx *ctx)
7337{
Olivier Houchard3f795f72019-04-17 22:51:06 +02007338 task_destroy(ctx->ctx.hlua_apphttp.task);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007339 ctx->ctx.hlua_apphttp.task = NULL;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007340 hlua_ctx_destroy(ctx->ctx.hlua_apphttp.hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007341 ctx->ctx.hlua_apphttp.hlua = NULL;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007342}
7343
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007344/* global {tcp|http}-request parser. Return ACT_RET_PRS_OK in
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05007345 * success case, else return ACT_RET_PRS_ERR.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02007346 *
7347 * This function can fail with an abort() due to an Lua critical error.
7348 * We are in the configuration parsing process of HAProxy, this abort() is
7349 * tolerated.
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007350 */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007351static enum act_parse_ret action_register_lua(const char **args, int *cur_arg, struct proxy *px,
7352 struct act_rule *rule, char **err)
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007353{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02007354 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007355 int i;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007356
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007357 /* Memory for the rule. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02007358 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007359 if (!rule->arg.hlua_rule) {
7360 memprintf(err, "out of memory error");
Thierry FOURNIERafa80492015-08-19 09:04:15 +02007361 return ACT_RET_PRS_ERR;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007362 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007363
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007364 /* Memory for arguments. */
Tim Duesterhuse52b6e52020-09-12 20:26:43 +02007365 rule->arg.hlua_rule->args = calloc(fcn->nargs + 1,
7366 sizeof(*rule->arg.hlua_rule->args));
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007367 if (!rule->arg.hlua_rule->args) {
7368 memprintf(err, "out of memory error");
7369 return ACT_RET_PRS_ERR;
7370 }
7371
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007372 /* Reference the Lua function and store the reference. */
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007373 rule->arg.hlua_rule->fcn = *fcn;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007374
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007375 /* Expect some arguments */
7376 for (i = 0; i < fcn->nargs; i++) {
Thierry FOURNIER1725c2e2019-01-06 19:38:49 +01007377 if (*args[*cur_arg] == '\0') {
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007378 memprintf(err, "expect %d arguments", fcn->nargs);
7379 return ACT_RET_PRS_ERR;
7380 }
Thierry FOURNIER1725c2e2019-01-06 19:38:49 +01007381 rule->arg.hlua_rule->args[i] = strdup(args[*cur_arg]);
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007382 if (!rule->arg.hlua_rule->args[i]) {
7383 memprintf(err, "out of memory error");
7384 return ACT_RET_PRS_ERR;
7385 }
7386 (*cur_arg)++;
7387 }
7388 rule->arg.hlua_rule->args[i] = NULL;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007389
Thierry FOURNIER42148732015-09-02 17:17:33 +02007390 rule->action = ACT_CUSTOM;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007391 rule->action_ptr = hlua_action;
Thierry FOURNIERafa80492015-08-19 09:04:15 +02007392 return ACT_RET_PRS_OK;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007393}
7394
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007395static enum act_parse_ret action_register_service_http(const char **args, int *cur_arg, struct proxy *px,
7396 struct act_rule *rule, char **err)
7397{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02007398 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007399
Thierry FOURNIER718e2a72015-12-20 20:13:14 +01007400 /* HTTP applets are forbidden in tcp-request rules.
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05007401 * HTTP applet request requires everything initialized by
Thierry FOURNIER718e2a72015-12-20 20:13:14 +01007402 * "http_process_request" (analyzer flag AN_REQ_HTTP_INNER).
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05007403 * The applet will be immediately initialized, but its before
Thierry FOURNIER718e2a72015-12-20 20:13:14 +01007404 * the call of this analyzer.
7405 */
7406 if (rule->from != ACT_F_HTTP_REQ) {
7407 memprintf(err, "HTTP applets are forbidden from 'tcp-request' rulesets");
7408 return ACT_RET_PRS_ERR;
7409 }
7410
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007411 /* Memory for the rule. */
7412 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
7413 if (!rule->arg.hlua_rule) {
7414 memprintf(err, "out of memory error");
7415 return ACT_RET_PRS_ERR;
7416 }
7417
7418 /* Reference the Lua function and store the reference. */
7419 rule->arg.hlua_rule->fcn = *fcn;
7420
7421 /* TODO: later accept arguments. */
7422 rule->arg.hlua_rule->args = NULL;
7423
7424 /* Add applet pointer in the rule. */
7425 rule->applet.obj_type = OBJ_TYPE_APPLET;
7426 rule->applet.name = fcn->name;
7427 rule->applet.init = hlua_applet_http_init;
7428 rule->applet.fct = hlua_applet_http_fct;
7429 rule->applet.release = hlua_applet_http_release;
7430 rule->applet.timeout = hlua_timeout_applet;
7431
7432 return ACT_RET_PRS_OK;
7433}
7434
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007435/* This function is an LUA binding used for registering
7436 * "sample-conv" functions. It expects a converter name used
7437 * in the haproxy configuration file, and an LUA function.
7438 */
7439__LJMP static int hlua_register_action(lua_State *L)
7440{
7441 struct action_kw_list *akl;
7442 const char *name;
7443 int ref;
7444 int len;
7445 struct hlua_function *fcn;
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007446 int nargs;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007447
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007448 /* Initialise the number of expected arguments at 0. */
7449 nargs = 0;
7450
7451 if (lua_gettop(L) < 3 || lua_gettop(L) > 4)
7452 WILL_LJMP(luaL_error(L, "'register_action' needs between 3 and 4 arguments"));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007453
7454 /* First argument : converter name. */
7455 name = MAY_LJMP(luaL_checkstring(L, 1));
7456
7457 /* Second argument : environment. */
7458 if (lua_type(L, 2) != LUA_TTABLE)
7459 WILL_LJMP(luaL_error(L, "register_action: second argument must be a table of strings"));
7460
7461 /* Third argument : lua function. */
7462 ref = MAY_LJMP(hlua_checkfunction(L, 3));
7463
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08007464 /* Fourth argument : number of mandatory arguments expected on the configuration line. */
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007465 if (lua_gettop(L) >= 4)
7466 nargs = MAY_LJMP(luaL_checkinteger(L, 4));
7467
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08007468 /* browse the second argument as an array. */
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007469 lua_pushnil(L);
7470 while (lua_next(L, 2) != 0) {
7471 if (lua_type(L, -1) != LUA_TSTRING)
7472 WILL_LJMP(luaL_error(L, "register_action: second argument must be a table of strings"));
7473
7474 /* Check required environment. Only accepted "http" or "tcp". */
7475 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02007476 akl = calloc(1, sizeof(*akl) + sizeof(struct action_kw) * 2);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007477 if (!akl)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007478 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02007479 fcn = calloc(1, sizeof(*fcn));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007480 if (!fcn)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007481 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007482
7483 /* Fill fcn. */
7484 fcn->name = strdup(name);
7485 if (!fcn->name)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007486 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007487 fcn->function_ref = ref;
7488
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007489 /* Set the expected number od arguments. */
7490 fcn->nargs = nargs;
7491
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007492 /* List head */
7493 akl->list.n = akl->list.p = NULL;
7494
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007495 /* action keyword. */
7496 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02007497 akl->kw[0].kw = calloc(1, len);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007498 if (!akl->kw[0].kw)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007499 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007500
7501 snprintf((char *)akl->kw[0].kw, len, "lua.%s", name);
7502
7503 akl->kw[0].match_pfx = 0;
7504 akl->kw[0].private = fcn;
7505 akl->kw[0].parse = action_register_lua;
7506
7507 /* select the action registering point. */
7508 if (strcmp(lua_tostring(L, -1), "tcp-req") == 0)
7509 tcp_req_cont_keywords_register(akl);
7510 else if (strcmp(lua_tostring(L, -1), "tcp-res") == 0)
7511 tcp_res_cont_keywords_register(akl);
7512 else if (strcmp(lua_tostring(L, -1), "http-req") == 0)
7513 http_req_keywords_register(akl);
7514 else if (strcmp(lua_tostring(L, -1), "http-res") == 0)
7515 http_res_keywords_register(akl);
7516 else
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007517 WILL_LJMP(luaL_error(L, "Lua action environment '%s' is unknown. "
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007518 "'tcp-req', 'tcp-res', 'http-req' or 'http-res' "
7519 "are expected.", lua_tostring(L, -1)));
7520
7521 /* pop the environment string. */
7522 lua_pop(L, 1);
7523 }
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007524 return ACT_RET_PRS_OK;
7525}
7526
7527static enum act_parse_ret action_register_service_tcp(const char **args, int *cur_arg, struct proxy *px,
7528 struct act_rule *rule, char **err)
7529{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02007530 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007531
Christopher Faulet280f85b2019-07-15 15:02:04 +02007532 if (px->mode == PR_MODE_HTTP) {
7533 memprintf(err, "Lua TCP services cannot be used on HTTP proxies");
Christopher Fauletafd8f102018-11-08 11:34:21 +01007534 return ACT_RET_PRS_ERR;
7535 }
7536
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007537 /* Memory for the rule. */
7538 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
7539 if (!rule->arg.hlua_rule) {
7540 memprintf(err, "out of memory error");
7541 return ACT_RET_PRS_ERR;
7542 }
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007543
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007544 /* Reference the Lua function and store the reference. */
7545 rule->arg.hlua_rule->fcn = *fcn;
7546
7547 /* TODO: later accept arguments. */
7548 rule->arg.hlua_rule->args = NULL;
7549
7550 /* Add applet pointer in the rule. */
7551 rule->applet.obj_type = OBJ_TYPE_APPLET;
7552 rule->applet.name = fcn->name;
7553 rule->applet.init = hlua_applet_tcp_init;
7554 rule->applet.fct = hlua_applet_tcp_fct;
7555 rule->applet.release = hlua_applet_tcp_release;
7556 rule->applet.timeout = hlua_timeout_applet;
7557
7558 return 0;
7559}
7560
7561/* This function is an LUA binding used for registering
7562 * "sample-conv" functions. It expects a converter name used
7563 * in the haproxy configuration file, and an LUA function.
7564 */
7565__LJMP static int hlua_register_service(lua_State *L)
7566{
7567 struct action_kw_list *akl;
7568 const char *name;
7569 const char *env;
7570 int ref;
7571 int len;
7572 struct hlua_function *fcn;
7573
7574 MAY_LJMP(check_args(L, 3, "register_service"));
7575
7576 /* First argument : converter name. */
7577 name = MAY_LJMP(luaL_checkstring(L, 1));
7578
7579 /* Second argument : environment. */
7580 env = MAY_LJMP(luaL_checkstring(L, 2));
7581
7582 /* Third argument : lua function. */
7583 ref = MAY_LJMP(hlua_checkfunction(L, 3));
7584
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007585 /* Allocate and fill the sample fetch keyword struct. */
7586 akl = calloc(1, sizeof(*akl) + sizeof(struct action_kw) * 2);
7587 if (!akl)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007588 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007589 fcn = calloc(1, sizeof(*fcn));
7590 if (!fcn)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007591 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007592
7593 /* Fill fcn. */
7594 len = strlen("<lua.>") + strlen(name) + 1;
7595 fcn->name = calloc(1, len);
7596 if (!fcn->name)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007597 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007598 snprintf((char *)fcn->name, len, "<lua.%s>", name);
7599 fcn->function_ref = ref;
7600
7601 /* List head */
7602 akl->list.n = akl->list.p = NULL;
7603
7604 /* converter keyword. */
7605 len = strlen("lua.") + strlen(name) + 1;
7606 akl->kw[0].kw = calloc(1, len);
7607 if (!akl->kw[0].kw)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007608 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007609
7610 snprintf((char *)akl->kw[0].kw, len, "lua.%s", name);
7611
Thierry FOURNIER / OZON.IO02564fd2016-11-12 11:07:05 +01007612 /* Check required environment. Only accepted "http" or "tcp". */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007613 if (strcmp(env, "tcp") == 0)
7614 akl->kw[0].parse = action_register_service_tcp;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007615 else if (strcmp(env, "http") == 0)
7616 akl->kw[0].parse = action_register_service_http;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007617 else
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007618 WILL_LJMP(luaL_error(L, "Lua service environment '%s' is unknown. "
Eric Salamafe7456f2017-12-21 14:30:07 +01007619 "'tcp' or 'http' are expected.", env));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007620
7621 akl->kw[0].match_pfx = 0;
7622 akl->kw[0].private = fcn;
7623
7624 /* End of array. */
7625 memset(&akl->kw[1], 0, sizeof(*akl->kw));
7626
7627 /* Register this new converter */
7628 service_keywords_register(akl);
7629
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007630 return 0;
7631}
7632
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007633/* This function initialises Lua cli handler. It copies the
7634 * arguments in the Lua stack and create channel IO objects.
7635 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02007636static int hlua_cli_parse_fct(char **args, char *payload, struct appctx *appctx, void *private)
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007637{
7638 struct hlua *hlua;
7639 struct hlua_function *fcn;
7640 int i;
7641 const char *error;
7642
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007643 fcn = private;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007644 appctx->ctx.hlua_cli.fcn = private;
7645
Willy Tarreaubafbe012017-11-24 17:34:44 +01007646 hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007647 if (!hlua) {
7648 SEND_ERR(NULL, "Lua cli '%s': out of memory.\n", fcn->name);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01007649 return 1;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007650 }
7651 HLUA_INIT(hlua);
7652 appctx->ctx.hlua_cli.hlua = hlua;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007653
7654 /* Create task used by signal to wakeup applets.
Ilya Shipitsind4259502020-04-08 01:07:56 +05007655 * We use the same wakeup function than the Lua applet_tcp and
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007656 * applet_http. It is absolutely compatible.
7657 */
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01007658 appctx->ctx.hlua_cli.task = task_new(tid_bit);
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007659 if (!appctx->ctx.hlua_cli.task) {
Thierry FOURNIERffbf5692016-12-16 11:14:06 +01007660 SEND_ERR(NULL, "Lua cli '%s': out of memory.\n", fcn->name);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01007661 goto error;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007662 }
7663 appctx->ctx.hlua_cli.task->nice = 0;
7664 appctx->ctx.hlua_cli.task->context = appctx;
7665 appctx->ctx.hlua_cli.task->process = hlua_applet_wakeup;
7666
7667 /* Initialises the Lua context */
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01007668 if (!hlua_ctx_init(hlua, appctx->ctx.hlua_cli.task, 0)) {
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007669 SEND_ERR(NULL, "Lua cli '%s': can't initialize Lua context.\n", fcn->name);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01007670 goto error;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007671 }
7672
7673 /* The following Lua calls can fail. */
7674 if (!SET_SAFE_LJMP(hlua->T)) {
7675 if (lua_type(hlua->T, -1) == LUA_TSTRING)
7676 error = lua_tostring(hlua->T, -1);
7677 else
7678 error = "critical error";
7679 SEND_ERR(NULL, "Lua cli '%s': %s.\n", fcn->name, error);
7680 goto error;
7681 }
7682
7683 /* Check stack available size. */
7684 if (!lua_checkstack(hlua->T, 2)) {
7685 SEND_ERR(NULL, "Lua cli '%s': full stack.\n", fcn->name);
7686 goto error;
7687 }
7688
7689 /* Restore the function in the stack. */
7690 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, fcn->function_ref);
7691
7692 /* Once the arguments parsed, the CLI is like an AppletTCP,
7693 * so push AppletTCP in the stack.
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007694 */
7695 if (!hlua_applet_tcp_new(hlua->T, appctx)) {
7696 SEND_ERR(NULL, "Lua cli '%s': full stack.\n", fcn->name);
7697 goto error;
7698 }
7699 hlua->nargs = 1;
7700
7701 /* push keywords in the stack. */
7702 for (i = 0; *args[i]; i++) {
7703 /* Check stack available size. */
7704 if (!lua_checkstack(hlua->T, 1)) {
7705 SEND_ERR(NULL, "Lua cli '%s': full stack.\n", fcn->name);
7706 goto error;
7707 }
7708 lua_pushstring(hlua->T, args[i]);
7709 hlua->nargs++;
7710 }
7711
7712 /* We must initialize the execution timeouts. */
7713 hlua->max_time = hlua_timeout_session;
7714
7715 /* At this point the execution is safe. */
7716 RESET_SAFE_LJMP(hlua->T);
7717
7718 /* It's ok */
7719 return 0;
7720
7721 /* It's not ok. */
7722error:
7723 RESET_SAFE_LJMP(hlua->T);
7724 hlua_ctx_destroy(hlua);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01007725 appctx->ctx.hlua_cli.hlua = NULL;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007726 return 1;
7727}
7728
7729static int hlua_cli_io_handler_fct(struct appctx *appctx)
7730{
7731 struct hlua *hlua;
7732 struct stream_interface *si;
7733 struct hlua_function *fcn;
7734
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007735 hlua = appctx->ctx.hlua_cli.hlua;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007736 si = appctx->owner;
Willy Tarreau8ae4f752016-12-14 15:41:45 +01007737 fcn = appctx->ctx.hlua_cli.fcn;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007738
7739 /* If the stream is disconnect or closed, ldo nothing. */
7740 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
7741 return 1;
7742
7743 /* Execute the function. */
7744 switch (hlua_ctx_resume(hlua, 1)) {
7745
7746 /* finished. */
7747 case HLUA_E_OK:
7748 return 1;
7749
7750 /* yield. */
7751 case HLUA_E_AGAIN:
7752 /* We want write. */
7753 if (HLUA_IS_WAKERESWR(hlua))
Willy Tarreaudb398432018-11-15 11:08:52 +01007754 si_rx_room_blk(si);
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007755 /* Set the timeout. */
7756 if (hlua->wake_time != TICK_ETERNITY)
7757 task_schedule(hlua->task, hlua->wake_time);
7758 return 0;
7759
7760 /* finished with error. */
7761 case HLUA_E_ERRMSG:
7762 /* Display log. */
7763 SEND_ERR(NULL, "Lua cli '%s': %s.\n",
7764 fcn->name, lua_tostring(hlua->T, -1));
7765 lua_pop(hlua->T, 1);
7766 return 1;
7767
Thierry Fournierd5b073c2018-05-21 19:42:47 +02007768 case HLUA_E_ETMOUT:
7769 SEND_ERR(NULL, "Lua converter '%s': execution timeout.\n",
7770 fcn->name);
7771 return 1;
7772
7773 case HLUA_E_NOMEM:
7774 SEND_ERR(NULL, "Lua converter '%s': out of memory error.\n",
7775 fcn->name);
7776 return 1;
7777
7778 case HLUA_E_YIELD: /* unexpected */
7779 SEND_ERR(NULL, "Lua converter '%s': yield not allowed.\n",
7780 fcn->name);
7781 return 1;
7782
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007783 case HLUA_E_ERR:
7784 /* Display log. */
7785 SEND_ERR(NULL, "Lua cli '%s' return an unknown error.\n",
7786 fcn->name);
7787 return 1;
7788
7789 default:
7790 return 1;
7791 }
7792
7793 return 1;
7794}
7795
7796static void hlua_cli_io_release_fct(struct appctx *appctx)
7797{
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007798 hlua_ctx_destroy(appctx->ctx.hlua_cli.hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007799 appctx->ctx.hlua_cli.hlua = NULL;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007800}
7801
7802/* This function is an LUA binding used for registering
7803 * new keywords in the cli. It expects a list of keywords
7804 * which are the "path". It is limited to 5 keywords. A
7805 * description of the command, a function to be executed
7806 * for the parsing and a function for io handlers.
7807 */
7808__LJMP static int hlua_register_cli(lua_State *L)
7809{
7810 struct cli_kw_list *cli_kws;
7811 const char *message;
7812 int ref_io;
7813 int len;
7814 struct hlua_function *fcn;
7815 int index;
7816 int i;
7817
7818 MAY_LJMP(check_args(L, 3, "register_cli"));
7819
7820 /* First argument : an array of maximum 5 keywords. */
7821 if (!lua_istable(L, 1))
7822 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table"));
7823
7824 /* Second argument : string with contextual message. */
7825 message = MAY_LJMP(luaL_checkstring(L, 2));
7826
7827 /* Third and fourth argument : lua function. */
7828 ref_io = MAY_LJMP(hlua_checkfunction(L, 3));
7829
7830 /* Allocate and fill the sample fetch keyword struct. */
7831 cli_kws = calloc(1, sizeof(*cli_kws) + sizeof(struct cli_kw) * 2);
7832 if (!cli_kws)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007833 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007834 fcn = calloc(1, sizeof(*fcn));
7835 if (!fcn)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007836 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007837
7838 /* Fill path. */
7839 index = 0;
7840 lua_pushnil(L);
7841 while(lua_next(L, 1) != 0) {
7842 if (index >= 5)
7843 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table with a maximum of 5 entries"));
7844 if (lua_type(L, -1) != LUA_TSTRING)
7845 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table filled with strings"));
7846 cli_kws->kw[0].str_kw[index] = strdup(lua_tostring(L, -1));
7847 if (!cli_kws->kw[0].str_kw[index])
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007848 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007849 index++;
7850 lua_pop(L, 1);
7851 }
7852
7853 /* Copy help message. */
7854 cli_kws->kw[0].usage = strdup(message);
7855 if (!cli_kws->kw[0].usage)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007856 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007857
7858 /* Fill fcn io handler. */
7859 len = strlen("<lua.cli>") + 1;
7860 for (i = 0; i < index; i++)
7861 len += strlen(cli_kws->kw[0].str_kw[i]) + 1;
7862 fcn->name = calloc(1, len);
7863 if (!fcn->name)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007864 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007865 strncat((char *)fcn->name, "<lua.cli", len);
7866 for (i = 0; i < index; i++) {
7867 strncat((char *)fcn->name, ".", len);
7868 strncat((char *)fcn->name, cli_kws->kw[0].str_kw[i], len);
7869 }
7870 strncat((char *)fcn->name, ">", len);
7871 fcn->function_ref = ref_io;
7872
7873 /* Fill last entries. */
7874 cli_kws->kw[0].private = fcn;
7875 cli_kws->kw[0].parse = hlua_cli_parse_fct;
7876 cli_kws->kw[0].io_handler = hlua_cli_io_handler_fct;
7877 cli_kws->kw[0].io_release = hlua_cli_io_release_fct;
7878
7879 /* Register this new converter */
7880 cli_register_kw(cli_kws);
7881
7882 return 0;
7883}
7884
Thierry FOURNIERbd413492015-03-03 16:52:26 +01007885static int hlua_read_timeout(char **args, int section_type, struct proxy *curpx,
7886 struct proxy *defpx, const char *file, int line,
7887 char **err, unsigned int *timeout)
7888{
7889 const char *error;
7890
7891 error = parse_time_err(args[1], timeout, TIME_UNIT_MS);
Willy Tarreau9faebe32019-06-07 19:00:37 +02007892 if (error == PARSE_TIME_OVER) {
7893 memprintf(err, "timer overflow in argument <%s> to <%s> (maximum value is 2147483647 ms or ~24.8 days)",
7894 args[1], args[0]);
7895 return -1;
7896 }
7897 else if (error == PARSE_TIME_UNDER) {
7898 memprintf(err, "timer underflow in argument <%s> to <%s> (minimum non-null value is 1 ms)",
7899 args[1], args[0]);
7900 return -1;
7901 }
7902 else if (error) {
Thierry FOURNIERbd413492015-03-03 16:52:26 +01007903 memprintf(err, "%s: invalid timeout", args[0]);
7904 return -1;
7905 }
7906 return 0;
7907}
7908
7909static int hlua_session_timeout(char **args, int section_type, struct proxy *curpx,
7910 struct proxy *defpx, const char *file, int line,
7911 char **err)
7912{
7913 return hlua_read_timeout(args, section_type, curpx, defpx,
7914 file, line, err, &hlua_timeout_session);
7915}
7916
7917static int hlua_task_timeout(char **args, int section_type, struct proxy *curpx,
7918 struct proxy *defpx, const char *file, int line,
7919 char **err)
7920{
7921 return hlua_read_timeout(args, section_type, curpx, defpx,
7922 file, line, err, &hlua_timeout_task);
7923}
7924
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007925static int hlua_applet_timeout(char **args, int section_type, struct proxy *curpx,
7926 struct proxy *defpx, const char *file, int line,
7927 char **err)
7928{
7929 return hlua_read_timeout(args, section_type, curpx, defpx,
7930 file, line, err, &hlua_timeout_applet);
7931}
7932
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01007933static int hlua_forced_yield(char **args, int section_type, struct proxy *curpx,
7934 struct proxy *defpx, const char *file, int line,
7935 char **err)
7936{
7937 char *error;
7938
7939 hlua_nb_instruction = strtoll(args[1], &error, 10);
7940 if (*error != '\0') {
7941 memprintf(err, "%s: invalid number", args[0]);
7942 return -1;
7943 }
7944 return 0;
7945}
7946
Willy Tarreau32f61e22015-03-18 17:54:59 +01007947static int hlua_parse_maxmem(char **args, int section_type, struct proxy *curpx,
7948 struct proxy *defpx, const char *file, int line,
7949 char **err)
7950{
7951 char *error;
7952
7953 if (*(args[1]) == 0) {
7954 memprintf(err, "'%s' expects an integer argument (Lua memory size in MB).\n", args[0]);
7955 return -1;
7956 }
7957 hlua_global_allocator.limit = strtoll(args[1], &error, 10) * 1024L * 1024L;
7958 if (*error != '\0') {
7959 memprintf(err, "%s: invalid number %s (error at '%c')", args[0], args[1], *error);
7960 return -1;
7961 }
7962 return 0;
7963}
7964
7965
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01007966/* This function is called by the main configuration key "lua-load". It loads and
7967 * execute an lua file during the parsing of the HAProxy configuration file. It is
7968 * the main lua entry point.
7969 *
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08007970 * This function runs with the HAProxy keywords API. It returns -1 if an error
7971 * occurs, otherwise it returns 0.
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01007972 *
7973 * In some error case, LUA set an error message in top of the stack. This function
7974 * returns this error message in the HAProxy logs and pop it from the stack.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02007975 *
7976 * This function can fail with an abort() due to an Lua critical error.
7977 * We are in the configuration parsing process of HAProxy, this abort() is
7978 * tolerated.
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01007979 */
7980static int hlua_load(char **args, int section_type, struct proxy *curpx,
7981 struct proxy *defpx, const char *file, int line,
7982 char **err)
7983{
7984 int error;
7985
7986 /* Just load and compile the file. */
7987 error = luaL_loadfile(gL.T, args[1]);
7988 if (error) {
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007989 memprintf(err, "error in Lua file '%s': %s", args[1], lua_tostring(gL.T, -1));
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01007990 lua_pop(gL.T, 1);
7991 return -1;
7992 }
7993
7994 /* If no syntax error where detected, execute the code. */
7995 error = lua_pcall(gL.T, 0, LUA_MULTRET, 0);
7996 switch (error) {
7997 case LUA_OK:
7998 break;
7999 case LUA_ERRRUN:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008000 memprintf(err, "Lua runtime error: %s\n", lua_tostring(gL.T, -1));
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008001 lua_pop(gL.T, 1);
8002 return -1;
8003 case LUA_ERRMEM:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008004 memprintf(err, "Lua out of memory error.n");
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008005 return -1;
8006 case LUA_ERRERR:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008007 memprintf(err, "Lua message handler error: %s\n", lua_tostring(gL.T, -1));
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008008 lua_pop(gL.T, 1);
8009 return -1;
Christopher Faulet08ed98f2020-07-28 10:33:25 +02008010#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM <= 503
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008011 case LUA_ERRGCMM:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008012 memprintf(err, "Lua garbage collector error: %s\n", lua_tostring(gL.T, -1));
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008013 lua_pop(gL.T, 1);
8014 return -1;
Christopher Faulet08ed98f2020-07-28 10:33:25 +02008015#endif
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008016 default:
Ilya Shipitsind4259502020-04-08 01:07:56 +05008017 memprintf(err, "Lua unknown error: %s\n", lua_tostring(gL.T, -1));
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008018 lua_pop(gL.T, 1);
8019 return -1;
8020 }
8021
8022 return 0;
8023}
8024
Tim Duesterhusc9fc9f22020-01-12 13:55:39 +01008025/* Prepend the given <path> followed by a semicolon to the `package.<type>` variable
8026 * in the given <ctx>.
8027 */
8028static int hlua_prepend_path(struct hlua ctx, char *type, char *path)
8029{
8030 lua_getglobal(ctx.T, "package"); /* push package variable */
8031 lua_pushstring(ctx.T, path); /* push given path */
8032 lua_pushstring(ctx.T, ";"); /* push semicolon */
8033 lua_getfield(ctx.T, -3, type); /* push old path */
8034 lua_concat(ctx.T, 3); /* concatenate to new path */
8035 lua_setfield(ctx.T, -2, type); /* store new path */
8036 lua_pop(ctx.T, 1); /* pop package variable */
8037
8038 return 0;
8039}
8040
Tim Duesterhusdd74b5f2020-01-12 13:55:40 +01008041static int hlua_config_prepend_path(char **args, int section_type, struct proxy *curpx,
8042 struct proxy *defpx, const char *file, int line,
8043 char **err)
8044{
8045 char *path;
8046 char *type = "path";
8047 if (too_many_args(2, args, err, NULL)) {
8048 return -1;
8049 }
8050
8051 if (!(*args[1])) {
8052 memprintf(err, "'%s' expects to receive a <path> as argument", args[0]);
8053 return -1;
8054 }
8055 path = args[1];
8056
8057 if (*args[2]) {
8058 if (strcmp(args[2], "path") != 0 && strcmp(args[2], "cpath") != 0) {
8059 memprintf(err, "'%s' expects <type> to either be 'path' or 'cpath'", args[0]);
8060 return -1;
8061 }
8062 type = args[2];
8063 }
8064
8065 return hlua_prepend_path(gL, type, path);
8066}
8067
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008068/* configuration keywords declaration */
8069static struct cfg_kw_list cfg_kws = {{ },{
Tim Duesterhusdd74b5f2020-01-12 13:55:40 +01008070 { CFG_GLOBAL, "lua-prepend-path", hlua_config_prepend_path },
Thierry FOURNIERbd413492015-03-03 16:52:26 +01008071 { CFG_GLOBAL, "lua-load", hlua_load },
8072 { CFG_GLOBAL, "tune.lua.session-timeout", hlua_session_timeout },
8073 { CFG_GLOBAL, "tune.lua.task-timeout", hlua_task_timeout },
Thierry FOURNIER56da1012015-10-01 08:42:31 +02008074 { CFG_GLOBAL, "tune.lua.service-timeout", hlua_applet_timeout },
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01008075 { CFG_GLOBAL, "tune.lua.forced-yield", hlua_forced_yield },
Willy Tarreau32f61e22015-03-18 17:54:59 +01008076 { CFG_GLOBAL, "tune.lua.maxmem", hlua_parse_maxmem },
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008077 { 0, NULL, NULL },
8078}};
8079
Willy Tarreau0108d902018-11-25 19:14:37 +01008080INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
8081
Christopher Fauletafd8f102018-11-08 11:34:21 +01008082
Thierry FOURNIERbabae282015-09-17 11:36:37 +02008083/* This function can fail with an abort() due to an Lua critical error.
8084 * We are in the initialisation process of HAProxy, this abort() is
8085 * tolerated.
8086 */
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008087int hlua_post_init()
8088{
8089 struct hlua_init_function *init;
8090 const char *msg;
8091 enum hlua_exec ret;
Thierry Fournierfd107a22016-02-19 19:57:23 +01008092 const char *error;
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008093
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05008094 /* Call post initialisation function in safe environment. */
Thierry Fournier3d4a6752016-02-19 20:53:30 +01008095 if (!SET_SAFE_LJMP(gL.T)) {
8096 if (lua_type(gL.T, -1) == LUA_TSTRING)
8097 error = lua_tostring(gL.T, -1);
8098 else
8099 error = "critical error";
8100 fprintf(stderr, "Lua post-init: %s.\n", error);
8101 exit(1);
8102 }
Frédéric Lécaille54f2bcf2018-08-29 13:46:24 +02008103
8104#if USE_OPENSSL
8105 /* Initialize SSL server. */
8106 if (socket_ssl.xprt->prepare_srv) {
8107 int saved_used_backed = global.ssl_used_backend;
8108 // don't affect maxconn automatic computation
8109 socket_ssl.xprt->prepare_srv(&socket_ssl);
8110 global.ssl_used_backend = saved_used_backed;
8111 }
8112#endif
8113
Thierry Fournier3d4a6752016-02-19 20:53:30 +01008114 hlua_fcn_post_init(gL.T);
8115 RESET_SAFE_LJMP(gL.T);
8116
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008117 list_for_each_entry(init, &hlua_init_functions, l) {
8118 lua_rawgeti(gL.T, LUA_REGISTRYINDEX, init->function_ref);
8119 ret = hlua_ctx_resume(&gL, 0);
8120 switch (ret) {
8121 case HLUA_E_OK:
8122 lua_pop(gL.T, -1);
8123 return 1;
8124 case HLUA_E_AGAIN:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008125 ha_alert("Lua init: yield not allowed.\n");
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008126 return 0;
8127 case HLUA_E_ERRMSG:
8128 msg = lua_tostring(gL.T, -1);
Christopher Faulet767a84b2017-11-24 16:50:31 +01008129 ha_alert("lua init: %s.\n", msg);
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008130 return 0;
8131 case HLUA_E_ERR:
8132 default:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008133 ha_alert("Lua init: unknown runtime error.\n");
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008134 return 0;
8135 }
8136 }
8137 return 1;
8138}
8139
Willy Tarreau32f61e22015-03-18 17:54:59 +01008140/* The memory allocator used by the Lua stack. <ud> is a pointer to the
8141 * allocator's context. <ptr> is the pointer to alloc/free/realloc. <osize>
8142 * is the previously allocated size or the kind of object in case of a new
8143 * allocation. <nsize> is the requested new size.
8144 */
8145static void *hlua_alloc(void *ud, void *ptr, size_t osize, size_t nsize)
8146{
8147 struct hlua_mem_allocator *zone = ud;
8148
8149 if (nsize == 0) {
8150 /* it's a free */
8151 if (ptr)
8152 zone->allocated -= osize;
8153 free(ptr);
8154 return NULL;
8155 }
8156
8157 if (!ptr) {
8158 /* it's a new allocation */
8159 if (zone->limit && zone->allocated + nsize > zone->limit)
8160 return NULL;
8161
8162 ptr = malloc(nsize);
8163 if (ptr)
8164 zone->allocated += nsize;
8165 return ptr;
8166 }
8167
8168 /* it's a realloc */
8169 if (zone->limit && zone->allocated + nsize - osize > zone->limit)
8170 return NULL;
8171
8172 ptr = realloc(ptr, nsize);
8173 if (ptr)
8174 zone->allocated += nsize - osize;
8175 return ptr;
8176}
8177
Thierry FOURNIERbabae282015-09-17 11:36:37 +02008178/* Ithis function can fail with an abort() due to an Lua critical error.
8179 * We are in the initialisation process of HAProxy, this abort() is
8180 * tolerated.
8181 */
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +01008182void hlua_init(void)
8183{
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008184 int i;
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008185 int idx;
8186 struct sample_fetch *sf;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008187 struct sample_conv *sc;
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008188 char *p;
Thierry Fournierfd107a22016-02-19 19:57:23 +01008189 const char *error_msg;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01008190#ifdef USE_OPENSSL
Willy Tarreau80f5fae2015-02-27 16:38:20 +01008191 struct srv_kw *kw;
8192 int tmp_error;
8193 char *error;
Thierry FOURNIER36d13742015-03-17 16:48:53 +01008194 char *args[] = { /* SSL client configuration. */
8195 "ssl",
8196 "verify",
8197 "none",
Thierry FOURNIER36d13742015-03-17 16:48:53 +01008198 NULL
8199 };
Willy Tarreau80f5fae2015-02-27 16:38:20 +01008200#endif
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008201
Thierry FOURNIER380d0932015-01-23 14:27:52 +01008202 /* Init main lua stack. */
8203 gL.Mref = LUA_REFNIL;
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01008204 gL.flags = 0;
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +01008205 LIST_INIT(&gL.com);
Willy Tarreau42ef75f2017-04-12 21:40:29 +02008206 gL.T = lua_newstate(hlua_alloc, &hlua_global_allocator);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01008207 hlua_sethlua(&gL);
8208 gL.Tref = LUA_REFNIL;
8209 gL.task = NULL;
8210
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08008211 /* From this point, until the end of the initialisation function,
Thierry FOURNIERbabae282015-09-17 11:36:37 +02008212 * the Lua function can fail with an abort. We are in the initialisation
8213 * process of HAProxy, this abort() is tolerated.
8214 */
8215
Thierry FOURNIER380d0932015-01-23 14:27:52 +01008216 /* Initialise lua. */
8217 luaL_openlibs(gL.T);
Tim Duesterhus541fe1e2020-01-12 13:55:41 +01008218#define HLUA_PREPEND_PATH_TOSTRING1(x) #x
8219#define HLUA_PREPEND_PATH_TOSTRING(x) HLUA_PREPEND_PATH_TOSTRING1(x)
8220#ifdef HLUA_PREPEND_PATH
8221 hlua_prepend_path(gL, "path", HLUA_PREPEND_PATH_TOSTRING(HLUA_PREPEND_PATH));
8222#endif
8223#ifdef HLUA_PREPEND_CPATH
8224 hlua_prepend_path(gL, "cpath", HLUA_PREPEND_PATH_TOSTRING(HLUA_PREPEND_CPATH));
8225#endif
8226#undef HLUA_PREPEND_PATH_TOSTRING
8227#undef HLUA_PREPEND_PATH_TOSTRING1
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008228
Thierry Fournier75933d42016-01-21 09:30:18 +01008229 /* Set safe environment for the initialisation. */
8230 if (!SET_SAFE_LJMP(gL.T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01008231 if (lua_type(gL.T, -1) == LUA_TSTRING)
8232 error_msg = lua_tostring(gL.T, -1);
8233 else
8234 error_msg = "critical error";
8235 fprintf(stderr, "Lua init: %s.\n", error_msg);
Thierry Fournier75933d42016-01-21 09:30:18 +01008236 exit(1);
8237 }
8238
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008239 /*
8240 *
8241 * Create "core" object.
8242 *
8243 */
8244
Thierry FOURNIERa2d8c652015-03-11 17:29:39 +01008245 /* This table entry is the object "core" base. */
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008246 lua_newtable(gL.T);
8247
8248 /* Push the loglevel constants. */
Willy Tarreau80f5fae2015-02-27 16:38:20 +01008249 for (i = 0; i < NB_LOG_LEVELS; i++)
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008250 hlua_class_const_int(gL.T, log_levels[i], i);
8251
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008252 /* Register special functions. */
8253 hlua_class_function(gL.T, "register_init", hlua_register_init);
Thierry FOURNIER24f33532015-01-23 12:13:00 +01008254 hlua_class_function(gL.T, "register_task", hlua_register_task);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01008255 hlua_class_function(gL.T, "register_fetches", hlua_register_fetches);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01008256 hlua_class_function(gL.T, "register_converters", hlua_register_converters);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02008257 hlua_class_function(gL.T, "register_action", hlua_register_action);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008258 hlua_class_function(gL.T, "register_service", hlua_register_service);
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008259 hlua_class_function(gL.T, "register_cli", hlua_register_cli);
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01008260 hlua_class_function(gL.T, "yield", hlua_yield);
Willy Tarreau59551662015-03-10 14:23:13 +01008261 hlua_class_function(gL.T, "set_nice", hlua_set_nice);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01008262 hlua_class_function(gL.T, "sleep", hlua_sleep);
8263 hlua_class_function(gL.T, "msleep", hlua_msleep);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01008264 hlua_class_function(gL.T, "add_acl", hlua_add_acl);
8265 hlua_class_function(gL.T, "del_acl", hlua_del_acl);
8266 hlua_class_function(gL.T, "set_map", hlua_set_map);
8267 hlua_class_function(gL.T, "del_map", hlua_del_map);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008268 hlua_class_function(gL.T, "tcp", hlua_socket_new);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01008269 hlua_class_function(gL.T, "log", hlua_log);
8270 hlua_class_function(gL.T, "Debug", hlua_log_debug);
8271 hlua_class_function(gL.T, "Info", hlua_log_info);
8272 hlua_class_function(gL.T, "Warning", hlua_log_warning);
8273 hlua_class_function(gL.T, "Alert", hlua_log_alert);
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02008274 hlua_class_function(gL.T, "done", hlua_done);
Thierry Fournierfb0b5462016-01-21 09:28:58 +01008275 hlua_fcn_reg_core_fcn(gL.T);
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008276
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008277 lua_setglobal(gL.T, "core");
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01008278
8279 /*
8280 *
Christopher Faulet0f3c8902020-01-31 18:57:12 +01008281 * Create "act" object.
8282 *
8283 */
8284
8285 /* This table entry is the object "act" base. */
8286 lua_newtable(gL.T);
8287
8288 /* push action return constants */
8289 hlua_class_const_int(gL.T, "CONTINUE", ACT_RET_CONT);
8290 hlua_class_const_int(gL.T, "STOP", ACT_RET_STOP);
8291 hlua_class_const_int(gL.T, "YIELD", ACT_RET_YIELD);
8292 hlua_class_const_int(gL.T, "ERROR", ACT_RET_ERR);
8293 hlua_class_const_int(gL.T, "DONE", ACT_RET_DONE);
8294 hlua_class_const_int(gL.T, "DENY", ACT_RET_DENY);
8295 hlua_class_const_int(gL.T, "ABORT", ACT_RET_ABRT);
8296 hlua_class_const_int(gL.T, "INVALID", ACT_RET_INV);
8297
Christopher Faulet501465d2020-02-26 14:54:16 +01008298 hlua_class_function(gL.T, "wake_time", hlua_set_wake_time);
Christopher Faulet2c2c2e32020-01-31 19:07:52 +01008299
Christopher Faulet0f3c8902020-01-31 18:57:12 +01008300 lua_setglobal(gL.T, "act");
8301
8302 /*
8303 *
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008304 * Register class Map
8305 *
8306 */
8307
8308 /* This table entry is the object "Map" base. */
8309 lua_newtable(gL.T);
8310
8311 /* register pattern types. */
8312 for (i=0; i<PAT_MATCH_NUM; i++)
8313 hlua_class_const_int(gL.T, pat_match_names[i], i);
Thierry FOURNIER4dc71972017-01-28 08:33:08 +01008314 for (i=0; i<PAT_MATCH_NUM; i++) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008315 snprintf(trash.area, trash.size, "_%s", pat_match_names[i]);
8316 hlua_class_const_int(gL.T, trash.area, i);
Thierry FOURNIER4dc71972017-01-28 08:33:08 +01008317 }
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008318
8319 /* register constructor. */
8320 hlua_class_function(gL.T, "new", hlua_map_new);
8321
8322 /* Create and fill the metatable. */
8323 lua_newtable(gL.T);
8324
Ilya Shipitsind4259502020-04-08 01:07:56 +05008325 /* Create and fill the __index entry. */
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008326 lua_pushstring(gL.T, "__index");
8327 lua_newtable(gL.T);
8328
8329 /* Register . */
8330 hlua_class_function(gL.T, "lookup", hlua_map_lookup);
8331 hlua_class_function(gL.T, "slookup", hlua_map_slookup);
8332
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008333 lua_rawset(gL.T, -3);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008334
Thierry Fournier45e78d72016-02-19 18:34:46 +01008335 /* Register previous table in the registry with reference and named entry.
8336 * The function hlua_register_metatable() pops the stack, so we
8337 * previously create a copy of the table.
8338 */
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008339 lua_pushvalue(gL.T, -1); /* Copy the -1 entry and push it on the stack. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008340 class_map_ref = hlua_register_metatable(gL.T, CLASS_MAP);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008341
8342 /* Assign the metatable to the mai Map object. */
8343 lua_setmetatable(gL.T, -2);
8344
8345 /* Set a name to the table. */
8346 lua_setglobal(gL.T, "Map");
8347
8348 /*
8349 *
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008350 * Register class Channel
8351 *
8352 */
8353
8354 /* Create and fill the metatable. */
8355 lua_newtable(gL.T);
8356
Ilya Shipitsind4259502020-04-08 01:07:56 +05008357 /* Create and fill the __index entry. */
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008358 lua_pushstring(gL.T, "__index");
8359 lua_newtable(gL.T);
8360
8361 /* Register . */
8362 hlua_class_function(gL.T, "get", hlua_channel_get);
8363 hlua_class_function(gL.T, "dup", hlua_channel_dup);
8364 hlua_class_function(gL.T, "getline", hlua_channel_getline);
8365 hlua_class_function(gL.T, "set", hlua_channel_set);
8366 hlua_class_function(gL.T, "append", hlua_channel_append);
8367 hlua_class_function(gL.T, "send", hlua_channel_send);
8368 hlua_class_function(gL.T, "forward", hlua_channel_forward);
8369 hlua_class_function(gL.T, "get_in_len", hlua_channel_get_in_len);
8370 hlua_class_function(gL.T, "get_out_len", hlua_channel_get_out_len);
Thierry FOURNIER / OZON.IO65192f32016-11-07 15:28:40 +01008371 hlua_class_function(gL.T, "is_full", hlua_channel_is_full);
Christopher Faulet2ac9ba22020-02-25 10:15:50 +01008372 hlua_class_function(gL.T, "is_resp", hlua_channel_is_resp);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008373
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008374 lua_rawset(gL.T, -3);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008375
8376 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008377 class_channel_ref = hlua_register_metatable(gL.T, CLASS_CHANNEL);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008378
8379 /*
8380 *
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01008381 * Register class Fetches
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01008382 *
8383 */
8384
8385 /* Create and fill the metatable. */
8386 lua_newtable(gL.T);
8387
Ilya Shipitsind4259502020-04-08 01:07:56 +05008388 /* Create and fill the __index entry. */
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01008389 lua_pushstring(gL.T, "__index");
8390 lua_newtable(gL.T);
8391
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008392 /* Browse existing fetches and create the associated
8393 * object method.
8394 */
8395 sf = NULL;
8396 while ((sf = sample_fetch_getnext(sf, &idx)) != NULL) {
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008397 /* gL.Tua doesn't support '.' and '-' in the function names, replace it
8398 * by an underscore.
8399 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008400 strncpy(trash.area, sf->kw, trash.size);
8401 trash.area[trash.size - 1] = '\0';
8402 for (p = trash.area; *p; p++)
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008403 if (*p == '.' || *p == '-' || *p == '+')
8404 *p = '_';
8405
8406 /* Register the function. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008407 lua_pushstring(gL.T, trash.area);
Willy Tarreau2ec22742015-03-10 14:27:20 +01008408 lua_pushlightuserdata(gL.T, sf);
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008409 lua_pushcclosure(gL.T, hlua_run_sample_fetch, 1);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008410 lua_rawset(gL.T, -3);
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008411 }
8412
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008413 lua_rawset(gL.T, -3);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01008414
8415 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008416 class_fetches_ref = hlua_register_metatable(gL.T, CLASS_FETCHES);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01008417
8418 /*
8419 *
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008420 * Register class Converters
8421 *
8422 */
8423
8424 /* Create and fill the metatable. */
8425 lua_newtable(gL.T);
8426
8427 /* Create and fill the __index entry. */
8428 lua_pushstring(gL.T, "__index");
8429 lua_newtable(gL.T);
8430
8431 /* Browse existing converters and create the associated
8432 * object method.
8433 */
8434 sc = NULL;
8435 while ((sc = sample_conv_getnext(sc, &idx)) != NULL) {
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008436 /* gL.Tua doesn't support '.' and '-' in the function names, replace it
8437 * by an underscore.
8438 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008439 strncpy(trash.area, sc->kw, trash.size);
8440 trash.area[trash.size - 1] = '\0';
8441 for (p = trash.area; *p; p++)
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008442 if (*p == '.' || *p == '-' || *p == '+')
8443 *p = '_';
8444
8445 /* Register the function. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008446 lua_pushstring(gL.T, trash.area);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008447 lua_pushlightuserdata(gL.T, sc);
8448 lua_pushcclosure(gL.T, hlua_run_sample_conv, 1);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008449 lua_rawset(gL.T, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008450 }
8451
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008452 lua_rawset(gL.T, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008453
8454 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008455 class_converters_ref = hlua_register_metatable(gL.T, CLASS_CONVERTERS);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008456
8457 /*
8458 *
Thierry FOURNIER08504f42015-03-16 14:17:08 +01008459 * Register class HTTP
8460 *
8461 */
8462
8463 /* Create and fill the metatable. */
8464 lua_newtable(gL.T);
8465
Ilya Shipitsind4259502020-04-08 01:07:56 +05008466 /* Create and fill the __index entry. */
Thierry FOURNIER08504f42015-03-16 14:17:08 +01008467 lua_pushstring(gL.T, "__index");
8468 lua_newtable(gL.T);
8469
8470 /* Register Lua functions. */
8471 hlua_class_function(gL.T, "req_get_headers",hlua_http_req_get_headers);
8472 hlua_class_function(gL.T, "req_del_header", hlua_http_req_del_hdr);
8473 hlua_class_function(gL.T, "req_rep_header", hlua_http_req_rep_hdr);
8474 hlua_class_function(gL.T, "req_rep_value", hlua_http_req_rep_val);
8475 hlua_class_function(gL.T, "req_add_header", hlua_http_req_add_hdr);
8476 hlua_class_function(gL.T, "req_set_header", hlua_http_req_set_hdr);
8477 hlua_class_function(gL.T, "req_set_method", hlua_http_req_set_meth);
8478 hlua_class_function(gL.T, "req_set_path", hlua_http_req_set_path);
8479 hlua_class_function(gL.T, "req_set_query", hlua_http_req_set_query);
8480 hlua_class_function(gL.T, "req_set_uri", hlua_http_req_set_uri);
8481
8482 hlua_class_function(gL.T, "res_get_headers",hlua_http_res_get_headers);
8483 hlua_class_function(gL.T, "res_del_header", hlua_http_res_del_hdr);
8484 hlua_class_function(gL.T, "res_rep_header", hlua_http_res_rep_hdr);
8485 hlua_class_function(gL.T, "res_rep_value", hlua_http_res_rep_val);
8486 hlua_class_function(gL.T, "res_add_header", hlua_http_res_add_hdr);
8487 hlua_class_function(gL.T, "res_set_header", hlua_http_res_set_hdr);
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02008488 hlua_class_function(gL.T, "res_set_status", hlua_http_res_set_status);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01008489
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008490 lua_rawset(gL.T, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01008491
8492 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008493 class_http_ref = hlua_register_metatable(gL.T, CLASS_HTTP);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01008494
8495 /*
8496 *
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008497 * Register class AppletTCP
8498 *
8499 */
8500
8501 /* Create and fill the metatable. */
8502 lua_newtable(gL.T);
8503
Ilya Shipitsind4259502020-04-08 01:07:56 +05008504 /* Create and fill the __index entry. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008505 lua_pushstring(gL.T, "__index");
8506 lua_newtable(gL.T);
8507
8508 /* Register Lua functions. */
Thierry FOURNIER / OZON.IO3e1d7912016-12-12 12:29:34 +01008509 hlua_class_function(gL.T, "getline", hlua_applet_tcp_getline);
8510 hlua_class_function(gL.T, "receive", hlua_applet_tcp_recv);
8511 hlua_class_function(gL.T, "send", hlua_applet_tcp_send);
8512 hlua_class_function(gL.T, "set_priv", hlua_applet_tcp_set_priv);
8513 hlua_class_function(gL.T, "get_priv", hlua_applet_tcp_get_priv);
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01008514 hlua_class_function(gL.T, "set_var", hlua_applet_tcp_set_var);
8515 hlua_class_function(gL.T, "unset_var", hlua_applet_tcp_unset_var);
8516 hlua_class_function(gL.T, "get_var", hlua_applet_tcp_get_var);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008517
8518 lua_settable(gL.T, -3);
8519
8520 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008521 class_applet_tcp_ref = hlua_register_metatable(gL.T, CLASS_APPLET_TCP);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008522
8523 /*
8524 *
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02008525 * Register class AppletHTTP
8526 *
8527 */
8528
8529 /* Create and fill the metatable. */
8530 lua_newtable(gL.T);
8531
Ilya Shipitsind4259502020-04-08 01:07:56 +05008532 /* Create and fill the __index entry. */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02008533 lua_pushstring(gL.T, "__index");
8534 lua_newtable(gL.T);
8535
8536 /* Register Lua functions. */
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01008537 hlua_class_function(gL.T, "set_priv", hlua_applet_http_set_priv);
8538 hlua_class_function(gL.T, "get_priv", hlua_applet_http_get_priv);
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01008539 hlua_class_function(gL.T, "set_var", hlua_applet_http_set_var);
8540 hlua_class_function(gL.T, "unset_var", hlua_applet_http_unset_var);
8541 hlua_class_function(gL.T, "get_var", hlua_applet_http_get_var);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02008542 hlua_class_function(gL.T, "getline", hlua_applet_http_getline);
8543 hlua_class_function(gL.T, "receive", hlua_applet_http_recv);
8544 hlua_class_function(gL.T, "send", hlua_applet_http_send);
8545 hlua_class_function(gL.T, "add_header", hlua_applet_http_addheader);
8546 hlua_class_function(gL.T, "set_status", hlua_applet_http_status);
8547 hlua_class_function(gL.T, "start_response", hlua_applet_http_start_response);
8548
8549 lua_settable(gL.T, -3);
8550
8551 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008552 class_applet_http_ref = hlua_register_metatable(gL.T, CLASS_APPLET_HTTP);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02008553
8554 /*
8555 *
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01008556 * Register class TXN
8557 *
8558 */
8559
8560 /* Create and fill the metatable. */
8561 lua_newtable(gL.T);
8562
Ilya Shipitsind4259502020-04-08 01:07:56 +05008563 /* Create and fill the __index entry. */
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01008564 lua_pushstring(gL.T, "__index");
8565 lua_newtable(gL.T);
8566
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01008567 /* Register Lua functions. */
Patrick Hemmer268a7072018-05-11 12:52:31 -04008568 hlua_class_function(gL.T, "set_priv", hlua_set_priv);
8569 hlua_class_function(gL.T, "get_priv", hlua_get_priv);
8570 hlua_class_function(gL.T, "set_var", hlua_set_var);
8571 hlua_class_function(gL.T, "unset_var", hlua_unset_var);
8572 hlua_class_function(gL.T, "get_var", hlua_get_var);
8573 hlua_class_function(gL.T, "done", hlua_txn_done);
Christopher Faulet700d9e82020-01-31 12:21:52 +01008574 hlua_class_function(gL.T, "reply", hlua_txn_reply_new);
Patrick Hemmer268a7072018-05-11 12:52:31 -04008575 hlua_class_function(gL.T, "set_loglevel", hlua_txn_set_loglevel);
8576 hlua_class_function(gL.T, "set_tos", hlua_txn_set_tos);
8577 hlua_class_function(gL.T, "set_mark", hlua_txn_set_mark);
8578 hlua_class_function(gL.T, "set_priority_class", hlua_txn_set_priority_class);
8579 hlua_class_function(gL.T, "set_priority_offset", hlua_txn_set_priority_offset);
8580 hlua_class_function(gL.T, "deflog", hlua_txn_deflog);
8581 hlua_class_function(gL.T, "log", hlua_txn_log);
8582 hlua_class_function(gL.T, "Debug", hlua_txn_log_debug);
8583 hlua_class_function(gL.T, "Info", hlua_txn_log_info);
8584 hlua_class_function(gL.T, "Warning", hlua_txn_log_warning);
8585 hlua_class_function(gL.T, "Alert", hlua_txn_log_alert);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01008586
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008587 lua_rawset(gL.T, -3);
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01008588
8589 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008590 class_txn_ref = hlua_register_metatable(gL.T, CLASS_TXN);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008591
8592 /*
8593 *
Christopher Faulet700d9e82020-01-31 12:21:52 +01008594 * Register class reply
8595 *
8596 */
8597 lua_newtable(gL.T);
8598 lua_pushstring(gL.T, "__index");
8599 lua_newtable(gL.T);
8600 hlua_class_function(gL.T, "set_status", hlua_txn_reply_set_status);
8601 hlua_class_function(gL.T, "add_header", hlua_txn_reply_add_header);
8602 hlua_class_function(gL.T, "del_header", hlua_txn_reply_del_header);
8603 hlua_class_function(gL.T, "set_body", hlua_txn_reply_set_body);
8604 lua_settable(gL.T, -3); /* Sets the __index entry. */
8605 class_txn_reply_ref = luaL_ref(gL.T, LUA_REGISTRYINDEX);
8606
8607
8608 /*
8609 *
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008610 * Register class Socket
8611 *
8612 */
8613
8614 /* Create and fill the metatable. */
8615 lua_newtable(gL.T);
8616
Ilya Shipitsind4259502020-04-08 01:07:56 +05008617 /* Create and fill the __index entry. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008618 lua_pushstring(gL.T, "__index");
8619 lua_newtable(gL.T);
8620
Baptiste Assmann84bb4932015-03-02 21:40:06 +01008621#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008622 hlua_class_function(gL.T, "connect_ssl", hlua_socket_connect_ssl);
Baptiste Assmann84bb4932015-03-02 21:40:06 +01008623#endif
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008624 hlua_class_function(gL.T, "connect", hlua_socket_connect);
8625 hlua_class_function(gL.T, "send", hlua_socket_send);
8626 hlua_class_function(gL.T, "receive", hlua_socket_receive);
8627 hlua_class_function(gL.T, "close", hlua_socket_close);
8628 hlua_class_function(gL.T, "getpeername", hlua_socket_getpeername);
8629 hlua_class_function(gL.T, "getsockname", hlua_socket_getsockname);
8630 hlua_class_function(gL.T, "setoption", hlua_socket_setoption);
8631 hlua_class_function(gL.T, "settimeout", hlua_socket_settimeout);
8632
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008633 lua_rawset(gL.T, -3); /* Push the last 2 entries in the table at index -3 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008634
8635 /* Register the garbage collector entry. */
8636 lua_pushstring(gL.T, "__gc");
8637 lua_pushcclosure(gL.T, hlua_socket_gc, 0);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008638 lua_rawset(gL.T, -3); /* Push the last 2 entries in the table at index -3 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008639
8640 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008641 class_socket_ref = hlua_register_metatable(gL.T, CLASS_SOCKET);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008642
8643 /* Proxy and server configuration initialisation. */
8644 memset(&socket_proxy, 0, sizeof(socket_proxy));
8645 init_new_proxy(&socket_proxy);
8646 socket_proxy.parent = NULL;
8647 socket_proxy.last_change = now.tv_sec;
8648 socket_proxy.id = "LUA-SOCKET";
8649 socket_proxy.cap = PR_CAP_FE | PR_CAP_BE;
8650 socket_proxy.maxconn = 0;
8651 socket_proxy.accept = NULL;
8652 socket_proxy.options2 |= PR_O2_INDEPSTR;
8653 socket_proxy.srv = NULL;
8654 socket_proxy.conn_retries = 0;
8655 socket_proxy.timeout.connect = 5000; /* By default the timeout connection is 5s. */
8656
8657 /* Init TCP server: unchanged parameters */
8658 memset(&socket_tcp, 0, sizeof(socket_tcp));
8659 socket_tcp.next = NULL;
8660 socket_tcp.proxy = &socket_proxy;
8661 socket_tcp.obj_type = OBJ_TYPE_SERVER;
8662 LIST_INIT(&socket_tcp.actconns);
Patrick Hemmer0355dab2018-05-11 12:52:31 -04008663 socket_tcp.pendconns = EB_ROOT;
Christopher Faulet40a007c2017-07-03 15:41:01 +02008664 socket_tcp.idle_conns = NULL;
8665 socket_tcp.safe_conns = NULL;
Emeric Brun52a91d32017-08-31 14:41:55 +02008666 socket_tcp.next_state = SRV_ST_RUNNING; /* early server setup */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008667 socket_tcp.last_change = 0;
8668 socket_tcp.id = "LUA-TCP-CONN";
8669 socket_tcp.check.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
8670 socket_tcp.agent.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
8671 socket_tcp.pp_opts = 0; /* Remove proxy protocol. */
8672
8673 /* XXX: Copy default parameter from default server,
8674 * but the default server is not initialized.
8675 */
8676 socket_tcp.maxqueue = socket_proxy.defsrv.maxqueue;
8677 socket_tcp.minconn = socket_proxy.defsrv.minconn;
8678 socket_tcp.maxconn = socket_proxy.defsrv.maxconn;
8679 socket_tcp.slowstart = socket_proxy.defsrv.slowstart;
8680 socket_tcp.onerror = socket_proxy.defsrv.onerror;
8681 socket_tcp.onmarkeddown = socket_proxy.defsrv.onmarkeddown;
8682 socket_tcp.onmarkedup = socket_proxy.defsrv.onmarkedup;
8683 socket_tcp.consecutive_errors_limit = socket_proxy.defsrv.consecutive_errors_limit;
8684 socket_tcp.uweight = socket_proxy.defsrv.iweight;
8685 socket_tcp.iweight = socket_proxy.defsrv.iweight;
8686
8687 socket_tcp.check.status = HCHK_STATUS_INI;
8688 socket_tcp.check.rise = socket_proxy.defsrv.check.rise;
8689 socket_tcp.check.fall = socket_proxy.defsrv.check.fall;
8690 socket_tcp.check.health = socket_tcp.check.rise; /* socket, but will fall down at first failure */
8691 socket_tcp.check.server = &socket_tcp;
8692
8693 socket_tcp.agent.status = HCHK_STATUS_INI;
8694 socket_tcp.agent.rise = socket_proxy.defsrv.agent.rise;
8695 socket_tcp.agent.fall = socket_proxy.defsrv.agent.fall;
8696 socket_tcp.agent.health = socket_tcp.agent.rise; /* socket, but will fall down at first failure */
8697 socket_tcp.agent.server = &socket_tcp;
8698
Willy Tarreaua261e9b2016-12-22 20:44:00 +01008699 socket_tcp.xprt = xprt_get(XPRT_RAW);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008700
8701#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008702 /* Init TCP server: unchanged parameters */
8703 memset(&socket_ssl, 0, sizeof(socket_ssl));
8704 socket_ssl.next = NULL;
8705 socket_ssl.proxy = &socket_proxy;
8706 socket_ssl.obj_type = OBJ_TYPE_SERVER;
8707 LIST_INIT(&socket_ssl.actconns);
Patrick Hemmer0355dab2018-05-11 12:52:31 -04008708 socket_ssl.pendconns = EB_ROOT;
Willy Tarreaub784b352019-02-07 14:48:24 +01008709 socket_ssl.idle_conns = NULL;
8710 socket_ssl.safe_conns = NULL;
Emeric Brun52a91d32017-08-31 14:41:55 +02008711 socket_ssl.next_state = SRV_ST_RUNNING; /* early server setup */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008712 socket_ssl.last_change = 0;
8713 socket_ssl.id = "LUA-SSL-CONN";
8714 socket_ssl.check.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
8715 socket_ssl.agent.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
8716 socket_ssl.pp_opts = 0; /* Remove proxy protocol. */
8717
8718 /* XXX: Copy default parameter from default server,
8719 * but the default server is not initialized.
8720 */
8721 socket_ssl.maxqueue = socket_proxy.defsrv.maxqueue;
8722 socket_ssl.minconn = socket_proxy.defsrv.minconn;
8723 socket_ssl.maxconn = socket_proxy.defsrv.maxconn;
8724 socket_ssl.slowstart = socket_proxy.defsrv.slowstart;
8725 socket_ssl.onerror = socket_proxy.defsrv.onerror;
8726 socket_ssl.onmarkeddown = socket_proxy.defsrv.onmarkeddown;
8727 socket_ssl.onmarkedup = socket_proxy.defsrv.onmarkedup;
8728 socket_ssl.consecutive_errors_limit = socket_proxy.defsrv.consecutive_errors_limit;
8729 socket_ssl.uweight = socket_proxy.defsrv.iweight;
8730 socket_ssl.iweight = socket_proxy.defsrv.iweight;
8731
8732 socket_ssl.check.status = HCHK_STATUS_INI;
8733 socket_ssl.check.rise = socket_proxy.defsrv.check.rise;
8734 socket_ssl.check.fall = socket_proxy.defsrv.check.fall;
8735 socket_ssl.check.health = socket_ssl.check.rise; /* socket, but will fall down at first failure */
8736 socket_ssl.check.server = &socket_ssl;
8737
8738 socket_ssl.agent.status = HCHK_STATUS_INI;
8739 socket_ssl.agent.rise = socket_proxy.defsrv.agent.rise;
8740 socket_ssl.agent.fall = socket_proxy.defsrv.agent.fall;
8741 socket_ssl.agent.health = socket_ssl.agent.rise; /* socket, but will fall down at first failure */
8742 socket_ssl.agent.server = &socket_ssl;
8743
Thierry FOURNIER36d13742015-03-17 16:48:53 +01008744 socket_ssl.use_ssl = 1;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01008745 socket_ssl.xprt = xprt_get(XPRT_SSL);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008746
Thierry FOURNIER36d13742015-03-17 16:48:53 +01008747 for (idx = 0; args[idx] != NULL; idx++) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008748 if ((kw = srv_find_kw(args[idx])) != NULL) { /* Maybe it's registered server keyword */
8749 /*
8750 *
8751 * If the keyword is not known, we can search in the registered
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08008752 * server keywords. This is useful to configure special SSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008753 * features like client certificates and ssl_verify.
8754 *
8755 */
8756 tmp_error = kw->parse(args, &idx, &socket_proxy, &socket_ssl, &error);
8757 if (tmp_error != 0) {
8758 fprintf(stderr, "INTERNAL ERROR: %s\n", error);
8759 abort(); /* This must be never arrives because the command line
8760 not editable by the user. */
8761 }
8762 idx += kw->skip;
8763 }
8764 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008765#endif
Thierry Fournier75933d42016-01-21 09:30:18 +01008766
8767 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +01008768}
Willy Tarreaubb57d942016-12-21 19:04:56 +01008769
Tim Duesterhusd0c0ca22020-07-04 11:53:26 +02008770static void hlua_deinit()
8771{
8772 lua_close(gL.T);
8773}
8774
8775REGISTER_POST_DEINIT(hlua_deinit);
8776
Willy Tarreau80713382018-11-26 10:19:54 +01008777static void hlua_register_build_options(void)
8778{
Willy Tarreaubb57d942016-12-21 19:04:56 +01008779 char *ptr = NULL;
Willy Tarreau80713382018-11-26 10:19:54 +01008780
Willy Tarreaubb57d942016-12-21 19:04:56 +01008781 memprintf(&ptr, "Built with Lua version : %s", LUA_RELEASE);
8782 hap_register_build_opts(ptr, 1);
8783}
Willy Tarreau80713382018-11-26 10:19:54 +01008784
8785INITCALL0(STG_REGISTER, hlua_register_build_options);