blob: ff5ffba553e035e0b8967573a8df640b4c64e613 [file] [log] [blame]
Thierry Fourniere726b142016-02-11 17:57:57 +01001/*
2 * Lua unsafe core engine
3 *
4 * Copyright 2015-2016 Thierry Fournier <tfournier@arpalert.org>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +010013#include <ctype.h>
Mark Lakes56cc1252018-03-27 09:48:06 +020014#include <limits.h>
Thierry FOURNIERbabae282015-09-17 11:36:37 +020015#include <setjmp.h>
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +010016
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +010017#include <lauxlib.h>
18#include <lua.h>
19#include <lualib.h>
20
Thierry FOURNIER463119c2015-03-10 00:35:36 +010021#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 503
22#error "Requires Lua 5.3 or later."
Cyril Bontédc0306e2015-03-02 00:08:40 +010023#endif
24
Thierry FOURNIER380d0932015-01-23 14:27:52 +010025#include <ebpttree.h>
26
27#include <common/cfgparse.h>
Willy Tarreaub059b892018-10-16 17:57:36 +020028#include <common/compiler.h>
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +020029#include <common/hathreads.h>
Willy Tarreau0108d902018-11-25 19:14:37 +010030#include <common/initcall.h>
31#include <common/xref.h>
Christopher Faulet724a12c2018-12-13 22:12:15 +010032#include <common/h1.h>
Thierry FOURNIER380d0932015-01-23 14:27:52 +010033
William Lallemand9ed62032016-11-21 17:49:11 +010034#include <types/cli.h>
Thierry FOURNIER380d0932015-01-23 14:27:52 +010035#include <types/hlua.h>
36#include <types/proxy.h>
William Lallemand9ed62032016-11-21 17:49:11 +010037#include <types/stats.h>
Thierry FOURNIER380d0932015-01-23 14:27:52 +010038
Thierry FOURNIER55da1652015-01-23 11:36:30 +010039#include <proto/arg.h>
Willy Tarreau8a8d83b2015-04-13 13:24:54 +020040#include <proto/applet.h>
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010041#include <proto/channel.h>
William Lallemand9ed62032016-11-21 17:49:11 +010042#include <proto/cli.h>
Willy Tarreaua71f6422016-11-16 17:00:14 +010043#include <proto/connection.h>
William Lallemand9ed62032016-11-21 17:49:11 +010044#include <proto/stats.h>
Thierry FOURNIER9a819e72015-02-16 20:22:55 +010045#include <proto/hdr_idx.h>
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +010046#include <proto/hlua.h>
Thierry Fournierfb0b5462016-01-21 09:28:58 +010047#include <proto/hlua_fcn.h>
Willy Tarreau79e57332018-10-02 16:01:16 +020048#include <proto/http_fetch.h>
Christopher Faulet724a12c2018-12-13 22:12:15 +010049#include <proto/http_htx.h>
Willy Tarreau61c112a2018-10-02 16:43:32 +020050#include <proto/http_rules.h>
Thierry FOURNIER3def3932015-04-07 11:27:54 +020051#include <proto/map.h>
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010052#include <proto/obj_type.h>
Patrick Hemmer268a7072018-05-11 12:52:31 -040053#include <proto/queue.h>
Thierry FOURNIER83758bb2015-02-04 13:21:04 +010054#include <proto/pattern.h>
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +010055#include <proto/payload.h>
56#include <proto/proto_http.h>
57#include <proto/sample.h>
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010058#include <proto/server.h>
Willy Tarreaufeb76402015-04-03 14:10:06 +020059#include <proto/session.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020060#include <proto/stream.h>
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +010061#include <proto/stream_interface.h>
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +010062#include <proto/task.h>
Willy Tarreau39713102016-11-25 15:49:32 +010063#include <proto/tcp_rules.h>
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +020064#include <proto/vars.h>
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +010065
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +010066/* Lua uses longjmp to perform yield or throwing errors. This
67 * macro is used only for identifying the function that can
68 * not return because a longjmp is executed.
69 * __LJMP marks a prototype of hlua file that can use longjmp.
70 * WILL_LJMP() marks an lua function that will use longjmp.
71 * MAY_LJMP() marks an lua function that may use longjmp.
72 */
73#define __LJMP
Willy Tarreau4e7cc332018-10-20 17:45:48 +020074#define WILL_LJMP(func) do { func; my_unreachable(); } while(0)
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +010075#define MAY_LJMP(func) func
76
Thierry FOURNIERbabae282015-09-17 11:36:37 +020077/* This couple of function executes securely some Lua calls outside of
78 * the lua runtime environment. Each Lua call can return a longjmp
79 * if it encounter a memory error.
80 *
81 * Lua documentation extract:
82 *
83 * If an error happens outside any protected environment, Lua calls
84 * a panic function (see lua_atpanic) and then calls abort, thus
85 * exiting the host application. Your panic function can avoid this
86 * exit by never returning (e.g., doing a long jump to your own
87 * recovery point outside Lua).
88 *
89 * The panic function runs as if it were a message handler (see
90 * §2.3); in particular, the error message is at the top of the
91 * stack. However, there is no guarantee about stack space. To push
92 * anything on the stack, the panic function must first check the
93 * available space (see §4.2).
94 *
95 * We must check all the Lua entry point. This includes:
96 * - The include/proto/hlua.h exported functions
97 * - the task wrapper function
98 * - The action wrapper function
99 * - The converters wrapper function
100 * - The sample-fetch wrapper functions
101 *
102 * It is tolerated that the initilisation function returns an abort.
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -0800103 * Before each Lua abort, an error message is written on stderr.
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200104 *
105 * The macro SET_SAFE_LJMP initialise the longjmp. The Macro
106 * RESET_SAFE_LJMP reset the longjmp. These function must be macro
107 * because they must be exists in the program stack when the longjmp
108 * is called.
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +0200109 *
110 * Note that the Lua processing is not really thread safe. It provides
111 * heavy system which consists to add our own lock function in the Lua
112 * code and recompile the library. This system will probably not accepted
113 * by maintainers of various distribs.
114 *
115 * Our main excution point of the Lua is the function lua_resume(). A
116 * quick looking on the Lua sources displays a lua_lock() a the start
117 * of function and a lua_unlock() at the end of the function. So I
118 * conclude that the Lua thread safe mode just perform a mutex around
119 * all execution. So I prefer to do this in the HAProxy code, it will be
120 * easier for distro maintainers.
121 *
122 * Note that the HAProxy lua functions rounded by the macro SET_SAFE_LJMP
123 * and RESET_SAFE_LJMP manipulates the Lua stack, so it will be careful
124 * to set mutex around these functions.
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200125 */
Willy Tarreau86abe442018-11-25 20:12:18 +0100126__decl_spinlock(hlua_global_lock);
Thierry FOURNIERffbad792017-07-12 11:39:04 +0200127THREAD_LOCAL jmp_buf safe_ljmp_env;
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200128static int hlua_panic_safe(lua_State *L) { return 0; }
129static int hlua_panic_ljmp(lua_State *L) { longjmp(safe_ljmp_env, 1); }
130
131#define SET_SAFE_LJMP(__L) \
132 ({ \
133 int ret; \
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100134 HA_SPIN_LOCK(LUA_LOCK, &hlua_global_lock); \
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200135 if (setjmp(safe_ljmp_env) != 0) { \
136 lua_atpanic(__L, hlua_panic_safe); \
137 ret = 0; \
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100138 HA_SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock); \
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200139 } else { \
140 lua_atpanic(__L, hlua_panic_ljmp); \
141 ret = 1; \
142 } \
143 ret; \
144 })
145
146/* If we are the last function catching Lua errors, we
147 * must reset the panic function.
148 */
149#define RESET_SAFE_LJMP(__L) \
150 do { \
151 lua_atpanic(__L, hlua_panic_safe); \
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100152 HA_SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock); \
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200153 } while(0)
154
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200155/* Applet status flags */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200156#define APPLET_DONE 0x01 /* applet processing is done. */
Christopher Faulet18c2e8d2019-03-01 12:02:08 +0100157/* unused: 0x02 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200158#define APPLET_HDR_SENT 0x04 /* Response header sent. */
159#define APPLET_CHUNKED 0x08 /* Use transfer encoding chunked. */
160#define APPLET_LAST_CHK 0x10 /* Last chunk sent. */
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +0100161#define APPLET_HTTP11 0x20 /* Last chunk sent. */
Christopher Faulet56a3d6e2019-02-27 22:06:23 +0100162#define APPLET_RSP_SENT 0x40 /* The response was fully sent */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200163
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100164/* The main Lua execution context. */
165struct hlua gL;
166
Thierry FOURNIERebed6e92016-12-16 11:54:07 +0100167/* This is the memory pool containing struct lua for applets
168 * (including cli).
169 */
Willy Tarreau8ceae722018-11-26 11:58:30 +0100170DECLARE_STATIC_POOL(pool_head_hlua, "hlua", sizeof(struct hlua));
Thierry FOURNIERebed6e92016-12-16 11:54:07 +0100171
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +0100172/* Used for Socket connection. */
173static struct proxy socket_proxy;
174static struct server socket_tcp;
175#ifdef USE_OPENSSL
176static struct server socket_ssl;
177#endif
178
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +0100179/* List head of the function called at the initialisation time. */
180struct list hlua_init_functions = LIST_HEAD_INIT(hlua_init_functions);
181
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +0100182/* The following variables contains the reference of the different
183 * Lua classes. These references are useful for identify metadata
184 * associated with an object.
185 */
Thierry FOURNIER65f34c62015-02-16 20:11:43 +0100186static int class_txn_ref;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +0100187static int class_socket_ref;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +0100188static int class_channel_ref;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +0100189static int class_fetches_ref;
Thierry FOURNIER594afe72015-03-10 23:58:30 +0100190static int class_converters_ref;
Thierry FOURNIER08504f42015-03-16 14:17:08 +0100191static int class_http_ref;
Thierry FOURNIER3def3932015-04-07 11:27:54 +0200192static int class_map_ref;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200193static int class_applet_tcp_ref;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200194static int class_applet_http_ref;
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +0100195
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100196/* Global Lua execution timeout. By default Lua, execution linked
Willy Tarreau87b09662015-04-03 00:22:06 +0200197 * with stream (actions, sample-fetches and converters) have a
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100198 * short timeout. Lua linked with tasks doesn't have a timeout
199 * because a task may remain alive during all the haproxy execution.
200 */
201static unsigned int hlua_timeout_session = 4000; /* session timeout. */
202static unsigned int hlua_timeout_task = TICK_ETERNITY; /* task timeout. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +0200203static unsigned int hlua_timeout_applet = 4000; /* applet timeout. */
Thierry FOURNIERbd413492015-03-03 16:52:26 +0100204
Thierry FOURNIERee9f8022015-03-03 17:37:37 +0100205/* Interrupts the Lua processing each "hlua_nb_instruction" instructions.
206 * it is used for preventing infinite loops.
207 *
208 * I test the scheer with an infinite loop containing one incrementation
209 * and one test. I run this loop between 10 seconds, I raise a ceil of
210 * 710M loops from one interrupt each 9000 instructions, so I fix the value
211 * to one interrupt each 10 000 instructions.
212 *
213 * configured | Number of
214 * instructions | loops executed
215 * between two | in milions
216 * forced yields |
217 * ---------------+---------------
218 * 10 | 160
219 * 500 | 670
220 * 1000 | 680
221 * 5000 | 700
222 * 7000 | 700
223 * 8000 | 700
224 * 9000 | 710 <- ceil
225 * 10000 | 710
226 * 100000 | 710
227 * 1000000 | 710
228 *
229 */
230static unsigned int hlua_nb_instruction = 10000;
231
Willy Tarreau32f61e22015-03-18 17:54:59 +0100232/* Descriptor for the memory allocation state. If limit is not null, it will
233 * be enforced on any memory allocation.
234 */
235struct hlua_mem_allocator {
236 size_t allocated;
237 size_t limit;
238};
239
240static struct hlua_mem_allocator hlua_global_allocator;
241
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200242static const char error_500[] =
Jarno Huuskonen16ad94a2017-01-09 14:17:10 +0200243 "HTTP/1.0 500 Internal Server Error\r\n"
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200244 "Cache-Control: no-cache\r\n"
245 "Connection: close\r\n"
246 "Content-Type: text/html\r\n"
247 "\r\n"
Joseph Herlant7fe15772018-11-15 10:07:32 -0800248 "<html><body><h1>500 Internal Server Error</h1>\nAn internal server error occurred.\n</body></html>\n";
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200249
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100250/* These functions converts types between HAProxy internal args or
251 * sample and LUA types. Another function permits to check if the
252 * LUA stack contains arguments according with an required ARG_T
253 * format.
254 */
255static int hlua_arg2lua(lua_State *L, const struct arg *arg);
256static int hlua_lua2arg(lua_State *L, int ud, struct arg *arg);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100257__LJMP static int hlua_lua2arg_check(lua_State *L, int first, struct arg *argp,
David Carlier0c437f42016-04-27 16:21:56 +0100258 uint64_t mask, struct proxy *p);
Willy Tarreau5eadada2015-03-10 17:28:54 +0100259static int hlua_smp2lua(lua_State *L, struct sample *smp);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100260static int hlua_smp2lua_str(lua_State *L, struct sample *smp);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100261static int hlua_lua2smp(lua_State *L, int ud, struct sample *smp);
262
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200263__LJMP static int hlua_http_get_headers(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg);
264
Thierry FOURNIER23bc3752015-09-11 19:15:43 +0200265#define SEND_ERR(__be, __fmt, __args...) \
266 do { \
267 send_log(__be, LOG_ERR, __fmt, ## __args); \
268 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) \
Christopher Faulet767a84b2017-11-24 16:50:31 +0100269 ha_alert(__fmt, ## __args); \
Thierry FOURNIER23bc3752015-09-11 19:15:43 +0200270 } while (0)
271
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100272/* Used to check an Lua function type in the stack. It creates and
273 * returns a reference of the function. This function throws an
274 * error if the rgument is not a "function".
275 */
276__LJMP unsigned int hlua_checkfunction(lua_State *L, int argno)
277{
278 if (!lua_isfunction(L, argno)) {
Thierry FOURNIERfd1e9552018-02-23 18:41:18 +0100279 const char *msg = lua_pushfstring(L, "function expected, got %s", luaL_typename(L, argno));
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100280 WILL_LJMP(luaL_argerror(L, argno, msg));
281 }
282 lua_pushvalue(L, argno);
283 return luaL_ref(L, LUA_REGISTRYINDEX);
284}
285
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +0200286/* Return the string that is of the top of the stack. */
287const char *hlua_get_top_error_string(lua_State *L)
288{
289 if (lua_gettop(L) < 1)
290 return "unknown error";
291 if (lua_type(L, -1) != LUA_TSTRING)
292 return "unknown error";
293 return lua_tostring(L, -1);
294}
295
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200296__LJMP static const char *hlua_traceback(lua_State *L)
297{
298 lua_Debug ar;
299 int level = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +0200300 struct buffer *msg = get_trash_chunk();
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200301 int filled = 0;
302
303 while (lua_getstack(L, level++, &ar)) {
304
305 /* Add separator */
306 if (filled)
307 chunk_appendf(msg, ", ");
308 filled = 1;
309
310 /* Fill fields:
311 * 'S': fills in the fields source, short_src, linedefined, lastlinedefined, and what;
312 * 'l': fills in the field currentline;
313 * 'n': fills in the field name and namewhat;
314 * 't': fills in the field istailcall;
315 */
316 lua_getinfo(L, "Slnt", &ar);
317
318 /* Append code localisation */
319 if (ar.currentline > 0)
320 chunk_appendf(msg, "%s:%d ", ar.short_src, ar.currentline);
321 else
322 chunk_appendf(msg, "%s ", ar.short_src);
323
324 /*
325 * Get function name
326 *
327 * if namewhat is no empty, name is defined.
328 * what contains "Lua" for Lua function, "C" for C function,
329 * or "main" for main code.
330 */
331 if (*ar.namewhat != '\0' && ar.name != NULL) /* is there a name from code? */
332 chunk_appendf(msg, "%s '%s'", ar.namewhat, ar.name); /* use it */
333
334 else if (*ar.what == 'm') /* "main", the code is not executed in a function */
335 chunk_appendf(msg, "main chunk");
336
337 else if (*ar.what != 'C') /* for Lua functions, use <file:line> */
338 chunk_appendf(msg, "C function line %d", ar.linedefined);
339
340 else /* nothing left... */
341 chunk_appendf(msg, "?");
342
343
344 /* Display tailed call */
345 if (ar.istailcall)
346 chunk_appendf(msg, " ...");
347 }
348
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200349 return msg->area;
Thierry FOURNIERfc044c92018-06-07 14:40:48 +0200350}
351
352
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100353/* This function check the number of arguments available in the
354 * stack. If the number of arguments available is not the same
355 * then <nb> an error is throwed.
356 */
357__LJMP static inline void check_args(lua_State *L, int nb, char *fcn)
358{
359 if (lua_gettop(L) == nb)
360 return;
361 WILL_LJMP(luaL_error(L, "'%s' needs %d arguments", fcn, nb));
362}
363
Mark Lakes22154b42018-01-29 14:38:40 -0800364/* This function pushes an error string prefixed by the file name
Thierry FOURNIERe8b9a402015-02-25 18:48:12 +0100365 * and the line number where the error is encountered.
366 */
367static int hlua_pusherror(lua_State *L, const char *fmt, ...)
368{
369 va_list argp;
370 va_start(argp, fmt);
371 luaL_where(L, 1);
372 lua_pushvfstring(L, fmt, argp);
373 va_end(argp);
374 lua_concat(L, 2);
375 return 1;
376}
377
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100378/* This functions is used with sample fetch and converters. It
379 * converts the HAProxy configuration argument in a lua stack
380 * values.
381 *
382 * It takes an array of "arg", and each entry of the array is
383 * converted and pushed in the LUA stack.
384 */
385static int hlua_arg2lua(lua_State *L, const struct arg *arg)
386{
387 switch (arg->type) {
388 case ARGT_SINT:
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100389 case ARGT_TIME:
390 case ARGT_SIZE:
Thierry FOURNIERf90838b2015-03-06 13:48:32 +0100391 lua_pushinteger(L, arg->data.sint);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100392 break;
393
394 case ARGT_STR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200395 lua_pushlstring(L, arg->data.str.area, arg->data.str.data);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100396 break;
397
398 case ARGT_IPV4:
399 case ARGT_IPV6:
400 case ARGT_MSK4:
401 case ARGT_MSK6:
402 case ARGT_FE:
403 case ARGT_BE:
404 case ARGT_TAB:
405 case ARGT_SRV:
406 case ARGT_USR:
407 case ARGT_MAP:
408 default:
409 lua_pushnil(L);
410 break;
411 }
412 return 1;
413}
414
415/* This function take one entrie in an LUA stack at the index "ud",
416 * and try to convert it in an HAProxy argument entry. This is useful
417 * with sample fetch wrappers. The input arguments are gived to the
418 * lua wrapper and converted as arg list by thi function.
419 */
420static int hlua_lua2arg(lua_State *L, int ud, struct arg *arg)
421{
422 switch (lua_type(L, ud)) {
423
424 case LUA_TNUMBER:
425 case LUA_TBOOLEAN:
426 arg->type = ARGT_SINT;
427 arg->data.sint = lua_tointeger(L, ud);
428 break;
429
430 case LUA_TSTRING:
431 arg->type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200432 arg->data.str.area = (char *)lua_tolstring(L, ud, (size_t *)&arg->data.str.data);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100433 break;
434
435 case LUA_TUSERDATA:
436 case LUA_TNIL:
437 case LUA_TTABLE:
438 case LUA_TFUNCTION:
439 case LUA_TTHREAD:
440 case LUA_TLIGHTUSERDATA:
441 arg->type = ARGT_SINT;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +0200442 arg->data.sint = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100443 break;
444 }
445 return 1;
446}
447
448/* the following functions are used to convert a struct sample
449 * in Lua type. This useful to convert the return of the
450 * fetchs or converters.
451 */
Willy Tarreau5eadada2015-03-10 17:28:54 +0100452static int hlua_smp2lua(lua_State *L, struct sample *smp)
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100453{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200454 switch (smp->data.type) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100455 case SMP_T_SINT:
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100456 case SMP_T_BOOL:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200457 lua_pushinteger(L, smp->data.u.sint);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100458 break;
459
460 case SMP_T_BIN:
461 case SMP_T_STR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200462 lua_pushlstring(L, smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100463 break;
464
465 case SMP_T_METH:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200466 switch (smp->data.u.meth.meth) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100467 case HTTP_METH_OPTIONS: lua_pushstring(L, "OPTIONS"); break;
468 case HTTP_METH_GET: lua_pushstring(L, "GET"); break;
469 case HTTP_METH_HEAD: lua_pushstring(L, "HEAD"); break;
470 case HTTP_METH_POST: lua_pushstring(L, "POST"); break;
471 case HTTP_METH_PUT: lua_pushstring(L, "PUT"); break;
472 case HTTP_METH_DELETE: lua_pushstring(L, "DELETE"); break;
473 case HTTP_METH_TRACE: lua_pushstring(L, "TRACE"); break;
474 case HTTP_METH_CONNECT: lua_pushstring(L, "CONNECT"); break;
475 case HTTP_METH_OTHER:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200476 lua_pushlstring(L, smp->data.u.meth.str.area, smp->data.u.meth.str.data);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100477 break;
478 default:
479 lua_pushnil(L);
480 break;
481 }
482 break;
483
484 case SMP_T_IPV4:
485 case SMP_T_IPV6:
486 case SMP_T_ADDR: /* This type is never used to qualify a sample. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200487 if (sample_casts[smp->data.type][SMP_T_STR] &&
488 sample_casts[smp->data.type][SMP_T_STR](smp))
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200489 lua_pushlstring(L, smp->data.u.str.area, smp->data.u.str.data);
Willy Tarreau5eadada2015-03-10 17:28:54 +0100490 else
491 lua_pushnil(L);
492 break;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100493 default:
494 lua_pushnil(L);
495 break;
496 }
497 return 1;
498}
499
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100500/* the following functions are used to convert a struct sample
501 * in Lua strings. This is useful to convert the return of the
502 * fetchs or converters.
503 */
504static int hlua_smp2lua_str(lua_State *L, struct sample *smp)
505{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200506 switch (smp->data.type) {
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100507
508 case SMP_T_BIN:
509 case SMP_T_STR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200510 lua_pushlstring(L, smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100511 break;
512
513 case SMP_T_METH:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200514 switch (smp->data.u.meth.meth) {
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100515 case HTTP_METH_OPTIONS: lua_pushstring(L, "OPTIONS"); break;
516 case HTTP_METH_GET: lua_pushstring(L, "GET"); break;
517 case HTTP_METH_HEAD: lua_pushstring(L, "HEAD"); break;
518 case HTTP_METH_POST: lua_pushstring(L, "POST"); break;
519 case HTTP_METH_PUT: lua_pushstring(L, "PUT"); break;
520 case HTTP_METH_DELETE: lua_pushstring(L, "DELETE"); break;
521 case HTTP_METH_TRACE: lua_pushstring(L, "TRACE"); break;
522 case HTTP_METH_CONNECT: lua_pushstring(L, "CONNECT"); break;
523 case HTTP_METH_OTHER:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200524 lua_pushlstring(L, smp->data.u.meth.str.area, smp->data.u.meth.str.data);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100525 break;
526 default:
527 lua_pushstring(L, "");
528 break;
529 }
530 break;
531
532 case SMP_T_SINT:
533 case SMP_T_BOOL:
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100534 case SMP_T_IPV4:
535 case SMP_T_IPV6:
536 case SMP_T_ADDR: /* This type is never used to qualify a sample. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200537 if (sample_casts[smp->data.type][SMP_T_STR] &&
538 sample_casts[smp->data.type][SMP_T_STR](smp))
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200539 lua_pushlstring(L, smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +0100540 else
541 lua_pushstring(L, "");
542 break;
543 default:
544 lua_pushstring(L, "");
545 break;
546 }
547 return 1;
548}
549
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100550/* the following functions are used to convert an Lua type in a
551 * struct sample. This is useful to provide data from a converter
552 * to the LUA code.
553 */
554static int hlua_lua2smp(lua_State *L, int ud, struct sample *smp)
555{
556 switch (lua_type(L, ud)) {
557
558 case LUA_TNUMBER:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200559 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200560 smp->data.u.sint = lua_tointeger(L, ud);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100561 break;
562
563
564 case LUA_TBOOLEAN:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200565 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200566 smp->data.u.sint = lua_toboolean(L, ud);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100567 break;
568
569 case LUA_TSTRING:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200570 smp->data.type = SMP_T_STR;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100571 smp->flags |= SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200572 smp->data.u.str.area = (char *)lua_tolstring(L, ud, (size_t *)&smp->data.u.str.data);
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100573 break;
574
575 case LUA_TUSERDATA:
576 case LUA_TNIL:
577 case LUA_TTABLE:
578 case LUA_TFUNCTION:
579 case LUA_TTHREAD:
580 case LUA_TLIGHTUSERDATA:
Thierry FOURNIER93405e12015-08-26 14:19:03 +0200581 case LUA_TNONE:
582 default:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200583 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200584 smp->data.u.sint = 0;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100585 break;
586 }
587 return 1;
588}
589
590/* This function check the "argp" builded by another conversion function
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -0800591 * is in accord with the expected argp defined by the "mask". The function
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100592 * returns true or false. It can be adjust the types if there compatibles.
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100593 *
594 * This function assumes thant the argp argument contains ARGM_NBARGS + 1
595 * entries.
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100596 */
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100597__LJMP int hlua_lua2arg_check(lua_State *L, int first, struct arg *argp,
David Carlier0c437f42016-04-27 16:21:56 +0100598 uint64_t mask, struct proxy *p)
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100599{
600 int min_arg;
601 int idx;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100602 struct proxy *px;
603 char *sname, *pname;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100604
605 idx = 0;
606 min_arg = ARGM(mask);
607 mask >>= ARGM_BITS;
608
609 while (1) {
610
611 /* Check oversize. */
612 if (idx >= ARGM_NBARGS && argp[idx].type != ARGT_STOP) {
Cyril Bonté577a36a2015-03-02 00:08:38 +0100613 WILL_LJMP(luaL_argerror(L, first + idx, "Malformed argument mask"));
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100614 }
615
616 /* Check for mandatory arguments. */
617 if (argp[idx].type == ARGT_STOP) {
Thierry FOURNIER3caa0392015-03-13 13:38:17 +0100618 if (idx < min_arg) {
619
620 /* If miss other argument than the first one, we return an error. */
621 if (idx > 0)
622 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
623
624 /* If first argument have a certain type, some default values
625 * may be used. See the function smp_resolve_args().
626 */
627 switch (mask & ARGT_MASK) {
628
629 case ARGT_FE:
630 if (!(p->cap & PR_CAP_FE))
631 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
632 argp[idx].data.prx = p;
633 argp[idx].type = ARGT_FE;
634 argp[idx+1].type = ARGT_STOP;
635 break;
636
637 case ARGT_BE:
638 if (!(p->cap & PR_CAP_BE))
639 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
640 argp[idx].data.prx = p;
641 argp[idx].type = ARGT_BE;
642 argp[idx+1].type = ARGT_STOP;
643 break;
644
645 case ARGT_TAB:
646 argp[idx].data.prx = p;
647 argp[idx].type = ARGT_TAB;
648 argp[idx+1].type = ARGT_STOP;
649 break;
650
651 default:
652 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
653 break;
654 }
655 }
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100656 return 0;
657 }
658
659 /* Check for exceed the number of requiered argument. */
660 if ((mask & ARGT_MASK) == ARGT_STOP &&
661 argp[idx].type != ARGT_STOP) {
662 WILL_LJMP(luaL_argerror(L, first + idx, "Last argument expected"));
663 }
664
665 if ((mask & ARGT_MASK) == ARGT_STOP &&
666 argp[idx].type == ARGT_STOP) {
667 return 0;
668 }
669
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100670 /* Convert some argument types. */
671 switch (mask & ARGT_MASK) {
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100672 case ARGT_SINT:
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100673 if (argp[idx].type != ARGT_SINT)
674 WILL_LJMP(luaL_argerror(L, first + idx, "integer expected"));
675 argp[idx].type = ARGT_SINT;
676 break;
677
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100678 case ARGT_TIME:
679 if (argp[idx].type != ARGT_SINT)
680 WILL_LJMP(luaL_argerror(L, first + idx, "integer expected"));
Thierry FOURNIER29176f32015-07-07 00:41:29 +0200681 argp[idx].type = ARGT_TIME;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100682 break;
683
684 case ARGT_SIZE:
685 if (argp[idx].type != ARGT_SINT)
686 WILL_LJMP(luaL_argerror(L, first + idx, "integer expected"));
Thierry FOURNIER29176f32015-07-07 00:41:29 +0200687 argp[idx].type = ARGT_SIZE;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100688 break;
689
690 case ARGT_FE:
691 if (argp[idx].type != ARGT_STR)
692 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200693 memcpy(trash.area, argp[idx].data.str.area,
694 argp[idx].data.str.data);
695 trash.area[argp[idx].data.str.data] = 0;
696 argp[idx].data.prx = proxy_fe_by_name(trash.area);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100697 if (!argp[idx].data.prx)
698 WILL_LJMP(luaL_argerror(L, first + idx, "frontend doesn't exist"));
699 argp[idx].type = ARGT_FE;
700 break;
701
702 case ARGT_BE:
703 if (argp[idx].type != ARGT_STR)
704 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200705 memcpy(trash.area, argp[idx].data.str.area,
706 argp[idx].data.str.data);
707 trash.area[argp[idx].data.str.data] = 0;
708 argp[idx].data.prx = proxy_be_by_name(trash.area);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100709 if (!argp[idx].data.prx)
710 WILL_LJMP(luaL_argerror(L, first + idx, "backend doesn't exist"));
711 argp[idx].type = ARGT_BE;
712 break;
713
714 case ARGT_TAB:
715 if (argp[idx].type != ARGT_STR)
716 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200717 memcpy(trash.area, argp[idx].data.str.area,
718 argp[idx].data.str.data);
719 trash.area[argp[idx].data.str.data] = 0;
720 argp[idx].data.prx = proxy_tbl_by_name(trash.area);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100721 if (!argp[idx].data.prx)
722 WILL_LJMP(luaL_argerror(L, first + idx, "table doesn't exist"));
723 argp[idx].type = ARGT_TAB;
724 break;
725
726 case ARGT_SRV:
727 if (argp[idx].type != ARGT_STR)
728 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200729 memcpy(trash.area, argp[idx].data.str.area,
730 argp[idx].data.str.data);
731 trash.area[argp[idx].data.str.data] = 0;
732 sname = strrchr(trash.area, '/');
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100733 if (sname) {
734 *sname++ = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200735 pname = trash.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +0200736 px = proxy_be_by_name(pname);
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100737 if (!px)
738 WILL_LJMP(luaL_argerror(L, first + idx, "backend doesn't exist"));
739 }
740 else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200741 sname = trash.area;
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100742 px = p;
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100743 }
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100744 argp[idx].data.srv = findserver(px, sname);
745 if (!argp[idx].data.srv)
746 WILL_LJMP(luaL_argerror(L, first + idx, "server doesn't exist"));
747 argp[idx].type = ARGT_SRV;
748 break;
749
750 case ARGT_IPV4:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200751 memcpy(trash.area, argp[idx].data.str.area,
752 argp[idx].data.str.data);
753 trash.area[argp[idx].data.str.data] = 0;
754 if (inet_pton(AF_INET, trash.area, &argp[idx].data.ipv4))
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100755 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv4 address"));
756 argp[idx].type = ARGT_IPV4;
757 break;
758
759 case ARGT_MSK4:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200760 memcpy(trash.area, argp[idx].data.str.area,
761 argp[idx].data.str.data);
762 trash.area[argp[idx].data.str.data] = 0;
763 if (!str2mask(trash.area, &argp[idx].data.ipv4))
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100764 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv4 mask"));
765 argp[idx].type = ARGT_MSK4;
766 break;
767
768 case ARGT_IPV6:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200769 memcpy(trash.area, argp[idx].data.str.area,
770 argp[idx].data.str.data);
771 trash.area[argp[idx].data.str.data] = 0;
772 if (inet_pton(AF_INET6, trash.area, &argp[idx].data.ipv6))
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100773 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv6 address"));
774 argp[idx].type = ARGT_IPV6;
775 break;
776
777 case ARGT_MSK6:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200778 memcpy(trash.area, argp[idx].data.str.area,
779 argp[idx].data.str.data);
780 trash.area[argp[idx].data.str.data] = 0;
781 if (!str2mask6(trash.area, &argp[idx].data.ipv6))
Tim Duesterhusb814da62018-01-25 16:24:50 +0100782 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv6 mask"));
783 argp[idx].type = ARGT_MSK6;
784 break;
785
Thierry FOURNIER7f4942a2015-03-12 18:28:50 +0100786 case ARGT_MAP:
787 case ARGT_REG:
788 case ARGT_USR:
789 WILL_LJMP(luaL_argerror(L, first + idx, "type not yet supported"));
Thierry FOURNIER55da1652015-01-23 11:36:30 +0100790 break;
791 }
792
793 /* Check for type of argument. */
794 if ((mask & ARGT_MASK) != argp[idx].type) {
795 const char *msg = lua_pushfstring(L, "'%s' expected, got '%s'",
796 arg_type_names[(mask & ARGT_MASK)],
797 arg_type_names[argp[idx].type & ARGT_MASK]);
798 WILL_LJMP(luaL_argerror(L, first + idx, msg));
799 }
800
801 /* Next argument. */
802 mask >>= ARGT_BITS;
803 idx++;
804 }
805}
806
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100807/*
808 * The following functions are used to make correspondance between the the
809 * executed lua pointer and the "struct hlua *" that contain the context.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100810 *
811 * - hlua_gethlua : return the hlua context associated with an lua_State.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100812 * - hlua_sethlua : create the association between hlua context and lua_state.
813 */
814static inline struct hlua *hlua_gethlua(lua_State *L)
815{
Thierry FOURNIER38c5fd62015-03-10 02:40:29 +0100816 struct hlua **hlua = lua_getextraspace(L);
817 return *hlua;
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100818}
819static inline void hlua_sethlua(struct hlua *hlua)
820{
Thierry FOURNIER38c5fd62015-03-10 02:40:29 +0100821 struct hlua **hlua_store = lua_getextraspace(hlua->T);
822 *hlua_store = hlua;
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100823}
824
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100825/* This function is used to send logs. It try to send on screen (stderr)
826 * and on the default syslog server.
827 */
828static inline void hlua_sendlog(struct proxy *px, int level, const char *msg)
829{
830 struct tm tm;
831 char *p;
832
833 /* Cleanup the log message. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200834 p = trash.area;
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100835 for (; *msg != '\0'; msg++, p++) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200836 if (p >= trash.area + trash.size - 1) {
Thierry FOURNIERccf00632015-09-16 12:47:03 +0200837 /* Break the message if exceed the buffer size. */
838 *(p-4) = ' ';
839 *(p-3) = '.';
840 *(p-2) = '.';
841 *(p-1) = '.';
842 break;
843 }
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100844 if (isprint(*msg))
845 *p = *msg;
846 else
847 *p = '.';
848 }
849 *p = '\0';
850
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200851 send_log(px, level, "%s\n", trash.area);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100852 if (!(global.mode & MODE_QUIET) || (global.mode & (MODE_VERBOSE | MODE_STARTING))) {
Willy Tarreaua678b432015-08-28 10:14:59 +0200853 get_localtime(date.tv_sec, &tm);
854 fprintf(stderr, "[%s] %03d/%02d%02d%02d (%d) : %s\n",
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100855 log_levels[level], tm.tm_yday, tm.tm_hour, tm.tm_min, tm.tm_sec,
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200856 (int)getpid(), trash.area);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +0100857 fflush(stderr);
858 }
859}
860
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100861/* This function just ensure that the yield will be always
862 * returned with a timeout and permit to set some flags
863 */
864__LJMP void hlua_yieldk(lua_State *L, int nresults, int ctx,
Thierry FOURNIERf90838b2015-03-06 13:48:32 +0100865 lua_KFunction k, int timeout, unsigned int flags)
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100866{
867 struct hlua *hlua = hlua_gethlua(L);
868
869 /* Set the wake timeout. If timeout is required, we set
870 * the expiration time.
871 */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +0200872 hlua->wake_time = timeout;
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100873
Thierry FOURNIER4abd3ae2015-03-03 17:29:06 +0100874 hlua->flags |= flags;
875
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100876 /* Process the yield. */
Willy Tarreau9635e032018-10-16 17:52:55 +0200877 MAY_LJMP(lua_yieldk(L, nresults, ctx, k));
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +0100878}
879
Willy Tarreau87b09662015-04-03 00:22:06 +0200880/* This function initialises the Lua environment stored in the stream.
881 * It must be called at the start of the stream. This function creates
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100882 * an LUA coroutine. It can not be use to crete the main LUA context.
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200883 *
884 * This function is particular. it initialises a new Lua thread. If the
885 * initialisation fails (example: out of memory error), the lua function
886 * throws an error (longjmp).
887 *
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +0100888 * In some case (at least one), this function can be called from safe
889 * environement, so we must not initialise it. While the support of
890 * threads appear, the safe environment set a lock to ensure only one
891 * Lua execution at a time. If we initialize safe environment in another
892 * safe environmenet, we have a dead lock.
893 *
894 * set "already_safe" true if the context is initialized form safe
895 * Lua fonction.
896 *
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -0800897 * This function manipulates two Lua stacks: the main and the thread. Only
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200898 * the main stack can fail. The thread is not manipulated. This function
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -0800899 * MUST NOT manipulate the created thread stack state, because it is not
900 * proctected against errors thrown by the thread stack.
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100901 */
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +0100902int hlua_ctx_init(struct hlua *lua, struct task *task, int already_safe)
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100903{
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +0100904 if (!already_safe) {
905 if (!SET_SAFE_LJMP(gL.T)) {
906 lua->Tref = LUA_REFNIL;
907 return 0;
908 }
Thierry FOURNIERbabae282015-09-17 11:36:37 +0200909 }
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100910 lua->Mref = LUA_REFNIL;
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +0100911 lua->flags = 0;
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100912 LIST_INIT(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100913 lua->T = lua_newthread(gL.T);
914 if (!lua->T) {
915 lua->Tref = LUA_REFNIL;
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +0100916 if (!already_safe)
917 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100918 return 0;
919 }
920 hlua_sethlua(lua);
921 lua->Tref = luaL_ref(gL.T, LUA_REGISTRYINDEX);
922 lua->task = task;
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +0100923 if (!already_safe)
924 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100925 return 1;
926}
927
Willy Tarreau87b09662015-04-03 00:22:06 +0200928/* Used to destroy the Lua coroutine when the attached stream or task
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100929 * is destroyed. The destroy also the memory context. The struct "lua"
930 * is not freed.
931 */
932void hlua_ctx_destroy(struct hlua *lua)
933{
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +0100934 if (!lua)
Thierry FOURNIERa718b292015-03-04 16:48:34 +0100935 return;
936
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +0100937 if (!lua->T)
938 goto end;
939
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100940 /* Purge all the pending signals. */
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200941 notification_purge(&lua->com);
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +0100942
Thierry FOURNIER75d02082017-07-12 13:41:33 +0200943 if (!SET_SAFE_LJMP(lua->T))
944 return;
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100945 luaL_unref(lua->T, LUA_REGISTRYINDEX, lua->Mref);
Thierry FOURNIER75d02082017-07-12 13:41:33 +0200946 RESET_SAFE_LJMP(lua->T);
Thierry FOURNIER5a50a852015-09-23 16:59:28 +0200947
Thierry FOURNIER75d02082017-07-12 13:41:33 +0200948 if (!SET_SAFE_LJMP(gL.T))
949 return;
950 luaL_unref(gL.T, LUA_REGISTRYINDEX, lua->Tref);
951 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER5a50a852015-09-23 16:59:28 +0200952 /* Forces a garbage collecting process. If the Lua program is finished
953 * without error, we run the GC on the thread pointer. Its freed all
954 * the unused memory.
955 * If the thread is finnish with an error or is currently yielded,
956 * it seems that the GC applied on the thread doesn't clean anything,
957 * so e run the GC on the main thread.
958 * NOTE: maybe this action locks all the Lua threads untiml the en of
959 * the garbage collection.
960 */
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +0200961 if (lua->flags & HLUA_MUST_GC) {
Thierry FOURNIER7bd10d52017-07-17 00:44:40 +0200962 if (!SET_SAFE_LJMP(gL.T))
Thierry FOURNIER75d02082017-07-12 13:41:33 +0200963 return;
Thierry FOURNIER7bd10d52017-07-17 00:44:40 +0200964 lua_gc(gL.T, LUA_GCCOLLECT, 0);
965 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +0200966 }
Thierry FOURNIER5a50a852015-09-23 16:59:28 +0200967
Thierry FOURNIERa7b536b2015-09-21 22:50:24 +0200968 lua->T = NULL;
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +0100969
970end:
Willy Tarreaubafbe012017-11-24 17:34:44 +0100971 pool_free(pool_head_hlua, lua);
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100972}
973
974/* This function is used to restore the Lua context when a coroutine
975 * fails. This function copy the common memory between old coroutine
976 * and the new coroutine. The old coroutine is destroyed, and its
977 * replaced by the new coroutine.
978 * If the flag "keep_msg" is set, the last entry of the old is assumed
979 * as string error message and it is copied in the new stack.
980 */
981static int hlua_ctx_renew(struct hlua *lua, int keep_msg)
982{
983 lua_State *T;
984 int new_ref;
985
986 /* Renew the main LUA stack doesn't have sense. */
987 if (lua == &gL)
988 return 0;
989
Thierry FOURNIER380d0932015-01-23 14:27:52 +0100990 /* New Lua coroutine. */
991 T = lua_newthread(gL.T);
992 if (!T)
993 return 0;
994
995 /* Copy last error message. */
996 if (keep_msg)
997 lua_xmove(lua->T, T, 1);
998
999 /* Copy data between the coroutines. */
1000 lua_rawgeti(lua->T, LUA_REGISTRYINDEX, lua->Mref);
1001 lua_xmove(lua->T, T, 1);
1002 new_ref = luaL_ref(T, LUA_REGISTRYINDEX); /* Valur poped. */
1003
1004 /* Destroy old data. */
1005 luaL_unref(lua->T, LUA_REGISTRYINDEX, lua->Mref);
1006
1007 /* The thread is garbage collected by Lua. */
1008 luaL_unref(gL.T, LUA_REGISTRYINDEX, lua->Tref);
1009
1010 /* Fill the struct with the new coroutine values. */
1011 lua->Mref = new_ref;
1012 lua->T = T;
1013 lua->Tref = luaL_ref(gL.T, LUA_REGISTRYINDEX);
1014
1015 /* Set context. */
1016 hlua_sethlua(lua);
1017
1018 return 1;
1019}
1020
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001021void hlua_hook(lua_State *L, lua_Debug *ar)
1022{
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001023 struct hlua *hlua = hlua_gethlua(L);
1024
1025 /* Lua cannot yield when its returning from a function,
1026 * so, we can fix the interrupt hook to 1 instruction,
1027 * expecting that the function is finnished.
1028 */
1029 if (lua_gethookmask(L) & LUA_MASKRET) {
1030 lua_sethook(hlua->T, hlua_hook, LUA_MASKCOUNT, 1);
1031 return;
1032 }
1033
1034 /* restore the interrupt condition. */
1035 lua_sethook(hlua->T, hlua_hook, LUA_MASKCOUNT, hlua_nb_instruction);
1036
1037 /* If we interrupt the Lua processing in yieldable state, we yield.
1038 * If the state is not yieldable, trying yield causes an error.
1039 */
1040 if (lua_isyieldable(L))
Willy Tarreau9635e032018-10-16 17:52:55 +02001041 MAY_LJMP(hlua_yieldk(L, 0, 0, NULL, TICK_ETERNITY, HLUA_CTRLYIELD));
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001042
Thierry FOURNIERa85cfb12015-03-13 14:50:06 +01001043 /* If we cannot yield, update the clock and check the timeout. */
1044 tv_update_date(0, 1);
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001045 hlua->run_time += now_ms - hlua->start_time;
1046 if (hlua->max_time && hlua->run_time >= hlua->max_time) {
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001047 lua_pushfstring(L, "execution timeout");
1048 WILL_LJMP(lua_error(L));
1049 }
1050
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001051 /* Update the start time. */
1052 hlua->start_time = now_ms;
1053
Thierry FOURNIERcae49c92015-03-06 14:05:24 +01001054 /* Try to interrupt the process at the end of the current
1055 * unyieldable function.
1056 */
1057 lua_sethook(hlua->T, hlua_hook, LUA_MASKRET|LUA_MASKCOUNT, hlua_nb_instruction);
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001058}
1059
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001060/* This function start or resumes the Lua stack execution. If the flag
1061 * "yield_allowed" if no set and the LUA stack execution returns a yield
1062 * The function return an error.
1063 *
1064 * The function can returns 4 values:
1065 * - HLUA_E_OK : The execution is terminated without any errors.
1066 * - HLUA_E_AGAIN : The execution must continue at the next associated
1067 * task wakeup.
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001068 * - HLUA_E_ERRMSG : An error has occurred, an error message is set in
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001069 * the top of the stack.
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001070 * - HLUA_E_ERR : An error has occurred without error message.
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001071 *
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001072 * If an error occurred, the stack is renewed and it is ready to run new
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001073 * LUA code.
1074 */
1075static enum hlua_exec hlua_ctx_resume(struct hlua *lua, int yield_allowed)
1076{
1077 int ret;
1078 const char *msg;
Thierry FOURNIERfc044c92018-06-07 14:40:48 +02001079 const char *trace;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001080
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001081 /* Initialise run time counter. */
1082 if (!HLUA_IS_RUNNING(lua))
1083 lua->run_time = 0;
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001084
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +02001085 /* Lock the whole Lua execution. This lock must be before the
1086 * label "resume_execution".
1087 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001088 HA_SPIN_LOCK(LUA_LOCK, &hlua_global_lock);
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +02001089
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001090resume_execution:
1091
1092 /* This hook interrupts the Lua processing each 'hlua_nb_instruction'
1093 * instructions. it is used for preventing infinite loops.
1094 */
1095 lua_sethook(lua->T, hlua_hook, LUA_MASKCOUNT, hlua_nb_instruction);
1096
Thierry FOURNIER1bfc09b2015-03-05 17:10:14 +01001097 /* Remove all flags except the running flags. */
Thierry FOURNIER2f3867f2015-09-28 01:02:01 +02001098 HLUA_SET_RUN(lua);
1099 HLUA_CLR_CTRLYIELD(lua);
1100 HLUA_CLR_WAKERESWR(lua);
1101 HLUA_CLR_WAKEREQWR(lua);
Thierry FOURNIER1bfc09b2015-03-05 17:10:14 +01001102
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001103 /* Update the start time. */
1104 lua->start_time = now_ms;
1105
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001106 /* Call the function. */
1107 ret = lua_resume(lua->T, gL.T, lua->nargs);
1108 switch (ret) {
1109
1110 case LUA_OK:
1111 ret = HLUA_E_OK;
1112 break;
1113
1114 case LUA_YIELD:
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001115 /* Check if the execution timeout is expired. It it is the case, we
1116 * break the Lua execution.
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001117 */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02001118 tv_update_date(0, 1);
1119 lua->run_time += now_ms - lua->start_time;
1120 if (lua->max_time && lua->run_time > lua->max_time) {
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001121 lua_settop(lua->T, 0); /* Empty the stack. */
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001122 ret = HLUA_E_ETMOUT;
Thierry FOURNIERdc9ca962015-03-05 11:16:52 +01001123 break;
1124 }
1125 /* Process the forced yield. if the general yield is not allowed or
1126 * if no task were associated this the current Lua execution
1127 * coroutine, we resume the execution. Else we want to return in the
1128 * scheduler and we want to be waked up again, to continue the
1129 * current Lua execution. So we schedule our own task.
1130 */
1131 if (HLUA_IS_CTRLYIELDING(lua)) {
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001132 if (!yield_allowed || !lua->task)
1133 goto resume_execution;
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001134 task_wakeup(lua->task, TASK_WOKEN_MSG);
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01001135 }
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001136 if (!yield_allowed) {
1137 lua_settop(lua->T, 0); /* Empty the stack. */
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001138 ret = HLUA_E_YIELD;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001139 break;
1140 }
1141 ret = HLUA_E_AGAIN;
1142 break;
1143
1144 case LUA_ERRRUN:
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001145
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001146 /* Special exit case. The traditional exit is returned as an error
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001147 * because the errors ares the only one mean to return immediately
1148 * from and lua execution.
1149 */
1150 if (lua->flags & HLUA_EXIT) {
1151 ret = HLUA_E_OK;
Thierry FOURNIERe1587b32015-08-28 09:54:13 +02001152 hlua_ctx_renew(lua, 0);
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001153 break;
1154 }
1155
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001156 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001157 if (!lua_checkstack(lua->T, 1)) {
1158 ret = HLUA_E_ERR;
1159 break;
1160 }
1161 msg = lua_tostring(lua->T, -1);
1162 lua_settop(lua->T, 0); /* Empty the stack. */
1163 lua_pop(lua->T, 1);
Thierry FOURNIERfc044c92018-06-07 14:40:48 +02001164 trace = hlua_traceback(lua->T);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001165 if (msg)
Thierry FOURNIERfc044c92018-06-07 14:40:48 +02001166 lua_pushfstring(lua->T, "runtime error: %s from %s", msg, trace);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001167 else
Thierry FOURNIERfc044c92018-06-07 14:40:48 +02001168 lua_pushfstring(lua->T, "unknown runtime error from %s", trace);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001169 ret = HLUA_E_ERRMSG;
1170 break;
1171
1172 case LUA_ERRMEM:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001173 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001174 lua_settop(lua->T, 0); /* Empty the stack. */
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001175 ret = HLUA_E_NOMEM;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001176 break;
1177
1178 case LUA_ERRERR:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001179 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001180 if (!lua_checkstack(lua->T, 1)) {
1181 ret = HLUA_E_ERR;
1182 break;
1183 }
1184 msg = lua_tostring(lua->T, -1);
1185 lua_settop(lua->T, 0); /* Empty the stack. */
1186 lua_pop(lua->T, 1);
1187 if (msg)
1188 lua_pushfstring(lua->T, "message handler error: %s", msg);
1189 else
1190 lua_pushfstring(lua->T, "message handler error");
1191 ret = HLUA_E_ERRMSG;
1192 break;
1193
1194 default:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01001195 lua->wake_time = TICK_ETERNITY;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001196 lua_settop(lua->T, 0); /* Empty the stack. */
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001197 ret = HLUA_E_ERR;
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001198 break;
1199 }
1200
Thierry FOURNIER6ab4d8e2015-09-27 22:17:19 +02001201 /* This GC permits to destroy some object when a Lua timeout strikes. */
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +02001202 if (lua->flags & HLUA_MUST_GC &&
1203 ret != HLUA_E_AGAIN)
Thierry FOURNIER6ab4d8e2015-09-27 22:17:19 +02001204 lua_gc(lua->T, LUA_GCCOLLECT, 0);
1205
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001206 switch (ret) {
1207 case HLUA_E_AGAIN:
1208 break;
1209
1210 case HLUA_E_ERRMSG:
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001211 notification_purge(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001212 hlua_ctx_renew(lua, 1);
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001213 HLUA_CLR_RUN(lua);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001214 break;
1215
Thierry Fournierd5b073c2018-05-21 19:42:47 +02001216 case HLUA_E_ETMOUT:
1217 case HLUA_E_NOMEM:
1218 case HLUA_E_YIELD:
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001219 case HLUA_E_ERR:
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001220 HLUA_CLR_RUN(lua);
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001221 notification_purge(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001222 hlua_ctx_renew(lua, 0);
1223 break;
1224
1225 case HLUA_E_OK:
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01001226 HLUA_CLR_RUN(lua);
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001227 notification_purge(&lua->com);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001228 break;
1229 }
1230
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +02001231 /* This is the main exit point, remove the Lua lock. */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001232 HA_SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock);
Thierry FOURNIER61ba0e22017-07-12 11:41:21 +02001233
Thierry FOURNIER380d0932015-01-23 14:27:52 +01001234 return ret;
1235}
1236
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02001237/* This function exit the current code. */
1238__LJMP static int hlua_done(lua_State *L)
1239{
1240 struct hlua *hlua = hlua_gethlua(L);
1241
1242 hlua->flags |= HLUA_EXIT;
1243 WILL_LJMP(lua_error(L));
1244
1245 return 0;
1246}
1247
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001248/* This function is an LUA binding. It provides a function
1249 * for deleting ACL from a referenced ACL file.
1250 */
1251__LJMP static int hlua_del_acl(lua_State *L)
1252{
1253 const char *name;
1254 const char *key;
1255 struct pat_ref *ref;
1256
1257 MAY_LJMP(check_args(L, 2, "del_acl"));
1258
1259 name = MAY_LJMP(luaL_checkstring(L, 1));
1260 key = MAY_LJMP(luaL_checkstring(L, 2));
1261
1262 ref = pat_ref_lookup(name);
1263 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001264 WILL_LJMP(luaL_error(L, "'del_acl': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001265
1266 pat_ref_delete(ref, key);
1267 return 0;
1268}
1269
1270/* This function is an LUA binding. It provides a function
1271 * for deleting map entry from a referenced map file.
1272 */
1273static int hlua_del_map(lua_State *L)
1274{
1275 const char *name;
1276 const char *key;
1277 struct pat_ref *ref;
1278
1279 MAY_LJMP(check_args(L, 2, "del_map"));
1280
1281 name = MAY_LJMP(luaL_checkstring(L, 1));
1282 key = MAY_LJMP(luaL_checkstring(L, 2));
1283
1284 ref = pat_ref_lookup(name);
1285 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001286 WILL_LJMP(luaL_error(L, "'del_map': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001287
1288 pat_ref_delete(ref, key);
1289 return 0;
1290}
1291
1292/* This function is an LUA binding. It provides a function
1293 * for adding ACL pattern from a referenced ACL file.
1294 */
1295static int hlua_add_acl(lua_State *L)
1296{
1297 const char *name;
1298 const char *key;
1299 struct pat_ref *ref;
1300
1301 MAY_LJMP(check_args(L, 2, "add_acl"));
1302
1303 name = MAY_LJMP(luaL_checkstring(L, 1));
1304 key = MAY_LJMP(luaL_checkstring(L, 2));
1305
1306 ref = pat_ref_lookup(name);
1307 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001308 WILL_LJMP(luaL_error(L, "'add_acl': unknown acl file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001309
1310 if (pat_ref_find_elt(ref, key) == NULL)
1311 pat_ref_add(ref, key, NULL, NULL);
1312 return 0;
1313}
1314
1315/* This function is an LUA binding. It provides a function
1316 * for setting map pattern and sample from a referenced map
1317 * file.
1318 */
1319static int hlua_set_map(lua_State *L)
1320{
1321 const char *name;
1322 const char *key;
1323 const char *value;
1324 struct pat_ref *ref;
1325
1326 MAY_LJMP(check_args(L, 3, "set_map"));
1327
1328 name = MAY_LJMP(luaL_checkstring(L, 1));
1329 key = MAY_LJMP(luaL_checkstring(L, 2));
1330 value = MAY_LJMP(luaL_checkstring(L, 3));
1331
1332 ref = pat_ref_lookup(name);
1333 if (!ref)
Vincent Bernata72db182015-10-06 16:05:59 +02001334 WILL_LJMP(luaL_error(L, "'set_map': unknown map file '%s'", name));
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01001335
1336 if (pat_ref_find_elt(ref, key) != NULL)
1337 pat_ref_set(ref, key, value, NULL);
1338 else
1339 pat_ref_add(ref, key, value, NULL);
1340 return 0;
1341}
1342
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01001343/* A class is a lot of memory that contain data. This data can be a table,
1344 * an integer or user data. This data is associated with a metatable. This
1345 * metatable have an original version registred in the global context with
1346 * the name of the object (_G[<name>] = <metable> ).
1347 *
1348 * A metable is a table that modify the standard behavior of a standard
1349 * access to the associated data. The entries of this new metatable are
1350 * defined as is:
1351 *
1352 * http://lua-users.org/wiki/MetatableEvents
1353 *
1354 * __index
1355 *
1356 * we access an absent field in a table, the result is nil. This is
1357 * true, but it is not the whole truth. Actually, such access triggers
1358 * the interpreter to look for an __index metamethod: If there is no
1359 * such method, as usually happens, then the access results in nil;
1360 * otherwise, the metamethod will provide the result.
1361 *
1362 * Control 'prototype' inheritance. When accessing "myTable[key]" and
1363 * the key does not appear in the table, but the metatable has an __index
1364 * property:
1365 *
1366 * - if the value is a function, the function is called, passing in the
1367 * table and the key; the return value of that function is returned as
1368 * the result.
1369 *
1370 * - if the value is another table, the value of the key in that table is
1371 * asked for and returned (and if it doesn't exist in that table, but that
1372 * table's metatable has an __index property, then it continues on up)
1373 *
1374 * - Use "rawget(myTable,key)" to skip this metamethod.
1375 *
1376 * http://www.lua.org/pil/13.4.1.html
1377 *
1378 * __newindex
1379 *
1380 * Like __index, but control property assignment.
1381 *
1382 * __mode - Control weak references. A string value with one or both
1383 * of the characters 'k' and 'v' which specifies that the the
1384 * keys and/or values in the table are weak references.
1385 *
1386 * __call - Treat a table like a function. When a table is followed by
1387 * parenthesis such as "myTable( 'foo' )" and the metatable has
1388 * a __call key pointing to a function, that function is invoked
1389 * (passing any specified arguments) and the return value is
1390 * returned.
1391 *
1392 * __metatable - Hide the metatable. When "getmetatable( myTable )" is
1393 * called, if the metatable for myTable has a __metatable
1394 * key, the value of that key is returned instead of the
1395 * actual metatable.
1396 *
1397 * __tostring - Control string representation. When the builtin
1398 * "tostring( myTable )" function is called, if the metatable
1399 * for myTable has a __tostring property set to a function,
1400 * that function is invoked (passing myTable to it) and the
1401 * return value is used as the string representation.
1402 *
1403 * __len - Control table length. When the table length is requested using
1404 * the length operator ( '#' ), if the metatable for myTable has
1405 * a __len key pointing to a function, that function is invoked
1406 * (passing myTable to it) and the return value used as the value
1407 * of "#myTable".
1408 *
1409 * __gc - Userdata finalizer code. When userdata is set to be garbage
1410 * collected, if the metatable has a __gc field pointing to a
1411 * function, that function is first invoked, passing the userdata
1412 * to it. The __gc metamethod is not called for tables.
1413 * (See http://lua-users.org/lists/lua-l/2006-11/msg00508.html)
1414 *
1415 * Special metamethods for redefining standard operators:
1416 * http://www.lua.org/pil/13.1.html
1417 *
1418 * __add "+"
1419 * __sub "-"
1420 * __mul "*"
1421 * __div "/"
1422 * __unm "!"
1423 * __pow "^"
1424 * __concat ".."
1425 *
1426 * Special methods for redfining standar relations
1427 * http://www.lua.org/pil/13.2.html
1428 *
1429 * __eq "=="
1430 * __lt "<"
1431 * __le "<="
1432 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001433
1434/*
1435 *
1436 *
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001437 * Class Map
1438 *
1439 *
1440 */
1441
1442/* Returns a struct hlua_map if the stack entry "ud" is
1443 * a class session, otherwise it throws an error.
1444 */
1445__LJMP static struct map_descriptor *hlua_checkmap(lua_State *L, int ud)
1446{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02001447 return MAY_LJMP(hlua_checkudata(L, ud, class_map_ref));
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001448}
1449
1450/* This function is the map constructor. It don't need
1451 * the class Map object. It creates and return a new Map
1452 * object. It must be called only during "body" or "init"
1453 * context because it process some filesystem accesses.
1454 */
1455__LJMP static int hlua_map_new(struct lua_State *L)
1456{
1457 const char *fn;
1458 int match = PAT_MATCH_STR;
1459 struct sample_conv conv;
1460 const char *file = "";
1461 int line = 0;
1462 lua_Debug ar;
1463 char *err = NULL;
1464 struct arg args[2];
1465
1466 if (lua_gettop(L) < 1 || lua_gettop(L) > 2)
1467 WILL_LJMP(luaL_error(L, "'new' needs at least 1 argument."));
1468
1469 fn = MAY_LJMP(luaL_checkstring(L, 1));
1470
1471 if (lua_gettop(L) >= 2) {
1472 match = MAY_LJMP(luaL_checkinteger(L, 2));
1473 if (match < 0 || match >= PAT_MATCH_NUM)
1474 WILL_LJMP(luaL_error(L, "'new' needs a valid match method."));
1475 }
1476
1477 /* Get Lua filename and line number. */
1478 if (lua_getstack(L, 1, &ar)) { /* check function at level */
1479 lua_getinfo(L, "Sl", &ar); /* get info about it */
1480 if (ar.currentline > 0) { /* is there info? */
1481 file = ar.short_src;
1482 line = ar.currentline;
1483 }
1484 }
1485
1486 /* fill fake sample_conv struct. */
1487 conv.kw = ""; /* unused. */
1488 conv.process = NULL; /* unused. */
1489 conv.arg_mask = 0; /* unused. */
1490 conv.val_args = NULL; /* unused. */
1491 conv.out_type = SMP_T_STR;
1492 conv.private = (void *)(long)match;
1493 switch (match) {
1494 case PAT_MATCH_STR: conv.in_type = SMP_T_STR; break;
1495 case PAT_MATCH_BEG: conv.in_type = SMP_T_STR; break;
1496 case PAT_MATCH_SUB: conv.in_type = SMP_T_STR; break;
1497 case PAT_MATCH_DIR: conv.in_type = SMP_T_STR; break;
1498 case PAT_MATCH_DOM: conv.in_type = SMP_T_STR; break;
1499 case PAT_MATCH_END: conv.in_type = SMP_T_STR; break;
1500 case PAT_MATCH_REG: conv.in_type = SMP_T_STR; break;
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001501 case PAT_MATCH_INT: conv.in_type = SMP_T_SINT; break;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001502 case PAT_MATCH_IP: conv.in_type = SMP_T_ADDR; break;
1503 default:
1504 WILL_LJMP(luaL_error(L, "'new' doesn't support this match mode."));
1505 }
1506
1507 /* fill fake args. */
1508 args[0].type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001509 args[0].data.str.area = (char *)fn;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001510 args[1].type = ARGT_STOP;
1511
1512 /* load the map. */
1513 if (!sample_load_map(args, &conv, file, line, &err)) {
1514 /* error case: we cant use luaL_error because we must
1515 * free the err variable.
1516 */
1517 luaL_where(L, 1);
1518 lua_pushfstring(L, "'new': %s.", err);
1519 lua_concat(L, 2);
1520 free(err);
1521 WILL_LJMP(lua_error(L));
1522 }
1523
1524 /* create the lua object. */
1525 lua_newtable(L);
1526 lua_pushlightuserdata(L, args[0].data.map);
1527 lua_rawseti(L, -2, 0);
1528
1529 /* Pop a class Map metatable and affect it to the userdata. */
1530 lua_rawgeti(L, LUA_REGISTRYINDEX, class_map_ref);
1531 lua_setmetatable(L, -2);
1532
1533
1534 return 1;
1535}
1536
1537__LJMP static inline int _hlua_map_lookup(struct lua_State *L, int str)
1538{
1539 struct map_descriptor *desc;
1540 struct pattern *pat;
1541 struct sample smp;
1542
1543 MAY_LJMP(check_args(L, 2, "lookup"));
1544 desc = MAY_LJMP(hlua_checkmap(L, 1));
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001545 if (desc->pat.expect_type == SMP_T_SINT) {
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001546 smp.data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001547 smp.data.u.sint = MAY_LJMP(luaL_checkinteger(L, 2));
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001548 }
1549 else {
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001550 smp.data.type = SMP_T_STR;
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001551 smp.flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001552 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 +02001553 }
1554
1555 pat = pattern_exec_match(&desc->pat, &smp, 1);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001556 if (!pat || !pat->data) {
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001557 if (str)
1558 lua_pushstring(L, "");
1559 else
1560 lua_pushnil(L);
1561 return 1;
1562 }
1563
1564 /* The Lua pattern must return a string, so we can't check the returned type */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001565 lua_pushlstring(L, pat->data->u.str.area, pat->data->u.str.data);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02001566 return 1;
1567}
1568
1569__LJMP static int hlua_map_lookup(struct lua_State *L)
1570{
1571 return _hlua_map_lookup(L, 0);
1572}
1573
1574__LJMP static int hlua_map_slookup(struct lua_State *L)
1575{
1576 return _hlua_map_lookup(L, 1);
1577}
1578
1579/*
1580 *
1581 *
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001582 * Class Socket
1583 *
1584 *
1585 */
1586
1587__LJMP static struct hlua_socket *hlua_checksocket(lua_State *L, int ud)
1588{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02001589 return MAY_LJMP(hlua_checkudata(L, ud, class_socket_ref));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001590}
1591
1592/* This function is the handler called for each I/O on the established
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001593 * connection. It is used for notify space available to send or data
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001594 * received.
1595 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02001596static void hlua_socket_handler(struct appctx *appctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001597{
Willy Tarreau00a37f02015-04-13 12:05:19 +02001598 struct stream_interface *si = appctx->owner;
Olivier Houchard9aaf7782017-09-13 18:30:23 +02001599 struct connection *c = cs_conn(objt_cs(si_opposite(si)->end));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001600
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02001601 if (appctx->ctx.hlua_cosocket.die) {
1602 si_shutw(si);
1603 si_shutr(si);
1604 si_ic(si)->flags |= CF_READ_NULL;
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001605 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1606 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02001607 stream_shutdown(si_strm(si), SF_ERR_KILLED);
1608 }
1609
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001610 /* If the connection object is not available, close all the
1611 * streams and wakeup everything waiting for.
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001612 */
1613 if (!c) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001614 si_shutw(si);
1615 si_shutr(si);
Willy Tarreau2bb4a962014-11-28 11:11:05 +01001616 si_ic(si)->flags |= CF_READ_NULL;
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001617 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1618 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Willy Tarreaud4da1962015-04-20 01:31:23 +02001619 return;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001620 }
1621
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001622 /* If we cant write, wakeup the pending write signals. */
1623 if (channel_output_closed(si_ic(si)))
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001624 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001625
1626 /* If we cant read, wakeup the pending read signals. */
1627 if (channel_input_closed(si_oc(si)))
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001628 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
Thierry FOURNIER6d695e62015-09-27 19:29:38 +02001629
Thierry FOURNIER316e3192015-09-04 18:25:53 +02001630 /* if the connection is not estabkished, inform the stream that we want
1631 * to be notified whenever the connection completes.
1632 */
1633 if (!(c->flags & CO_FL_CONNECTED)) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01001634 si_cant_get(si);
Willy Tarreau12c24232018-12-06 15:29:50 +01001635 si_rx_conn_blk(si);
Willy Tarreau3367d412018-11-15 10:57:41 +01001636 si_rx_endp_more(si);
Willy Tarreaud4da1962015-04-20 01:31:23 +02001637 return;
Thierry FOURNIER316e3192015-09-04 18:25:53 +02001638 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001639
1640 /* This function is called after the connect. */
Thierry FOURNIER18d09902016-12-16 09:25:38 +01001641 appctx->ctx.hlua_cosocket.connected = 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001642
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001643 /* Wake the tasks which wants to write if the buffer have available space. */
Thierry FOURNIEReba6f642015-09-26 22:01:07 +02001644 if (channel_may_recv(si_ic(si)))
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001645 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001646
1647 /* Wake the tasks which wants to read if the buffer contains data. */
Thierry FOURNIEReba6f642015-09-26 22:01:07 +02001648 if (!channel_is_empty(si_oc(si)))
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001649 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
Thierry FOURNIER101b9762018-05-27 01:27:40 +02001650
1651 /* Some data were injected in the buffer, notify the stream
1652 * interface.
1653 */
1654 if (!channel_is_empty(si_ic(si)))
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01001655 si_update(si);
Thierry FOURNIER101b9762018-05-27 01:27:40 +02001656
1657 /* If write notifications are registered, we considers we want
Willy Tarreau3367d412018-11-15 10:57:41 +01001658 * to write, so we clear the blocking flag.
Thierry FOURNIER101b9762018-05-27 01:27:40 +02001659 */
1660 if (notification_registered(&appctx->ctx.hlua_cosocket.wake_on_write))
Willy Tarreau3367d412018-11-15 10:57:41 +01001661 si_rx_endp_more(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001662}
1663
Willy Tarreau87b09662015-04-03 00:22:06 +02001664/* This function is called when the "struct stream" is destroyed.
1665 * Remove the link from the object to this stream.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001666 * Wake all the pending signals.
1667 */
Willy Tarreau00a37f02015-04-13 12:05:19 +02001668static void hlua_socket_release(struct appctx *appctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001669{
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001670 struct xref *peer;
1671
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001672 /* Remove my link in the original object. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001673 peer = xref_get_peer_and_lock(&appctx->ctx.hlua_cosocket.xref);
1674 if (peer)
1675 xref_disconnect(&appctx->ctx.hlua_cosocket.xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001676
1677 /* Wake all the task waiting for me. */
Thierry FOURNIERd6975962017-07-12 14:31:10 +02001678 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1679 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001680}
1681
1682/* If the garbage collectio of the object is launch, nobody
Willy Tarreau87b09662015-04-03 00:22:06 +02001683 * uses this object. If the stream does not exists, just quit.
1684 * Send the shutdown signal to the stream. In some cases,
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001685 * pending signal can rest in the read and write lists. destroy
1686 * it.
1687 */
1688__LJMP static int hlua_socket_gc(lua_State *L)
1689{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001690 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001691 struct appctx *appctx;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001692 struct xref *peer;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001693
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001694 MAY_LJMP(check_args(L, 1, "__gc"));
1695
1696 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001697 peer = xref_get_peer_and_lock(&socket->xref);
1698 if (!peer)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001699 return 0;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001700 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001701
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001702 /* Set the flag which destroy the session. */
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02001703 appctx->ctx.hlua_cosocket.die = 1;
1704 appctx_wakeup(appctx);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001705
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001706 /* Remove all reference between the Lua stack and the coroutine stream. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001707 xref_disconnect(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001708 return 0;
1709}
1710
1711/* The close function send shutdown signal and break the
Willy Tarreau87b09662015-04-03 00:22:06 +02001712 * links between the stream and the object.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001713 */
sada05ed3302018-05-11 11:48:18 -07001714__LJMP static int hlua_socket_close_helper(lua_State *L)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001715{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001716 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001717 struct appctx *appctx;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001718 struct xref *peer;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001719
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001720 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02001721
1722 /* Check if we run on the same thread than the xreator thread.
1723 * We cannot access to the socket if the thread is different.
1724 */
1725 if (socket->tid != tid)
1726 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
1727
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001728 peer = xref_get_peer_and_lock(&socket->xref);
1729 if (!peer)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001730 return 0;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001731 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001732
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001733 /* Set the flag which destroy the session. */
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02001734 appctx->ctx.hlua_cosocket.die = 1;
1735 appctx_wakeup(appctx);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001736
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001737 /* Remove all reference between the Lua stack and the coroutine stream. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001738 xref_disconnect(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001739 return 0;
1740}
1741
sada05ed3302018-05-11 11:48:18 -07001742/* The close function calls close_helper.
1743 */
1744__LJMP static int hlua_socket_close(lua_State *L)
1745{
1746 MAY_LJMP(check_args(L, 1, "close"));
1747 return hlua_socket_close_helper(L);
1748}
1749
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001750/* This Lua function assumes that the stack contain three parameters.
1751 * 1 - USERDATA containing a struct socket
1752 * 2 - INTEGER with values of the macro defined below
1753 * If the integer is -1, we must read at most one line.
1754 * If the integer is -2, we ust read all the data until the
1755 * end of the stream.
1756 * If the integer is positive value, we must read a number of
1757 * bytes corresponding to this value.
1758 */
1759#define HLSR_READ_LINE (-1)
1760#define HLSR_READ_ALL (-2)
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001761__LJMP static int hlua_socket_receive_yield(struct lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001762{
1763 struct hlua_socket *socket = MAY_LJMP(hlua_checksocket(L, 1));
1764 int wanted = lua_tointeger(L, 2);
1765 struct hlua *hlua = hlua_gethlua(L);
1766 struct appctx *appctx;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02001767 size_t len;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001768 int nblk;
Willy Tarreau206ba832018-06-14 15:27:31 +02001769 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02001770 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02001771 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02001772 size_t len2;
Thierry FOURNIER00543922015-03-09 18:35:06 +01001773 int skip_at_end = 0;
Willy Tarreau81389672015-03-10 12:03:52 +01001774 struct channel *oc;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001775 struct stream_interface *si;
1776 struct stream *s;
1777 struct xref *peer;
Thierry FOURNIER8c126c72018-05-25 16:27:44 +02001778 int missing_bytes;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001779
1780 /* Check if this lua stack is schedulable. */
1781 if (!hlua || !hlua->task)
1782 WILL_LJMP(luaL_error(L, "The 'receive' function is only allowed in "
1783 "'frontend', 'backend' or 'task'"));
1784
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02001785 /* Check if we run on the same thread than the xreator thread.
1786 * We cannot access to the socket if the thread is different.
1787 */
1788 if (socket->tid != tid)
1789 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
1790
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001791 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001792 peer = xref_get_peer_and_lock(&socket->xref);
1793 if (!peer)
1794 goto no_peer;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001795 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
1796 si = appctx->owner;
1797 s = si_strm(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001798
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02001799 oc = &s->res;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001800 if (wanted == HLSR_READ_LINE) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001801 /* Read line. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02001802 nblk = co_getline_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001803 if (nblk < 0) /* Connection close. */
1804 goto connection_closed;
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001805 if (nblk == 0) /* No data available. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001806 goto connection_empty;
Thierry FOURNIER00543922015-03-09 18:35:06 +01001807
1808 /* remove final \r\n. */
1809 if (nblk == 1) {
1810 if (blk1[len1-1] == '\n') {
1811 len1--;
1812 skip_at_end++;
1813 if (blk1[len1-1] == '\r') {
1814 len1--;
1815 skip_at_end++;
1816 }
1817 }
1818 }
1819 else {
1820 if (blk2[len2-1] == '\n') {
1821 len2--;
1822 skip_at_end++;
1823 if (blk2[len2-1] == '\r') {
1824 len2--;
1825 skip_at_end++;
1826 }
1827 }
1828 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001829 }
1830
1831 else if (wanted == HLSR_READ_ALL) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001832 /* Read all the available data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02001833 nblk = co_getblk_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001834 if (nblk < 0) /* Connection close. */
1835 goto connection_closed;
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001836 if (nblk == 0) /* No data available. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001837 goto connection_empty;
1838 }
1839
1840 else {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001841 /* Read a block of data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02001842 nblk = co_getblk_nc(oc, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001843 if (nblk < 0) /* Connection close. */
1844 goto connection_closed;
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08001845 if (nblk == 0) /* No data available. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001846 goto connection_empty;
1847
Thierry FOURNIER8c126c72018-05-25 16:27:44 +02001848 missing_bytes = wanted - socket->b.n;
1849 if (len1 > missing_bytes) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001850 nblk = 1;
Thierry FOURNIER8c126c72018-05-25 16:27:44 +02001851 len1 = missing_bytes;
1852 } if (nblk == 2 && len1 + len2 > missing_bytes)
1853 len2 = missing_bytes - len1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001854 }
1855
1856 len = len1;
1857
1858 luaL_addlstring(&socket->b, blk1, len1);
1859 if (nblk == 2) {
1860 len += len2;
1861 luaL_addlstring(&socket->b, blk2, len2);
1862 }
1863
1864 /* Consume data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02001865 co_skip(oc, len + skip_at_end);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001866
1867 /* Don't wait anything. */
Thierry FOURNIER7e4ee472018-05-25 15:03:50 +02001868 appctx_wakeup(appctx);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001869
1870 /* If the pattern reclaim to read all the data
1871 * in the connection, got out.
1872 */
1873 if (wanted == HLSR_READ_ALL)
1874 goto connection_empty;
Thierry FOURNIER8c126c72018-05-25 16:27:44 +02001875 else if (wanted >= 0 && socket->b.n < wanted)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001876 goto connection_empty;
1877
1878 /* Return result. */
1879 luaL_pushresult(&socket->b);
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001880 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001881 return 1;
1882
1883connection_closed:
1884
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001885 xref_unlock(&socket->xref, peer);
1886
1887no_peer:
1888
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001889 /* If the buffer containds data. */
1890 if (socket->b.n > 0) {
1891 luaL_pushresult(&socket->b);
1892 return 1;
1893 }
1894 lua_pushnil(L);
1895 lua_pushstring(L, "connection closed.");
1896 return 2;
1897
1898connection_empty:
1899
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001900 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_read, hlua->task)) {
1901 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001902 WILL_LJMP(luaL_error(L, "out of memory"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02001903 }
1904 xref_unlock(&socket->xref, peer);
Willy Tarreau9635e032018-10-16 17:52:55 +02001905 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_receive_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001906 return 0;
1907}
1908
Tim Duesterhusb33754c2018-01-04 19:32:14 +01001909/* This Lua function gets two parameters. The first one can be string
1910 * or a number. If the string is "*l", the user requires one line. If
1911 * the string is "*a", the user requires all the contents of the stream.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001912 * If the value is a number, the user require a number of bytes equal
1913 * to the value. The default value is "*l" (a line).
1914 *
Tim Duesterhusb33754c2018-01-04 19:32:14 +01001915 * This parameter with a variable type is converted in integer. This
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001916 * integer takes this values:
1917 * -1 : read a line
1918 * -2 : read all the stream
Tim Duesterhusb33754c2018-01-04 19:32:14 +01001919 * >0 : amount of bytes.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001920 *
Tim Duesterhusb33754c2018-01-04 19:32:14 +01001921 * The second parameter is optional. It contains a string that must be
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001922 * concatenated with the read data.
1923 */
1924__LJMP static int hlua_socket_receive(struct lua_State *L)
1925{
1926 int wanted = HLSR_READ_LINE;
1927 const char *pattern;
1928 int type;
1929 char *error;
1930 size_t len;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001931 struct hlua_socket *socket;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001932
1933 if (lua_gettop(L) < 1 || lua_gettop(L) > 3)
1934 WILL_LJMP(luaL_error(L, "The 'receive' function requires between 1 and 3 arguments."));
1935
Willy Tarreau80f5fae2015-02-27 16:38:20 +01001936 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001937
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02001938 /* Check if we run on the same thread than the xreator thread.
1939 * We cannot access to the socket if the thread is different.
1940 */
1941 if (socket->tid != tid)
1942 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
1943
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001944 /* check for pattern. */
1945 if (lua_gettop(L) >= 2) {
1946 type = lua_type(L, 2);
1947 if (type == LUA_TSTRING) {
1948 pattern = lua_tostring(L, 2);
1949 if (strcmp(pattern, "*a") == 0)
1950 wanted = HLSR_READ_ALL;
1951 else if (strcmp(pattern, "*l") == 0)
1952 wanted = HLSR_READ_LINE;
1953 else {
1954 wanted = strtoll(pattern, &error, 10);
1955 if (*error != '\0')
1956 WILL_LJMP(luaL_error(L, "Unsupported pattern."));
1957 }
1958 }
1959 else if (type == LUA_TNUMBER) {
1960 wanted = lua_tointeger(L, 2);
1961 if (wanted < 0)
1962 WILL_LJMP(luaL_error(L, "Unsupported size."));
1963 }
1964 }
1965
1966 /* Set pattern. */
1967 lua_pushinteger(L, wanted);
Tim Duesterhusc6e377e2018-01-04 19:32:13 +01001968
1969 /* Check if we would replace the top by itself. */
1970 if (lua_gettop(L) != 2)
1971 lua_replace(L, 2);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001972
Tim Duesterhusb33754c2018-01-04 19:32:14 +01001973 /* init buffer, and fill it with prefix. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001974 luaL_buffinit(L, &socket->b);
1975
1976 /* Check prefix. */
1977 if (lua_gettop(L) >= 3) {
1978 if (lua_type(L, 3) != LUA_TSTRING)
1979 WILL_LJMP(luaL_error(L, "Expect a 'string' for the prefix"));
1980 pattern = lua_tolstring(L, 3, &len);
1981 luaL_addlstring(&socket->b, pattern, len);
1982 }
1983
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001984 return __LJMP(hlua_socket_receive_yield(L, 0, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001985}
1986
1987/* Write the Lua input string in the output buffer.
Mark Lakes22154b42018-01-29 14:38:40 -08001988 * This function returns a yield if no space is available.
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001989 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01001990static int hlua_socket_write_yield(struct lua_State *L,int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01001991{
1992 struct hlua_socket *socket;
1993 struct hlua *hlua = hlua_gethlua(L);
1994 struct appctx *appctx;
1995 size_t buf_len;
1996 const char *buf;
1997 int len;
1998 int send_len;
1999 int sent;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002000 struct xref *peer;
2001 struct stream_interface *si;
2002 struct stream *s;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002003
2004 /* Check if this lua stack is schedulable. */
2005 if (!hlua || !hlua->task)
2006 WILL_LJMP(luaL_error(L, "The 'write' function is only allowed in "
2007 "'frontend', 'backend' or 'task'"));
2008
2009 /* Get object */
2010 socket = MAY_LJMP(hlua_checksocket(L, 1));
2011 buf = MAY_LJMP(luaL_checklstring(L, 2, &buf_len));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002012 sent = MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002013
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002014 /* Check if we run on the same thread than the xreator thread.
2015 * We cannot access to the socket if the thread is different.
2016 */
2017 if (socket->tid != tid)
2018 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2019
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002020 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002021 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002022 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002023 lua_pushinteger(L, -1);
2024 return 1;
2025 }
2026 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2027 si = appctx->owner;
2028 s = si_strm(si);
2029
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002030 /* Check for connection close. */
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002031 if (channel_output_closed(&s->req)) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002032 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002033 lua_pushinteger(L, -1);
2034 return 1;
2035 }
2036
2037 /* Update the input buffer data. */
2038 buf += sent;
2039 send_len = buf_len - sent;
2040
2041 /* All the data are sent. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002042 if (sent >= buf_len) {
2043 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002044 return 1; /* Implicitly return the length sent. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002045 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002046
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002047 /* Check if the buffer is available because HAProxy doesn't allocate
Thierry FOURNIER486d52a2015-03-09 17:51:43 +01002048 * the request buffer if its not required.
2049 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002050 if (s->req.buf.size == 0) {
Willy Tarreau581abd32018-10-25 10:21:41 +02002051 if (!si_alloc_ibuf(si, &appctx->buffer_wait))
Christopher Faulet33834b12016-12-19 09:29:06 +01002052 goto hlua_socket_write_yield_return;
Thierry FOURNIER486d52a2015-03-09 17:51:43 +01002053 }
2054
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002055 /* Check for available space. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002056 len = b_room(&s->req.buf);
Christopher Faulet33834b12016-12-19 09:29:06 +01002057 if (len <= 0) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002058 goto hlua_socket_write_yield_return;
Christopher Faulet33834b12016-12-19 09:29:06 +01002059 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002060
2061 /* send data */
2062 if (len < send_len)
2063 send_len = len;
Thierry FOURNIER66b89192018-05-27 01:14:47 +02002064 len = ci_putblk(&s->req, buf, send_len);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002065
2066 /* "Not enough space" (-1), "Buffer too little to contain
2067 * the data" (-2) are not expected because the available length
2068 * is tested.
2069 * Other unknown error are also not expected.
2070 */
2071 if (len <= 0) {
Willy Tarreaubc18da12015-03-13 14:00:47 +01002072 if (len == -1)
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002073 s->req.flags |= CF_WAKE_WRITE;
Willy Tarreaubc18da12015-03-13 14:00:47 +01002074
sada05ed3302018-05-11 11:48:18 -07002075 MAY_LJMP(hlua_socket_close_helper(L));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002076 lua_pop(L, 1);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002077 lua_pushinteger(L, -1);
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002078 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002079 return 1;
2080 }
2081
2082 /* update buffers. */
Thierry FOURNIER101b9762018-05-27 01:27:40 +02002083 appctx_wakeup(appctx);
Willy Tarreaude70fa12015-09-26 11:25:05 +02002084
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002085 s->req.rex = TICK_ETERNITY;
2086 s->res.wex = TICK_ETERNITY;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002087
2088 /* Update length sent. */
2089 lua_pop(L, 1);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002090 lua_pushinteger(L, sent + len);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002091
2092 /* All the data buffer is sent ? */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002093 if (sent + len >= buf_len) {
2094 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002095 return 1;
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002096 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002097
2098hlua_socket_write_yield_return:
Thierry FOURNIERba42fcd2018-05-27 00:59:48 +02002099 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task)) {
2100 xref_unlock(&socket->xref, peer);
2101 WILL_LJMP(luaL_error(L, "out of memory"));
2102 }
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002103 xref_unlock(&socket->xref, peer);
Willy Tarreau9635e032018-10-16 17:52:55 +02002104 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_write_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002105 return 0;
2106}
2107
2108/* This function initiate the send of data. It just check the input
2109 * parameters and push an integer in the Lua stack that contain the
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002110 * amount of data written to the buffer. This is used by the function
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002111 * "hlua_socket_write_yield" that can yield.
2112 *
2113 * The Lua function gets between 3 and 4 parameters. The first one is
2114 * the associated object. The second is a string buffer. The third is
2115 * a facultative integer that represents where is the buffer position
2116 * of the start of the data that can send. The first byte is the
2117 * position "1". The default value is "1". The fourth argument is a
2118 * facultative integer that represents where is the buffer position
2119 * of the end of the data that can send. The default is the last byte.
2120 */
2121static int hlua_socket_send(struct lua_State *L)
2122{
2123 int i;
2124 int j;
2125 const char *buf;
2126 size_t buf_len;
2127
2128 /* Check number of arguments. */
2129 if (lua_gettop(L) < 2 || lua_gettop(L) > 4)
2130 WILL_LJMP(luaL_error(L, "'send' needs between 2 and 4 arguments"));
2131
2132 /* Get the string. */
2133 buf = MAY_LJMP(luaL_checklstring(L, 2, &buf_len));
2134
2135 /* Get and check j. */
2136 if (lua_gettop(L) == 4) {
2137 j = MAY_LJMP(luaL_checkinteger(L, 4));
2138 if (j < 0)
2139 j = buf_len + j + 1;
2140 if (j > buf_len)
2141 j = buf_len + 1;
2142 lua_pop(L, 1);
2143 }
2144 else
2145 j = buf_len;
2146
2147 /* Get and check i. */
2148 if (lua_gettop(L) == 3) {
2149 i = MAY_LJMP(luaL_checkinteger(L, 3));
2150 if (i < 0)
2151 i = buf_len + i + 1;
2152 if (i > buf_len)
2153 i = buf_len + 1;
2154 lua_pop(L, 1);
2155 } else
2156 i = 1;
2157
2158 /* Check bth i and j. */
2159 if (i > j) {
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002160 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002161 return 1;
2162 }
2163 if (i == 0 && j == 0) {
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002164 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002165 return 1;
2166 }
2167 if (i == 0)
2168 i = 1;
2169 if (j == 0)
2170 j = 1;
2171
2172 /* Pop the string. */
2173 lua_pop(L, 1);
2174
2175 /* Update the buffer length. */
2176 buf += i - 1;
2177 buf_len = j - i + 1;
2178 lua_pushlstring(L, buf, buf_len);
2179
2180 /* This unsigned is used to remember the amount of sent data. */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002181 lua_pushinteger(L, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002182
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002183 return MAY_LJMP(hlua_socket_write_yield(L, 0, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002184}
2185
Willy Tarreau22b0a682015-06-17 19:43:49 +02002186#define SOCKET_INFO_MAX_LEN sizeof("[0000:0000:0000:0000:0000:0000:0000:0000]:12345")
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002187__LJMP static inline int hlua_socket_info(struct lua_State *L, struct sockaddr_storage *addr)
2188{
2189 static char buffer[SOCKET_INFO_MAX_LEN];
2190 int ret;
2191 int len;
2192 char *p;
2193
2194 ret = addr_to_str(addr, buffer+1, SOCKET_INFO_MAX_LEN-1);
2195 if (ret <= 0) {
2196 lua_pushnil(L);
2197 return 1;
2198 }
2199
2200 if (ret == AF_UNIX) {
2201 lua_pushstring(L, buffer+1);
2202 return 1;
2203 }
2204 else if (ret == AF_INET6) {
2205 buffer[0] = '[';
2206 len = strlen(buffer);
2207 buffer[len] = ']';
2208 len++;
2209 buffer[len] = ':';
2210 len++;
2211 p = buffer;
2212 }
2213 else if (ret == AF_INET) {
2214 p = buffer + 1;
2215 len = strlen(p);
2216 p[len] = ':';
2217 len++;
2218 }
2219 else {
2220 lua_pushnil(L);
2221 return 1;
2222 }
2223
2224 if (port_to_str(addr, p + len, SOCKET_INFO_MAX_LEN-1 - len) <= 0) {
2225 lua_pushnil(L);
2226 return 1;
2227 }
2228
2229 lua_pushstring(L, p);
2230 return 1;
2231}
2232
2233/* Returns information about the peer of the connection. */
2234__LJMP static int hlua_socket_getpeername(struct lua_State *L)
2235{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002236 struct hlua_socket *socket;
2237 struct connection *conn;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002238 struct xref *peer;
2239 struct appctx *appctx;
2240 struct stream_interface *si;
2241 struct stream *s;
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002242 int ret;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002243
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002244 MAY_LJMP(check_args(L, 1, "getpeername"));
2245
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002246 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002247
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002248 /* Check if we run on the same thread than the xreator thread.
2249 * We cannot access to the socket if the thread is different.
2250 */
2251 if (socket->tid != tid)
2252 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2253
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002254 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002255 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002256 if (!peer) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002257 lua_pushnil(L);
2258 return 1;
2259 }
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002260 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2261 si = appctx->owner;
2262 s = si_strm(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002263
Olivier Houchard9aaf7782017-09-13 18:30:23 +02002264 conn = cs_conn(objt_cs(s->si[1].end));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002265 if (!conn) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002266 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002267 lua_pushnil(L);
2268 return 1;
2269 }
2270
Willy Tarreaua71f6422016-11-16 17:00:14 +01002271 conn_get_to_addr(conn);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002272 if (!(conn->flags & CO_FL_ADDR_TO_SET)) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002273 xref_unlock(&socket->xref, peer);
Willy Tarreaua71f6422016-11-16 17:00:14 +01002274 lua_pushnil(L);
2275 return 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002276 }
2277
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002278 ret = MAY_LJMP(hlua_socket_info(L, &conn->addr.to));
2279 xref_unlock(&socket->xref, peer);
2280 return ret;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002281}
2282
2283/* Returns information about my connection side. */
2284static int hlua_socket_getsockname(struct lua_State *L)
2285{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002286 struct hlua_socket *socket;
2287 struct connection *conn;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002288 struct appctx *appctx;
2289 struct xref *peer;
2290 struct stream_interface *si;
2291 struct stream *s;
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002292 int ret;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002293
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002294 MAY_LJMP(check_args(L, 1, "getsockname"));
2295
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002296 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002297
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002298 /* Check if we run on the same thread than the xreator thread.
2299 * We cannot access to the socket if the thread is different.
2300 */
2301 if (socket->tid != tid)
2302 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2303
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002304 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002305 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002306 if (!peer) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002307 lua_pushnil(L);
2308 return 1;
2309 }
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002310 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2311 si = appctx->owner;
2312 s = si_strm(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002313
Olivier Houchard9aaf7782017-09-13 18:30:23 +02002314 conn = cs_conn(objt_cs(s->si[1].end));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002315 if (!conn) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002316 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002317 lua_pushnil(L);
2318 return 1;
2319 }
2320
Willy Tarreaua71f6422016-11-16 17:00:14 +01002321 conn_get_from_addr(conn);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002322 if (!(conn->flags & CO_FL_ADDR_FROM_SET)) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002323 xref_unlock(&socket->xref, peer);
Willy Tarreaua71f6422016-11-16 17:00:14 +01002324 lua_pushnil(L);
2325 return 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002326 }
2327
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002328 ret = hlua_socket_info(L, &conn->addr.from);
2329 xref_unlock(&socket->xref, peer);
2330 return ret;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002331}
2332
2333/* This struct define the applet. */
Willy Tarreau30576452015-04-13 13:50:30 +02002334static struct applet update_applet = {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002335 .obj_type = OBJ_TYPE_APPLET,
2336 .name = "<LUA_TCP>",
2337 .fct = hlua_socket_handler,
2338 .release = hlua_socket_release,
2339};
2340
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002341__LJMP static int hlua_socket_connect_yield(struct lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002342{
2343 struct hlua_socket *socket = MAY_LJMP(hlua_checksocket(L, 1));
2344 struct hlua *hlua = hlua_gethlua(L);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002345 struct xref *peer;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002346 struct appctx *appctx;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002347 struct stream_interface *si;
2348 struct stream *s;
2349
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002350 /* Check if we run on the same thread than the xreator thread.
2351 * We cannot access to the socket if the thread is different.
2352 */
2353 if (socket->tid != tid)
2354 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2355
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002356 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002357 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002358 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002359 lua_pushnil(L);
2360 lua_pushstring(L, "Can't connect");
2361 return 2;
2362 }
2363 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2364 si = appctx->owner;
2365 s = si_strm(si);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002366
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002367 /* Check if we run on the same thread than the xreator thread.
2368 * We cannot access to the socket if the thread is different.
2369 */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002370 if (socket->tid != tid) {
2371 xref_unlock(&socket->xref, peer);
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002372 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002373 }
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002374
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002375 /* Check for connection close. */
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002376 if (!hlua || channel_output_closed(&s->req)) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002377 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002378 lua_pushnil(L);
2379 lua_pushstring(L, "Can't connect");
2380 return 2;
2381 }
2382
Willy Tarreaue09101e2018-10-16 17:37:12 +02002383 appctx = __objt_appctx(s->si[0].end);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002384
2385 /* Check for connection established. */
Thierry FOURNIER18d09902016-12-16 09:25:38 +01002386 if (appctx->ctx.hlua_cosocket.connected) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002387 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002388 lua_pushinteger(L, 1);
2389 return 1;
2390 }
2391
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002392 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task)) {
2393 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002394 WILL_LJMP(luaL_error(L, "out of memory error"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002395 }
2396 xref_unlock(&socket->xref, peer);
Willy Tarreau9635e032018-10-16 17:52:55 +02002397 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_connect_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002398 return 0;
2399}
2400
2401/* This function fail or initite the connection. */
2402__LJMP static int hlua_socket_connect(struct lua_State *L)
2403{
2404 struct hlua_socket *socket;
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002405 int port = -1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002406 const char *ip;
2407 struct connection *conn;
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002408 struct hlua *hlua;
2409 struct appctx *appctx;
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002410 int low, high;
2411 struct sockaddr_storage *addr;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002412 struct xref *peer;
2413 struct stream_interface *si;
2414 struct stream *s;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002415
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002416 if (lua_gettop(L) < 2)
2417 WILL_LJMP(luaL_error(L, "connect: need at least 2 arguments"));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002418
2419 /* Get args. */
2420 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002421
2422 /* Check if we run on the same thread than the xreator thread.
2423 * We cannot access to the socket if the thread is different.
2424 */
2425 if (socket->tid != tid)
2426 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2427
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002428 ip = MAY_LJMP(luaL_checkstring(L, 2));
Tim Duesterhus6edab862018-01-06 19:04:45 +01002429 if (lua_gettop(L) >= 3) {
2430 luaL_Buffer b;
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002431 port = MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002432
Tim Duesterhus6edab862018-01-06 19:04:45 +01002433 /* Force the ip to end with a colon, to support IPv6 addresses
2434 * that are not enclosed within square brackets.
2435 */
2436 if (port > 0) {
2437 luaL_buffinit(L, &b);
2438 luaL_addstring(&b, ip);
2439 luaL_addchar(&b, ':');
2440 luaL_pushresult(&b);
2441 ip = lua_tolstring(L, lua_gettop(L), NULL);
2442 }
2443 }
2444
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002445 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002446 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002447 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002448 lua_pushnil(L);
2449 return 1;
2450 }
2451 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2452 si = appctx->owner;
2453 s = si_strm(si);
2454
2455 /* Initialise connection. */
Olivier Houchard9aaf7782017-09-13 18:30:23 +02002456 conn = cs_conn(si_alloc_cs(&s->si[1], NULL));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002457 if (!conn) {
2458 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002459 WILL_LJMP(luaL_error(L, "connect: internal error"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002460 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002461
Willy Tarreau3adac082015-09-26 17:51:09 +02002462 /* needed for the connection not to be closed */
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002463 conn->target = s->target;
Willy Tarreau3adac082015-09-26 17:51:09 +02002464
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002465 /* Parse ip address. */
Willy Tarreau48ef4c92017-01-06 18:32:38 +01002466 addr = str2sa_range(ip, NULL, &low, &high, NULL, NULL, NULL, 0);
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002467 if (!addr) {
2468 xref_unlock(&socket->xref, peer);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002469 WILL_LJMP(luaL_error(L, "connect: cannot parse destination address '%s'", ip));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002470 }
2471 if (low != high) {
2472 xref_unlock(&socket->xref, peer);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002473 WILL_LJMP(luaL_error(L, "connect: port ranges not supported : address '%s'", ip));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002474 }
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002475 memcpy(&conn->addr.to, addr, sizeof(struct sockaddr_storage));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002476
2477 /* Set port. */
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002478 if (low == 0) {
2479 if (conn->addr.to.ss_family == AF_INET) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002480 if (port == -1) {
2481 xref_unlock(&socket->xref, peer);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002482 WILL_LJMP(luaL_error(L, "connect: port missing"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002483 }
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002484 ((struct sockaddr_in *)&conn->addr.to)->sin_port = htons(port);
2485 } else if (conn->addr.to.ss_family == AF_INET6) {
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002486 if (port == -1) {
2487 xref_unlock(&socket->xref, peer);
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002488 WILL_LJMP(luaL_error(L, "connect: port missing"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002489 }
Thierry FOURNIERc2f56532015-09-26 20:23:30 +02002490 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_port = htons(port);
2491 }
2492 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002493
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002494 hlua = hlua_gethlua(L);
Willy Tarreaue09101e2018-10-16 17:37:12 +02002495 appctx = __objt_appctx(s->si[0].end);
Willy Tarreaubdc97a82015-08-24 15:42:28 +02002496
2497 /* inform the stream that we want to be notified whenever the
2498 * connection completes.
2499 */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01002500 si_cant_get(&s->si[0]);
Willy Tarreau3367d412018-11-15 10:57:41 +01002501 si_rx_endp_more(&s->si[0]);
Thierry FOURNIER8c8fbbe2015-09-26 17:02:35 +02002502 appctx_wakeup(appctx);
Willy Tarreaubdc97a82015-08-24 15:42:28 +02002503
Thierry FOURNIER7c39ab42015-09-27 22:53:33 +02002504 hlua->flags |= HLUA_MUST_GC;
2505
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002506 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task)) {
2507 xref_unlock(&socket->xref, peer);
Thierry FOURNIER95ad96a2015-03-09 18:12:40 +01002508 WILL_LJMP(luaL_error(L, "out of memory"));
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002509 }
2510 xref_unlock(&socket->xref, peer);
PiBa-NL706d5ee2018-05-05 23:51:42 +02002511
2512 task_wakeup(s->task, TASK_WOKEN_INIT);
2513 /* Return yield waiting for connection. */
2514
Willy Tarreau9635e032018-10-16 17:52:55 +02002515 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_connect_yield, TICK_ETERNITY, 0));
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002516
2517 return 0;
2518}
2519
Baptiste Assmann84bb4932015-03-02 21:40:06 +01002520#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002521__LJMP static int hlua_socket_connect_ssl(struct lua_State *L)
2522{
2523 struct hlua_socket *socket;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002524 struct xref *peer;
2525 struct appctx *appctx;
2526 struct stream_interface *si;
2527 struct stream *s;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002528
2529 MAY_LJMP(check_args(L, 3, "connect_ssl"));
2530 socket = MAY_LJMP(hlua_checksocket(L, 1));
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002531
2532 /* check for connection break. If some data where read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002533 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002534 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002535 lua_pushnil(L);
2536 return 1;
2537 }
2538 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2539 si = appctx->owner;
2540 s = si_strm(si);
2541
2542 s->target = &socket_ssl.obj_type;
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002543 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002544 return MAY_LJMP(hlua_socket_connect(L));
2545}
Baptiste Assmann84bb4932015-03-02 21:40:06 +01002546#endif
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002547
2548__LJMP static int hlua_socket_setoption(struct lua_State *L)
2549{
2550 return 0;
2551}
2552
2553__LJMP static int hlua_socket_settimeout(struct lua_State *L)
2554{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002555 struct hlua_socket *socket;
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002556 int tmout;
Mark Lakes56cc1252018-03-27 09:48:06 +02002557 double dtmout;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002558 struct xref *peer;
2559 struct appctx *appctx;
2560 struct stream_interface *si;
2561 struct stream *s;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002562
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002563 MAY_LJMP(check_args(L, 2, "settimeout"));
2564
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002565 socket = MAY_LJMP(hlua_checksocket(L, 1));
Mark Lakes56cc1252018-03-27 09:48:06 +02002566
Cyril Bonté7ee465f2018-08-19 22:08:50 +02002567 /* convert the timeout to millis */
2568 dtmout = MAY_LJMP(luaL_checknumber(L, 2)) * 1000;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002569
Thierry Fournier17a921b2018-03-08 09:59:02 +01002570 /* Check for negative values */
Mark Lakes56cc1252018-03-27 09:48:06 +02002571 if (dtmout < 0)
Thierry Fournier17a921b2018-03-08 09:59:02 +01002572 WILL_LJMP(luaL_error(L, "settimeout: cannot set negatives values"));
2573
Mark Lakes56cc1252018-03-27 09:48:06 +02002574 if (dtmout > INT_MAX) /* overflow check */
Cyril Bonté7ee465f2018-08-19 22:08:50 +02002575 WILL_LJMP(luaL_error(L, "settimeout: cannot set values larger than %d ms", INT_MAX));
Mark Lakes56cc1252018-03-27 09:48:06 +02002576
2577 tmout = MS_TO_TICKS((int)dtmout);
Cyril Bonté7ee465f2018-08-19 22:08:50 +02002578 if (tmout == 0)
2579 tmout++; /* very small timeouts are adjusted to a minium of 1ms */
Mark Lakes56cc1252018-03-27 09:48:06 +02002580
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002581 /* Check if we run on the same thread than the xreator thread.
2582 * We cannot access to the socket if the thread is different.
2583 */
2584 if (socket->tid != tid)
2585 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2586
Mark Lakes56cc1252018-03-27 09:48:06 +02002587 /* check for connection break. If some data were read, return it. */
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002588 peer = xref_get_peer_and_lock(&socket->xref);
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002589 if (!peer) {
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002590 hlua_pusherror(L, "socket: not yet initialised, you can't set timeouts.");
2591 WILL_LJMP(lua_error(L));
2592 return 0;
2593 }
2594 appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2595 si = appctx->owner;
2596 s = si_strm(si);
2597
Cyril Bonté7bb63452018-08-17 23:51:02 +02002598 s->sess->fe->timeout.connect = tmout;
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002599 s->req.rto = tmout;
2600 s->req.wto = tmout;
2601 s->res.rto = tmout;
2602 s->res.wto = tmout;
Cyril Bonté7bb63452018-08-17 23:51:02 +02002603 s->req.rex = tick_add_ifset(now_ms, tmout);
2604 s->req.wex = tick_add_ifset(now_ms, tmout);
2605 s->res.rex = tick_add_ifset(now_ms, tmout);
2606 s->res.wex = tick_add_ifset(now_ms, tmout);
2607
2608 s->task->expire = tick_add_ifset(now_ms, tmout);
2609 task_queue(s->task);
2610
Thierry FOURNIER952939d2017-09-01 14:17:32 +02002611 xref_unlock(&socket->xref, peer);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002612
Thierry Fourniere9636f12018-03-08 09:54:32 +01002613 lua_pushinteger(L, 1);
Tim Duesterhus119a5f12018-01-06 19:16:25 +01002614 return 1;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002615}
2616
2617__LJMP static int hlua_socket_new(lua_State *L)
2618{
2619 struct hlua_socket *socket;
2620 struct appctx *appctx;
Willy Tarreau15b5e142015-04-04 14:38:25 +02002621 struct session *sess;
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002622 struct stream *strm;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002623
2624 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002625 if (!lua_checkstack(L, 3)) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002626 hlua_pusherror(L, "socket: full stack");
2627 goto out_fail_conf;
2628 }
2629
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002630 /* Create the object: obj[0] = userdata. */
2631 lua_newtable(L);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002632 socket = MAY_LJMP(lua_newuserdata(L, sizeof(*socket)));
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002633 lua_rawseti(L, -2, 0);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002634 memset(socket, 0, sizeof(*socket));
Thierry FOURNIER94a6bfc2017-07-12 12:10:44 +02002635 socket->tid = tid;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002636
Thierry FOURNIER4a6170c2015-03-09 17:07:10 +01002637 /* Check if the various memory pools are intialized. */
Willy Tarreaubafbe012017-11-24 17:34:44 +01002638 if (!pool_head_stream || !pool_head_buffer) {
Thierry FOURNIER4a6170c2015-03-09 17:07:10 +01002639 hlua_pusherror(L, "socket: uninitialized pools.");
2640 goto out_fail_conf;
2641 }
2642
Willy Tarreau87b09662015-04-03 00:22:06 +02002643 /* Pop a class stream metatable and affect it to the userdata. */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002644 lua_rawgeti(L, LUA_REGISTRYINDEX, class_socket_ref);
2645 lua_setmetatable(L, -2);
2646
Willy Tarreaud420a972015-04-06 00:39:18 +02002647 /* Create the applet context */
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01002648 appctx = appctx_new(&update_applet, tid_bit);
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002649 if (!appctx) {
2650 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaufeb76402015-04-03 14:10:06 +02002651 goto out_fail_conf;
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002652 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002653
Thierry FOURNIER18d09902016-12-16 09:25:38 +01002654 appctx->ctx.hlua_cosocket.connected = 0;
Thierry FOURNIERb13b20a2017-07-16 20:48:54 +02002655 appctx->ctx.hlua_cosocket.die = 0;
Thierry FOURNIER18d09902016-12-16 09:25:38 +01002656 LIST_INIT(&appctx->ctx.hlua_cosocket.wake_on_write);
2657 LIST_INIT(&appctx->ctx.hlua_cosocket.wake_on_read);
Willy Tarreaub2bf8332015-04-04 15:58:58 +02002658
Willy Tarreaud420a972015-04-06 00:39:18 +02002659 /* Now create a session, task and stream for this applet */
2660 sess = session_new(&socket_proxy, NULL, &appctx->obj_type);
2661 if (!sess) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002662 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaud420a972015-04-06 00:39:18 +02002663 goto out_fail_sess;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002664 }
2665
Willy Tarreau87787ac2017-08-28 16:22:54 +02002666 strm = stream_new(sess, &appctx->obj_type);
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002667 if (!strm) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002668 hlua_pusherror(L, "socket: out of memory");
Willy Tarreaud420a972015-04-06 00:39:18 +02002669 goto out_fail_stream;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002670 }
2671
Thierry FOURNIER2da788e2017-09-11 18:37:23 +02002672 /* Initialise cross reference between stream and Lua socket object. */
2673 xref_create(&socket->xref, &appctx->ctx.hlua_cosocket.xref);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002674
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002675 /* Configure "right" stream interface. this "si" is used to connect
2676 * and retrieve data from the server. The connection is initialized
2677 * with the "struct server".
2678 */
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002679 si_set_state(&strm->si[1], SI_ST_ASS);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002680
2681 /* Force destination server. */
Willy Tarreau61cf7c82015-04-06 00:48:33 +02002682 strm->flags |= SF_DIRECT | SF_ASSIGNED | SF_ADDR_SET | SF_BE_ASSIGNED;
2683 strm->target = &socket_tcp.obj_type;
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002684
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002685 return 1;
2686
Willy Tarreaud420a972015-04-06 00:39:18 +02002687 out_fail_stream:
Willy Tarreau11c36242015-04-04 15:54:03 +02002688 session_free(sess);
Willy Tarreaud420a972015-04-06 00:39:18 +02002689 out_fail_sess:
2690 appctx_free(appctx);
2691 out_fail_conf:
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01002692 WILL_LJMP(lua_error(L));
2693 return 0;
2694}
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01002695
2696/*
2697 *
2698 *
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002699 * Class Channel
2700 *
2701 *
2702 */
2703
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01002704/* This function is called before the Lua execution. It stores
2705 * the differents parsers state before executing some Lua code.
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002706 */
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01002707static inline void consistency_set(struct stream *stream, int opt, struct hlua_consistency *c)
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002708{
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01002709 c->mode = stream->be->mode;
2710 switch (c->mode) {
2711 case PR_MODE_HTTP:
2712 c->data.http.dir = opt & SMP_OPT_DIR;
2713 if (c->data.http.dir == SMP_OPT_DIR_REQ)
2714 c->data.http.state = stream->txn->req.msg_state;
2715 else
2716 c->data.http.state = stream->txn->rsp.msg_state;
2717 break;
2718 default:
2719 break;
2720 }
2721}
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002722
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01002723/* This function is called after the Lua execution. it
2724 * returns true if the parser state is consistent, otherwise,
2725 * it return false.
2726 *
2727 * In HTTP mode, the parser state must be in the same state
2728 * or greater when we exit the function. Even if we do a
2729 * control yield. This prevent to break the HTTP message
2730 * from the Lua code.
2731 */
2732static inline int consistency_check(struct stream *stream, int opt, struct hlua_consistency *c)
2733{
2734 if (c->mode != stream->be->mode)
2735 return 0;
2736
2737 switch (c->mode) {
2738 case PR_MODE_HTTP:
2739 if (c->data.http.dir != (opt & SMP_OPT_DIR))
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002740 return 0;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01002741 if (c->data.http.dir == SMP_OPT_DIR_REQ)
2742 return stream->txn->req.msg_state >= c->data.http.state;
2743 else
2744 return stream->txn->rsp.msg_state >= c->data.http.state;
2745 default:
2746 return 1;
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02002747 }
2748 return 1;
2749}
2750
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002751/* Returns the struct hlua_channel join to the class channel in the
2752 * stack entry "ud" or throws an argument error.
2753 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002754__LJMP static struct channel *hlua_checkchannel(lua_State *L, int ud)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002755{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002756 return MAY_LJMP(hlua_checkudata(L, ud, class_channel_ref));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002757}
2758
Willy Tarreau47860ed2015-03-10 14:07:50 +01002759/* Pushes the channel onto the top of the stack. If the stask does not have a
2760 * free slots, the function fails and returns 0;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002761 */
Willy Tarreau2a71af42015-03-10 13:51:50 +01002762static int hlua_channel_new(lua_State *L, struct channel *channel)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002763{
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002764 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002765 if (!lua_checkstack(L, 3))
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002766 return 0;
2767
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002768 lua_newtable(L);
Willy Tarreau47860ed2015-03-10 14:07:50 +01002769 lua_pushlightuserdata(L, channel);
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01002770 lua_rawseti(L, -2, 0);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002771
2772 /* Pop a class sesison metatable and affect it to the userdata. */
2773 lua_rawgeti(L, LUA_REGISTRYINDEX, class_channel_ref);
2774 lua_setmetatable(L, -2);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002775 return 1;
2776}
2777
2778/* Duplicate all the data present in the input channel and put it
2779 * in a string LUA variables. Returns -1 and push a nil value in
2780 * the stack if the channel is closed and all the data are consumed,
2781 * returns 0 if no data are available, otherwise it returns the length
2782 * of the builded string.
2783 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01002784static inline int _hlua_channel_dup(struct channel *chn, lua_State *L)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002785{
2786 char *blk1;
2787 char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02002788 size_t len1;
2789 size_t len2;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002790 int ret;
2791 luaL_Buffer b;
2792
Willy Tarreau06d80a92017-10-19 14:32:15 +02002793 ret = ci_getblk_nc(chn, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002794 if (unlikely(ret == 0))
2795 return 0;
2796
2797 if (unlikely(ret < 0)) {
2798 lua_pushnil(L);
2799 return -1;
2800 }
2801
2802 luaL_buffinit(L, &b);
2803 luaL_addlstring(&b, blk1, len1);
2804 if (unlikely(ret == 2))
2805 luaL_addlstring(&b, blk2, len2);
2806 luaL_pushresult(&b);
2807
2808 if (unlikely(ret == 2))
2809 return len1 + len2;
2810 return len1;
2811}
2812
2813/* "_hlua_channel_dup" wrapper. If no data are available, it returns
2814 * a yield. This function keep the data in the buffer.
2815 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002816__LJMP static int hlua_channel_dup_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002817{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002818 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002819
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002820 chn = MAY_LJMP(hlua_checkchannel(L, 1));
2821
Christopher Faulet3f829a42018-12-13 21:56:45 +01002822 if (chn_strm(chn)->be->mode == PR_MODE_HTTP)
2823 WILL_LJMP(lua_error(L));
2824
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002825 if (_hlua_channel_dup(chn, L) == 0)
Willy Tarreau9635e032018-10-16 17:52:55 +02002826 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_dup_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002827 return 1;
2828}
2829
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002830/* Check arguments for the function "hlua_channel_dup_yield". */
2831__LJMP static int hlua_channel_dup(lua_State *L)
2832{
2833 MAY_LJMP(check_args(L, 1, "dup"));
2834 MAY_LJMP(hlua_checkchannel(L, 1));
2835 return MAY_LJMP(hlua_channel_dup_yield(L, 0, 0));
2836}
2837
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002838/* "_hlua_channel_dup" wrapper. If no data are available, it returns
2839 * a yield. This function consumes the data in the buffer. It returns
2840 * a string containing the data or a nil pointer if no data are available
2841 * and the channel is closed.
2842 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002843__LJMP static int hlua_channel_get_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002844{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002845 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002846 int ret;
2847
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002848 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002849
Christopher Faulet3f829a42018-12-13 21:56:45 +01002850 if (chn_strm(chn)->be->mode == PR_MODE_HTTP)
2851 WILL_LJMP(lua_error(L));
2852
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002853 ret = _hlua_channel_dup(chn, L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002854 if (unlikely(ret == 0))
Willy Tarreau9635e032018-10-16 17:52:55 +02002855 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_get_yield, TICK_ETERNITY, 0));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002856
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002857 if (unlikely(ret == -1))
2858 return 1;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002859
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002860 b_sub(&chn->buf, ret);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002861 return 1;
2862}
2863
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002864/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002865__LJMP static int hlua_channel_get(lua_State *L)
2866{
2867 MAY_LJMP(check_args(L, 1, "get"));
2868 MAY_LJMP(hlua_checkchannel(L, 1));
2869 return MAY_LJMP(hlua_channel_get_yield(L, 0, 0));
2870}
2871
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002872/* This functions consumes and returns one line. If the channel is closed,
2873 * and the last data does not contains a final '\n', the data are returned
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002874 * without the final '\n'. When no more data are available, it returns nil
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002875 * value.
2876 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002877__LJMP static int hlua_channel_getline_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002878{
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002879 char *blk1;
2880 char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02002881 size_t len1;
2882 size_t len2;
2883 size_t len;
Willy Tarreau47860ed2015-03-10 14:07:50 +01002884 struct channel *chn;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002885 int ret;
2886 luaL_Buffer b;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002887
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002888 chn = MAY_LJMP(hlua_checkchannel(L, 1));
2889
Christopher Faulet3f829a42018-12-13 21:56:45 +01002890 if (chn_strm(chn)->be->mode == PR_MODE_HTTP)
2891 WILL_LJMP(lua_error(L));
2892
Willy Tarreau06d80a92017-10-19 14:32:15 +02002893 ret = ci_getline_nc(chn, &blk1, &len1, &blk2, &len2);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002894 if (ret == 0)
Willy Tarreau9635e032018-10-16 17:52:55 +02002895 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_getline_yield, TICK_ETERNITY, 0));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01002896
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002897 if (ret == -1) {
2898 lua_pushnil(L);
2899 return 1;
2900 }
2901
2902 luaL_buffinit(L, &b);
2903 luaL_addlstring(&b, blk1, len1);
2904 len = len1;
2905 if (unlikely(ret == 2)) {
2906 luaL_addlstring(&b, blk2, len2);
2907 len += len2;
2908 }
2909 luaL_pushresult(&b);
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002910 b_rep_blk(&chn->buf, ci_head(chn), ci_head(chn) + len, NULL, 0);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002911 return 1;
2912}
2913
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002914/* Check arguments for the function "hlua_channel_getline_yield". */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002915__LJMP static int hlua_channel_getline(lua_State *L)
2916{
2917 MAY_LJMP(check_args(L, 1, "getline"));
2918 MAY_LJMP(hlua_checkchannel(L, 1));
2919 return MAY_LJMP(hlua_channel_getline_yield(L, 0, 0));
2920}
2921
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002922/* This function takes a string as input, and append it at the
2923 * input side of channel. If the data is too big, but a space
2924 * is probably available after sending some data, the function
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002925 * yields. If the data is bigger than the buffer, or if the
2926 * channel is closed, it returns -1. Otherwise, it returns the
2927 * amount of data written.
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002928 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002929__LJMP static int hlua_channel_append_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002930{
Willy Tarreau47860ed2015-03-10 14:07:50 +01002931 struct channel *chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002932 size_t len;
2933 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
2934 int l = MAY_LJMP(luaL_checkinteger(L, 3));
2935 int ret;
2936 int max;
2937
Christopher Faulet3f829a42018-12-13 21:56:45 +01002938 if (chn_strm(chn)->be->mode == PR_MODE_HTTP)
2939 WILL_LJMP(lua_error(L));
2940
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002941 /* Check if the buffer is available because HAProxy doesn't allocate
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002942 * the request buffer if its not required.
2943 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002944 if (chn->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +01002945 si_rx_buff_blk(chn_prod(chn));
Willy Tarreau9635e032018-10-16 17:52:55 +02002946 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
Christopher Fauleta73e59b2016-12-09 17:30:18 +01002947 }
2948
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002949 max = channel_recv_limit(chn) - b_data(&chn->buf);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002950 if (max > len - l)
2951 max = len - l;
2952
Willy Tarreau06d80a92017-10-19 14:32:15 +02002953 ret = ci_putblk(chn, str + l, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002954 if (ret == -2 || ret == -3) {
2955 lua_pushinteger(L, -1);
2956 return 1;
2957 }
Willy Tarreaubc18da12015-03-13 14:00:47 +01002958 if (ret == -1) {
2959 chn->flags |= CF_WAKE_WRITE;
Willy Tarreau9635e032018-10-16 17:52:55 +02002960 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
Willy Tarreaubc18da12015-03-13 14:00:47 +01002961 }
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002962 l += ret;
2963 lua_pop(L, 1);
2964 lua_pushinteger(L, l);
2965
Willy Tarreauc9fa0482018-07-10 17:43:27 +02002966 max = channel_recv_limit(chn) - b_data(&chn->buf);
Willy Tarreaua79021a2018-06-15 18:07:57 +02002967 if (max == 0 && co_data(chn) == 0) {
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002968 /* There are no space available, and the output buffer is empty.
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002969 * in this case, we cannot add more data, so we cannot yield,
2970 * we return the amount of copyied data.
2971 */
2972 return 1;
2973 }
2974 if (l < len)
Willy Tarreau9635e032018-10-16 17:52:55 +02002975 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002976 return 1;
2977}
2978
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002979/* Just a wrapper of "hlua_channel_append_yield". It returns the length
2980 * of the written string, or -1 if the channel is closed or if the
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002981 * buffer size is too little for the data.
2982 */
2983__LJMP static int hlua_channel_append(lua_State *L)
2984{
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002985 size_t len;
2986
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002987 MAY_LJMP(check_args(L, 2, "append"));
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002988 MAY_LJMP(hlua_checkchannel(L, 1));
2989 MAY_LJMP(luaL_checklstring(L, 2, &len));
2990 MAY_LJMP(luaL_checkinteger(L, 3));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002991 lua_pushinteger(L, 0);
2992
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01002993 return MAY_LJMP(hlua_channel_append_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002994}
2995
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002996/* Just a wrapper of "hlua_channel_append_yield". This wrapper starts
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002997 * his process by cleaning the buffer. The result is a replacement
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08002998 * of the current data. It returns the length of the written string,
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01002999 * or -1 if the channel is closed or if the buffer size is too
3000 * little for the data.
3001 */
3002__LJMP static int hlua_channel_set(lua_State *L)
3003{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003004 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003005
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003006 MAY_LJMP(check_args(L, 2, "set"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003007 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003008 lua_pushinteger(L, 0);
3009
Christopher Faulet3f829a42018-12-13 21:56:45 +01003010 if (chn_strm(chn)->be->mode == PR_MODE_HTTP)
3011 WILL_LJMP(lua_error(L));
3012
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003013 b_set_data(&chn->buf, co_data(chn));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003014
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003015 return MAY_LJMP(hlua_channel_append_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003016}
3017
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003018/* Append data in the output side of the buffer. This data is immediately
3019 * sent. The function returns the amount of data written. If the buffer
3020 * cannot contain the data, the function yields. The function returns -1
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003021 * if the channel is closed.
3022 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003023__LJMP static int hlua_channel_send_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003024{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003025 struct channel *chn = MAY_LJMP(hlua_checkchannel(L, 1));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003026 size_t len;
3027 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
3028 int l = MAY_LJMP(luaL_checkinteger(L, 3));
3029 int max;
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003030 struct hlua *hlua = hlua_gethlua(L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003031
Christopher Faulet3f829a42018-12-13 21:56:45 +01003032 if (chn_strm(chn)->be->mode == PR_MODE_HTTP)
3033 WILL_LJMP(lua_error(L));
3034
Willy Tarreau47860ed2015-03-10 14:07:50 +01003035 if (unlikely(channel_output_closed(chn))) {
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003036 lua_pushinteger(L, -1);
3037 return 1;
3038 }
3039
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003040 /* Check if the buffer is available because HAProxy doesn't allocate
Thierry FOURNIER3e3a6082015-03-05 17:06:12 +01003041 * the request buffer if its not required.
3042 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003043 if (chn->buf.size == 0) {
Willy Tarreau4b962a42018-11-15 11:03:21 +01003044 si_rx_buff_blk(chn_prod(chn));
Willy Tarreau9635e032018-10-16 17:52:55 +02003045 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIER3e3a6082015-03-05 17:06:12 +01003046 }
3047
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003048 /* The written data will be immediately sent, so we can check
3049 * the available space without taking in account the reserve.
3050 * The reserve is guaranteed for the processing of incoming
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003051 * data, because the buffer will be flushed.
3052 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003053 max = b_room(&chn->buf);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003054
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003055 /* If there is no space available, and the output buffer is empty.
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003056 * in this case, we cannot add more data, so we cannot yield,
3057 * we return the amount of copyied data.
3058 */
Willy Tarreaua79021a2018-06-15 18:07:57 +02003059 if (max == 0 && co_data(chn) == 0)
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003060 return 1;
3061
3062 /* Adjust the real required length. */
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003063 if (max > len - l)
3064 max = len - l;
3065
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003066 /* The buffer available size may be not contiguous. This test
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003067 * detects a non contiguous buffer and realign it.
3068 */
Willy Tarreau3f679992018-06-15 15:06:42 +02003069 if (ci_space_for_replace(chn) < max)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003070 channel_slow_realign(chn, trash.area);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003071
3072 /* Copy input data in the buffer. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003073 max = b_rep_blk(&chn->buf, ci_head(chn), ci_head(chn), str + l, max);
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003074
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003075 /* buffer replace considers that the input part is filled.
3076 * so, I must forward these new data in the output part.
3077 */
Willy Tarreaubcbd3932018-06-06 07:13:22 +02003078 c_adv(chn, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003079
3080 l += max;
3081 lua_pop(L, 1);
3082 lua_pushinteger(L, l);
3083
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003084 /* If there is no space available, and the output buffer is empty.
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003085 * in this case, we cannot add more data, so we cannot yield,
3086 * we return the amount of copyied data.
3087 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003088 max = b_room(&chn->buf);
Willy Tarreaua79021a2018-06-15 18:07:57 +02003089 if (max == 0 && co_data(chn) == 0)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003090 return 1;
Thierry FOURNIERdeb5d732015-03-06 01:07:45 +01003091
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003092 if (l < len) {
3093 /* If we are waiting for space in the response buffer, we
3094 * must set the flag WAKERESWR. This flag required the task
3095 * wake up if any activity is detected on the response buffer.
3096 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01003097 if (chn->flags & CF_ISRESP)
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003098 HLUA_SET_WAKERESWR(hlua);
Thierry FOURNIER53e08ec2015-03-06 00:35:53 +01003099 else
3100 HLUA_SET_WAKEREQWR(hlua);
Willy Tarreau9635e032018-10-16 17:52:55 +02003101 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003102 }
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003103
3104 return 1;
3105}
3106
3107/* Just a wraper of "_hlua_channel_send". This wrapper permits
3108 * yield the LUA process, and resume it without checking the
3109 * input arguments.
3110 */
3111__LJMP static int hlua_channel_send(lua_State *L)
3112{
3113 MAY_LJMP(check_args(L, 2, "send"));
3114 lua_pushinteger(L, 0);
3115
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003116 return MAY_LJMP(hlua_channel_send_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003117}
3118
3119/* This function forward and amount of butes. The data pass from
3120 * the input side of the buffer to the output side, and can be
3121 * forwarded. This function never fails.
3122 *
3123 * The Lua function takes an amount of bytes to be forwarded in
3124 * imput. It returns the number of bytes forwarded.
3125 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003126__LJMP static int hlua_channel_forward_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003127{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003128 struct channel *chn;
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003129 int len;
3130 int l;
3131 int max;
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003132 struct hlua *hlua = hlua_gethlua(L);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003133
3134 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Christopher Faulet3f829a42018-12-13 21:56:45 +01003135
3136 if (chn_strm(chn)->be->mode == PR_MODE_HTTP)
3137 WILL_LJMP(lua_error(L));
3138
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003139 len = MAY_LJMP(luaL_checkinteger(L, 2));
3140 l = MAY_LJMP(luaL_checkinteger(L, -1));
3141
3142 max = len - l;
Willy Tarreaua79021a2018-06-15 18:07:57 +02003143 if (max > ci_data(chn))
3144 max = ci_data(chn);
Willy Tarreau47860ed2015-03-10 14:07:50 +01003145 channel_forward(chn, max);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003146 l += max;
3147
3148 lua_pop(L, 1);
3149 lua_pushinteger(L, l);
3150
3151 /* Check if it miss bytes to forward. */
3152 if (l < len) {
3153 /* The the input channel or the output channel are closed, we
3154 * must return the amount of data forwarded.
3155 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01003156 if (channel_input_closed(chn) || channel_output_closed(chn))
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003157 return 1;
3158
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003159 /* If we are waiting for space data in the response buffer, we
3160 * must set the flag WAKERESWR. This flag required the task
3161 * wake up if any activity is detected on the response buffer.
3162 */
Willy Tarreau47860ed2015-03-10 14:07:50 +01003163 if (chn->flags & CF_ISRESP)
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003164 HLUA_SET_WAKERESWR(hlua);
Thierry FOURNIER53e08ec2015-03-06 00:35:53 +01003165 else
3166 HLUA_SET_WAKEREQWR(hlua);
Thierry FOURNIERef6a2112015-03-05 17:45:34 +01003167
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003168 /* Otherwise, we can yield waiting for new data in the inpout side. */
Willy Tarreau9635e032018-10-16 17:52:55 +02003169 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_forward_yield, TICK_ETERNITY, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003170 }
3171
3172 return 1;
3173}
3174
3175/* Just check the input and prepare the stack for the previous
3176 * function "hlua_channel_forward_yield"
3177 */
3178__LJMP static int hlua_channel_forward(lua_State *L)
3179{
3180 MAY_LJMP(check_args(L, 2, "forward"));
3181 MAY_LJMP(hlua_checkchannel(L, 1));
3182 MAY_LJMP(luaL_checkinteger(L, 2));
3183
3184 lua_pushinteger(L, 0);
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01003185 return MAY_LJMP(hlua_channel_forward_yield(L, 0, 0));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003186}
3187
3188/* Just returns the number of bytes available in the input
3189 * side of the buffer. This function never fails.
3190 */
3191__LJMP static int hlua_channel_get_in_len(lua_State *L)
3192{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003193 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003194
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003195 MAY_LJMP(check_args(L, 1, "get_in_len"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003196 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Christopher Fauleta3ceac12018-12-14 13:39:09 +01003197 if (IS_HTX_STRM(chn_strm(chn))) {
3198 struct htx *htx = htxbuf(&chn->buf);
3199 lua_pushinteger(L, htx->data - co_data(chn));
3200 }
3201 else
3202 lua_pushinteger(L, ci_data(chn));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003203 return 1;
3204}
3205
Thierry FOURNIER / OZON.IO65192f32016-11-07 15:28:40 +01003206/* Returns true if the channel is full. */
3207__LJMP static int hlua_channel_is_full(lua_State *L)
3208{
3209 struct channel *chn;
3210 int rem;
3211
3212 MAY_LJMP(check_args(L, 1, "is_full"));
3213 chn = MAY_LJMP(hlua_checkchannel(L, 1));
3214
Christopher Fauleta3ceac12018-12-14 13:39:09 +01003215 if (IS_HTX_STRM(chn_strm(chn))) {
3216 struct htx *htx = htxbuf(&chn->buf);
3217
3218 rem = htx_free_data_space(htx);
3219 }
3220 else
3221 rem = b_room(&chn->buf);
3222
Thierry FOURNIER / OZON.IO65192f32016-11-07 15:28:40 +01003223 rem -= global.tune.maxrewrite; /* Rewrite reserved size */
3224
3225 lua_pushboolean(L, rem <= 0);
3226 return 1;
3227}
3228
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003229/* Just returns the number of bytes available in the output
3230 * side of the buffer. This function never fails.
3231 */
3232__LJMP static int hlua_channel_get_out_len(lua_State *L)
3233{
Willy Tarreau47860ed2015-03-10 14:07:50 +01003234 struct channel *chn;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003235
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003236 MAY_LJMP(check_args(L, 1, "get_out_len"));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01003237 chn = MAY_LJMP(hlua_checkchannel(L, 1));
Willy Tarreaua79021a2018-06-15 18:07:57 +02003238 lua_pushinteger(L, co_data(chn));
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003239 return 1;
3240}
3241
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003242/*
3243 *
3244 *
3245 * Class Fetches
3246 *
3247 *
3248 */
3249
3250/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02003251 * a class stream, otherwise it throws an error.
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003252 */
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003253__LJMP static struct hlua_smp *hlua_checkfetches(lua_State *L, int ud)
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003254{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003255 return MAY_LJMP(hlua_checkudata(L, ud, class_fetches_ref));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003256}
3257
3258/* This function creates and push in the stack a fetch object according
3259 * with a current TXN.
3260 */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003261static int hlua_fetches_new(lua_State *L, struct hlua_txn *txn, unsigned int flags)
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003262{
Willy Tarreau7073c472015-04-06 11:15:40 +02003263 struct hlua_smp *hsmp;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003264
3265 /* Check stack size. */
3266 if (!lua_checkstack(L, 3))
3267 return 0;
3268
3269 /* Create the object: obj[0] = userdata.
3270 * Note that the base of the Fetches object is the
3271 * transaction object.
3272 */
3273 lua_newtable(L);
Willy Tarreau7073c472015-04-06 11:15:40 +02003274 hsmp = lua_newuserdata(L, sizeof(*hsmp));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003275 lua_rawseti(L, -2, 0);
3276
Willy Tarreau7073c472015-04-06 11:15:40 +02003277 hsmp->s = txn->s;
3278 hsmp->p = txn->p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01003279 hsmp->dir = txn->dir;
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003280 hsmp->flags = flags;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003281
3282 /* Pop a class sesison metatable and affect it to the userdata. */
3283 lua_rawgeti(L, LUA_REGISTRYINDEX, class_fetches_ref);
3284 lua_setmetatable(L, -2);
3285
3286 return 1;
3287}
3288
3289/* This function is an LUA binding. It is called with each sample-fetch.
3290 * It uses closure argument to store the associated sample-fetch. It
3291 * returns only one argument or throws an error. An error is thrown
3292 * only if an error is encountered during the argument parsing. If
3293 * the "sample-fetch" function fails, nil is returned.
3294 */
3295__LJMP static int hlua_run_sample_fetch(lua_State *L)
3296{
Willy Tarreaub2ccb562015-04-06 11:11:15 +02003297 struct hlua_smp *hsmp;
Willy Tarreau2ec22742015-03-10 14:27:20 +01003298 struct sample_fetch *f;
Frédéric Lécaillef874a832018-06-15 13:56:04 +02003299 struct arg args[ARGM_NBARGS + 1] = {{0}};
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003300 int i;
3301 struct sample smp;
3302
3303 /* Get closure arguments. */
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003304 f = lua_touserdata(L, lua_upvalueindex(1));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003305
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003306 /* Get traditional arguments. */
Willy Tarreaub2ccb562015-04-06 11:11:15 +02003307 hsmp = MAY_LJMP(hlua_checkfetches(L, 1));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003308
Thierry FOURNIERca988662015-12-20 18:43:03 +01003309 /* Check execution authorization. */
3310 if (f->use & SMP_USE_HTTP_ANY &&
3311 !(hsmp->flags & HLUA_F_MAY_USE_HTTP)) {
3312 lua_pushfstring(L, "the sample-fetch '%s' needs an HTTP parser which "
3313 "is not available in Lua services", f->kw);
3314 WILL_LJMP(lua_error(L));
3315 }
3316
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003317 /* Get extra arguments. */
3318 for (i = 0; i < lua_gettop(L) - 1; i++) {
3319 if (i >= ARGM_NBARGS)
3320 break;
3321 hlua_lua2arg(L, i + 2, &args[i]);
3322 }
3323 args[i].type = ARGT_STOP;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003324 args[i].data.str.area = NULL;
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003325
3326 /* Check arguments. */
Willy Tarreaub2ccb562015-04-06 11:11:15 +02003327 MAY_LJMP(hlua_lua2arg_check(L, 2, args, f->arg_mask, hsmp->p));
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003328
3329 /* Run the special args checker. */
Willy Tarreau2ec22742015-03-10 14:27:20 +01003330 if (f->val_args && !f->val_args(args, NULL)) {
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003331 lua_pushfstring(L, "error in arguments");
3332 WILL_LJMP(lua_error(L));
3333 }
3334
3335 /* Initialise the sample. */
3336 memset(&smp, 0, sizeof(smp));
3337
3338 /* Run the sample fetch process. */
Willy Tarreau1777ea62016-03-10 16:15:46 +01003339 smp_set_owner(&smp, hsmp->p, hsmp->s->sess, hsmp->s, hsmp->dir & SMP_OPT_DIR);
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003340 if (!f->process(args, &smp, f->kw, f->private)) {
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003341 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003342 lua_pushstring(L, "");
3343 else
3344 lua_pushnil(L);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003345 return 1;
3346 }
3347
3348 /* Convert the returned sample in lua value. */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003349 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003350 hlua_smp2lua_str(L, &smp);
3351 else
3352 hlua_smp2lua(L, &smp);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01003353 return 1;
3354}
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01003355
3356/*
3357 *
3358 *
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003359 * Class Converters
3360 *
3361 *
3362 */
3363
3364/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02003365 * a class stream, otherwise it throws an error.
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003366 */
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003367__LJMP static struct hlua_smp *hlua_checkconverters(lua_State *L, int ud)
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003368{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003369 return MAY_LJMP(hlua_checkudata(L, ud, class_converters_ref));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003370}
3371
3372/* This function creates and push in the stack a Converters object
3373 * according with a current TXN.
3374 */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003375static int hlua_converters_new(lua_State *L, struct hlua_txn *txn, unsigned int flags)
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003376{
Willy Tarreau7073c472015-04-06 11:15:40 +02003377 struct hlua_smp *hsmp;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003378
3379 /* Check stack size. */
3380 if (!lua_checkstack(L, 3))
3381 return 0;
3382
3383 /* Create the object: obj[0] = userdata.
3384 * Note that the base of the Converters object is the
3385 * same than the TXN object.
3386 */
3387 lua_newtable(L);
Willy Tarreau7073c472015-04-06 11:15:40 +02003388 hsmp = lua_newuserdata(L, sizeof(*hsmp));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003389 lua_rawseti(L, -2, 0);
3390
Willy Tarreau7073c472015-04-06 11:15:40 +02003391 hsmp->s = txn->s;
3392 hsmp->p = txn->p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01003393 hsmp->dir = txn->dir;
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003394 hsmp->flags = flags;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003395
Willy Tarreau87b09662015-04-03 00:22:06 +02003396 /* Pop a class stream metatable and affect it to the table. */
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003397 lua_rawgeti(L, LUA_REGISTRYINDEX, class_converters_ref);
3398 lua_setmetatable(L, -2);
3399
3400 return 1;
3401}
3402
3403/* This function is an LUA binding. It is called with each converter.
3404 * It uses closure argument to store the associated converter. It
3405 * returns only one argument or throws an error. An error is thrown
3406 * only if an error is encountered during the argument parsing. If
3407 * the converter function function fails, nil is returned.
3408 */
3409__LJMP static int hlua_run_sample_conv(lua_State *L)
3410{
Willy Tarreauda5f1082015-04-06 11:17:13 +02003411 struct hlua_smp *hsmp;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003412 struct sample_conv *conv;
Frédéric Lécaillef874a832018-06-15 13:56:04 +02003413 struct arg args[ARGM_NBARGS + 1] = {{0}};
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003414 int i;
3415 struct sample smp;
3416
3417 /* Get closure arguments. */
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003418 conv = lua_touserdata(L, lua_upvalueindex(1));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003419
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003420 /* Get traditional arguments. */
Willy Tarreauda5f1082015-04-06 11:17:13 +02003421 hsmp = MAY_LJMP(hlua_checkconverters(L, 1));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003422
3423 /* Get extra arguments. */
3424 for (i = 0; i < lua_gettop(L) - 2; i++) {
3425 if (i >= ARGM_NBARGS)
3426 break;
3427 hlua_lua2arg(L, i + 3, &args[i]);
3428 }
3429 args[i].type = ARGT_STOP;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003430 args[i].data.str.area = NULL;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003431
3432 /* Check arguments. */
Willy Tarreauda5f1082015-04-06 11:17:13 +02003433 MAY_LJMP(hlua_lua2arg_check(L, 3, args, conv->arg_mask, hsmp->p));
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003434
3435 /* Run the special args checker. */
3436 if (conv->val_args && !conv->val_args(args, conv, "", 0, NULL)) {
3437 hlua_pusherror(L, "error in arguments");
3438 WILL_LJMP(lua_error(L));
3439 }
3440
3441 /* Initialise the sample. */
3442 if (!hlua_lua2smp(L, 2, &smp)) {
3443 hlua_pusherror(L, "error in the input argument");
3444 WILL_LJMP(lua_error(L));
3445 }
3446
Willy Tarreau1777ea62016-03-10 16:15:46 +01003447 smp_set_owner(&smp, hsmp->p, hsmp->s->sess, hsmp->s, hsmp->dir & SMP_OPT_DIR);
3448
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003449 /* Apply expected cast. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003450 if (!sample_casts[smp.data.type][conv->in_type]) {
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003451 hlua_pusherror(L, "invalid input argument: cannot cast '%s' to '%s'",
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003452 smp_to_type[smp.data.type], smp_to_type[conv->in_type]);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003453 WILL_LJMP(lua_error(L));
3454 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003455 if (sample_casts[smp.data.type][conv->in_type] != c_none &&
3456 !sample_casts[smp.data.type][conv->in_type](&smp)) {
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003457 hlua_pusherror(L, "error during the input argument casting");
3458 WILL_LJMP(lua_error(L));
3459 }
3460
3461 /* Run the sample conversion process. */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02003462 if (!conv->process(args, &smp, conv->private)) {
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003463 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003464 lua_pushstring(L, "");
3465 else
Willy Tarreaua678b432015-08-28 10:14:59 +02003466 lua_pushnil(L);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003467 return 1;
3468 }
3469
3470 /* Convert the returned sample in lua value. */
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003471 if (hsmp->flags & HLUA_F_AS_STRING)
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01003472 hlua_smp2lua_str(L, &smp);
3473 else
3474 hlua_smp2lua(L, &smp);
Willy Tarreaua678b432015-08-28 10:14:59 +02003475 return 1;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003476}
3477
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003478/*
3479 *
3480 *
3481 * Class AppletTCP
3482 *
3483 *
3484 */
3485
3486/* Returns a struct hlua_txn if the stack entry "ud" is
3487 * a class stream, otherwise it throws an error.
3488 */
3489__LJMP static struct hlua_appctx *hlua_checkapplet_tcp(lua_State *L, int ud)
3490{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003491 return MAY_LJMP(hlua_checkudata(L, ud, class_applet_tcp_ref));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003492}
3493
3494/* This function creates and push in the stack an Applet object
3495 * according with a current TXN.
3496 */
3497static int hlua_applet_tcp_new(lua_State *L, struct appctx *ctx)
3498{
3499 struct hlua_appctx *appctx;
3500 struct stream_interface *si = ctx->owner;
3501 struct stream *s = si_strm(si);
3502 struct proxy *p = s->be;
3503
3504 /* Check stack size. */
3505 if (!lua_checkstack(L, 3))
3506 return 0;
3507
3508 /* Create the object: obj[0] = userdata.
3509 * Note that the base of the Converters object is the
3510 * same than the TXN object.
3511 */
3512 lua_newtable(L);
3513 appctx = lua_newuserdata(L, sizeof(*appctx));
3514 lua_rawseti(L, -2, 0);
3515 appctx->appctx = ctx;
3516 appctx->htxn.s = s;
3517 appctx->htxn.p = p;
3518
3519 /* Create the "f" field that contains a list of fetches. */
3520 lua_pushstring(L, "f");
3521 if (!hlua_fetches_new(L, &appctx->htxn, 0))
3522 return 0;
3523 lua_settable(L, -3);
3524
3525 /* Create the "sf" field that contains a list of stringsafe fetches. */
3526 lua_pushstring(L, "sf");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003527 if (!hlua_fetches_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003528 return 0;
3529 lua_settable(L, -3);
3530
3531 /* Create the "c" field that contains a list of converters. */
3532 lua_pushstring(L, "c");
3533 if (!hlua_converters_new(L, &appctx->htxn, 0))
3534 return 0;
3535 lua_settable(L, -3);
3536
3537 /* Create the "sc" field that contains a list of stringsafe converters. */
3538 lua_pushstring(L, "sc");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003539 if (!hlua_converters_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003540 return 0;
3541 lua_settable(L, -3);
3542
3543 /* Pop a class stream metatable and affect it to the table. */
3544 lua_rawgeti(L, LUA_REGISTRYINDEX, class_applet_tcp_ref);
3545 lua_setmetatable(L, -2);
3546
3547 return 1;
3548}
3549
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01003550__LJMP static int hlua_applet_tcp_set_var(lua_State *L)
3551{
3552 struct hlua_appctx *appctx;
3553 struct stream *s;
3554 const char *name;
3555 size_t len;
3556 struct sample smp;
3557
3558 MAY_LJMP(check_args(L, 3, "set_var"));
3559
3560 /* It is useles to retrieve the stream, but this function
3561 * runs only in a stream context.
3562 */
3563 appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3564 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3565 s = appctx->htxn.s;
3566
3567 /* Converts the third argument in a sample. */
3568 hlua_lua2smp(L, 3, &smp);
3569
3570 /* Store the sample in a variable. */
3571 smp_set_owner(&smp, s->be, s->sess, s, 0);
3572 vars_set_by_name(name, len, &smp);
3573 return 0;
3574}
3575
3576__LJMP static int hlua_applet_tcp_unset_var(lua_State *L)
3577{
3578 struct hlua_appctx *appctx;
3579 struct stream *s;
3580 const char *name;
3581 size_t len;
3582 struct sample smp;
3583
3584 MAY_LJMP(check_args(L, 2, "unset_var"));
3585
3586 /* It is useles to retrieve the stream, but this function
3587 * runs only in a stream context.
3588 */
3589 appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3590 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3591 s = appctx->htxn.s;
3592
3593 /* Unset the variable. */
3594 smp_set_owner(&smp, s->be, s->sess, s, 0);
3595 vars_unset_by_name(name, len, &smp);
3596 return 0;
3597}
3598
3599__LJMP static int hlua_applet_tcp_get_var(lua_State *L)
3600{
3601 struct hlua_appctx *appctx;
3602 struct stream *s;
3603 const char *name;
3604 size_t len;
3605 struct sample smp;
3606
3607 MAY_LJMP(check_args(L, 2, "get_var"));
3608
3609 /* It is useles to retrieve the stream, but this function
3610 * runs only in a stream context.
3611 */
3612 appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3613 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3614 s = appctx->htxn.s;
3615
3616 smp_set_owner(&smp, s->be, s->sess, s, 0);
3617 if (!vars_get_by_name(name, len, &smp)) {
3618 lua_pushnil(L);
3619 return 1;
3620 }
3621
3622 return hlua_smp2lua(L, &smp);
3623}
3624
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003625__LJMP static int hlua_applet_tcp_set_priv(lua_State *L)
3626{
3627 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3628 struct stream *s = appctx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01003629 struct hlua *hlua;
3630
3631 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01003632 if (!s->hlua)
3633 return 0;
3634 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003635
3636 MAY_LJMP(check_args(L, 2, "set_priv"));
3637
3638 /* Remove previous value. */
Thierry FOURNIERe068b602017-04-26 13:27:05 +02003639 luaL_unref(L, LUA_REGISTRYINDEX, hlua->Mref);
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003640
3641 /* Get and store new value. */
3642 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
3643 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
3644
3645 return 0;
3646}
3647
3648__LJMP static int hlua_applet_tcp_get_priv(lua_State *L)
3649{
3650 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3651 struct stream *s = appctx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01003652 struct hlua *hlua;
3653
3654 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01003655 if (!s->hlua) {
3656 lua_pushnil(L);
3657 return 1;
3658 }
3659 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01003660
3661 /* Push configuration index in the stack. */
3662 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
3663
3664 return 1;
3665}
3666
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003667/* If expected data not yet available, it returns a yield. This function
3668 * consumes the data in the buffer. It returns a string containing the
3669 * data. This string can be empty.
3670 */
3671__LJMP static int hlua_applet_tcp_getline_yield(lua_State *L, int status, lua_KContext ctx)
3672{
3673 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3674 struct stream_interface *si = appctx->appctx->owner;
3675 int ret;
Willy Tarreau206ba832018-06-14 15:27:31 +02003676 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003677 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02003678 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003679 size_t len2;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003680
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003681 /* Read the maximum amount of data available. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003682 ret = co_getline_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003683
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003684 /* Data not yet available. return yield. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003685 if (ret == 0) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01003686 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003687 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_getline_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003688 }
3689
3690 /* End of data: commit the total strings and return. */
3691 if (ret < 0) {
3692 luaL_pushresult(&appctx->b);
3693 return 1;
3694 }
3695
3696 /* Ensure that the block 2 length is usable. */
3697 if (ret == 1)
3698 len2 = 0;
3699
3700 /* dont check the max length read and dont check. */
3701 luaL_addlstring(&appctx->b, blk1, len1);
3702 luaL_addlstring(&appctx->b, blk2, len2);
3703
3704 /* Consume input channel output buffer data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003705 co_skip(si_oc(si), len1 + len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003706 luaL_pushresult(&appctx->b);
3707 return 1;
3708}
3709
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003710/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003711__LJMP static int hlua_applet_tcp_getline(lua_State *L)
3712{
3713 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3714
3715 /* Initialise the string catenation. */
3716 luaL_buffinit(L, &appctx->b);
3717
3718 return MAY_LJMP(hlua_applet_tcp_getline_yield(L, 0, 0));
3719}
3720
3721/* If expected data not yet available, it returns a yield. This function
3722 * consumes the data in the buffer. It returns a string containing the
3723 * data. This string can be empty.
3724 */
3725__LJMP static int hlua_applet_tcp_recv_yield(lua_State *L, int status, lua_KContext ctx)
3726{
3727 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3728 struct stream_interface *si = appctx->appctx->owner;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003729 size_t len = MAY_LJMP(luaL_checkinteger(L, 2));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003730 int ret;
Willy Tarreau206ba832018-06-14 15:27:31 +02003731 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003732 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02003733 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02003734 size_t len2;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003735
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003736 /* Read the maximum amount of data available. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003737 ret = co_getblk_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003738
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003739 /* Data not yet available. return yield. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003740 if (ret == 0) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01003741 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003742 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003743 }
3744
3745 /* End of data: commit the total strings and return. */
3746 if (ret < 0) {
3747 luaL_pushresult(&appctx->b);
3748 return 1;
3749 }
3750
3751 /* Ensure that the block 2 length is usable. */
3752 if (ret == 1)
3753 len2 = 0;
3754
3755 if (len == -1) {
3756
3757 /* If len == -1, catenate all the data avalaile and
3758 * yield because we want to get all the data until
3759 * the end of data stream.
3760 */
3761 luaL_addlstring(&appctx->b, blk1, len1);
3762 luaL_addlstring(&appctx->b, blk2, len2);
Willy Tarreau06d80a92017-10-19 14:32:15 +02003763 co_skip(si_oc(si), len1 + len2);
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01003764 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003765 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003766
3767 } else {
3768
3769 /* Copy the fisrt block caping to the length required. */
3770 if (len1 > len)
3771 len1 = len;
3772 luaL_addlstring(&appctx->b, blk1, len1);
3773 len -= len1;
3774
3775 /* Copy the second block. */
3776 if (len2 > len)
3777 len2 = len;
3778 luaL_addlstring(&appctx->b, blk2, len2);
3779 len -= len2;
3780
3781 /* Consume input channel output buffer data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003782 co_skip(si_oc(si), len1 + len2);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003783
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003784 /* If there is no other data available, yield waiting for new data. */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003785 if (len > 0) {
3786 lua_pushinteger(L, len);
3787 lua_replace(L, 2);
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01003788 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003789 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003790 }
3791
3792 /* return the result. */
3793 luaL_pushresult(&appctx->b);
3794 return 1;
3795 }
3796
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003797 /* we never execute this */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003798 hlua_pusherror(L, "Lua: internal error");
3799 WILL_LJMP(lua_error(L));
3800 return 0;
3801}
3802
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003803/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003804__LJMP static int hlua_applet_tcp_recv(lua_State *L)
3805{
3806 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3807 int len = -1;
3808
3809 if (lua_gettop(L) > 2)
3810 WILL_LJMP(luaL_error(L, "The 'recv' function requires between 1 and 2 arguments."));
3811 if (lua_gettop(L) >= 2) {
3812 len = MAY_LJMP(luaL_checkinteger(L, 2));
3813 lua_pop(L, 1);
3814 }
3815
3816 /* Confirm or set the required length */
3817 lua_pushinteger(L, len);
3818
3819 /* Initialise the string catenation. */
3820 luaL_buffinit(L, &appctx->b);
3821
3822 return MAY_LJMP(hlua_applet_tcp_recv_yield(L, 0, 0));
3823}
3824
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08003825/* Append data in the output side of the buffer. This data is immediately
3826 * sent. The function returns the amount of data written. If the buffer
3827 * cannot contain the data, the function yields. The function returns -1
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003828 * if the channel is closed.
3829 */
3830__LJMP static int hlua_applet_tcp_send_yield(lua_State *L, int status, lua_KContext ctx)
3831{
3832 size_t len;
3833 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3834 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
3835 int l = MAY_LJMP(luaL_checkinteger(L, 3));
3836 struct stream_interface *si = appctx->appctx->owner;
3837 struct channel *chn = si_ic(si);
3838 int max;
3839
3840 /* Get the max amount of data which can write as input in the channel. */
3841 max = channel_recv_max(chn);
3842 if (max > (len - l))
3843 max = len - l;
3844
3845 /* Copy data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02003846 ci_putblk(chn, str + l, max);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003847
3848 /* update counters. */
3849 l += max;
3850 lua_pop(L, 1);
3851 lua_pushinteger(L, l);
3852
3853 /* If some data is not send, declares the situation to the
3854 * applet, and returns a yield.
3855 */
3856 if (l < len) {
Willy Tarreaudb398432018-11-15 11:08:52 +01003857 si_rx_room_blk(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02003858 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02003859 }
3860
3861 return 1;
3862}
3863
3864/* Just a wraper of "hlua_applet_tcp_send_yield". This wrapper permits
3865 * yield the LUA process, and resume it without checking the
3866 * input arguments.
3867 */
3868__LJMP static int hlua_applet_tcp_send(lua_State *L)
3869{
3870 MAY_LJMP(check_args(L, 2, "send"));
3871 lua_pushinteger(L, 0);
3872
3873 return MAY_LJMP(hlua_applet_tcp_send_yield(L, 0, 0));
3874}
3875
Thierry FOURNIER594afe72015-03-10 23:58:30 +01003876/*
3877 *
3878 *
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003879 * Class AppletHTTP
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003880 *
3881 *
3882 */
3883
3884/* Returns a struct hlua_txn if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02003885 * a class stream, otherwise it throws an error.
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003886 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003887__LJMP static struct hlua_appctx *hlua_checkapplet_http(lua_State *L, int ud)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003888{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02003889 return MAY_LJMP(hlua_checkudata(L, ud, class_applet_http_ref));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003890}
3891
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003892/* This function creates and push in the stack an Applet object
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003893 * according with a current TXN.
3894 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003895static int hlua_applet_http_new(lua_State *L, struct appctx *ctx)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003896{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003897 struct hlua_appctx *appctx;
Thierry FOURNIER841475e2015-12-11 17:10:09 +01003898 struct hlua_txn htxn;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003899 struct stream_interface *si = ctx->owner;
3900 struct stream *s = si_strm(si);
3901 struct proxy *px = s->be;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003902
3903 /* Check stack size. */
3904 if (!lua_checkstack(L, 3))
3905 return 0;
3906
3907 /* Create the object: obj[0] = userdata.
3908 * Note that the base of the Converters object is the
3909 * same than the TXN object.
3910 */
3911 lua_newtable(L);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003912 appctx = lua_newuserdata(L, sizeof(*appctx));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003913 lua_rawseti(L, -2, 0);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003914 appctx->appctx = ctx;
3915 appctx->appctx->ctx.hlua_apphttp.status = 200; /* Default status code returned. */
Robin H. Johnson52f5db22017-01-01 13:10:52 -08003916 appctx->appctx->ctx.hlua_apphttp.reason = NULL; /* Use default reason based on status */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003917 appctx->htxn.s = s;
3918 appctx->htxn.p = px;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003919
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003920 /* Create the "f" field that contains a list of fetches. */
3921 lua_pushstring(L, "f");
3922 if (!hlua_fetches_new(L, &appctx->htxn, 0))
3923 return 0;
3924 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003925
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003926 /* Create the "sf" field that contains a list of stringsafe fetches. */
3927 lua_pushstring(L, "sf");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003928 if (!hlua_fetches_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003929 return 0;
3930 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003931
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003932 /* Create the "c" field that contains a list of converters. */
3933 lua_pushstring(L, "c");
3934 if (!hlua_converters_new(L, &appctx->htxn, 0))
3935 return 0;
3936 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003937
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003938 /* Create the "sc" field that contains a list of stringsafe converters. */
3939 lua_pushstring(L, "sc");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01003940 if (!hlua_converters_new(L, &appctx->htxn, HLUA_F_AS_STRING))
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02003941 return 0;
3942 lua_settable(L, -3);
Willy Tarreaueee5b512015-04-03 23:46:31 +02003943
Christopher Faulet9c832fc2018-12-14 13:34:05 +01003944 if (IS_HTX_STRM(s)) {
3945 /* HTX version */
3946 struct htx *htx = htxbuf(&s->req.buf);
3947 struct htx_sl *sl = http_find_stline(htx);
3948 struct ist path;
3949 unsigned long long len = 0;
3950 int32_t pos;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003951
Christopher Faulet9c832fc2018-12-14 13:34:05 +01003952 /* Stores the request method. */
3953 lua_pushstring(L, "method");
3954 lua_pushlstring(L, HTX_SL_REQ_MPTR(sl), HTX_SL_REQ_MLEN(sl));
3955 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01003956
Christopher Faulet9c832fc2018-12-14 13:34:05 +01003957 /* Stores the http version. */
3958 lua_pushstring(L, "version");
3959 lua_pushlstring(L, HTX_SL_REQ_VPTR(sl), HTX_SL_REQ_VLEN(sl));
3960 lua_settable(L, -3);
Thierry FOURNIER841475e2015-12-11 17:10:09 +01003961
Christopher Faulet9c832fc2018-12-14 13:34:05 +01003962 /* creates an array of headers. hlua_http_get_headers() crates and push
3963 * the array on the top of the stack.
3964 */
3965 lua_pushstring(L, "headers");
3966 htxn.s = s;
3967 htxn.p = px;
3968 htxn.dir = SMP_OPT_DIR_REQ;
3969 if (!hlua_http_get_headers(L, &htxn, &htxn.s->txn->req))
3970 return 0;
3971 lua_settable(L, -3);
3972
3973 path = http_get_path(htx_sl_req_uri(sl));
3974 if (path.ptr) {
3975 char *p, *q, *end;
3976
3977 p = path.ptr;
3978 end = path.ptr + path.len;
3979 q = p;
3980 while (q < end && *q != '?')
3981 q++;
3982
3983 /* Stores the request path. */
3984 lua_pushstring(L, "path");
3985 lua_pushlstring(L, p, q - p);
3986 lua_settable(L, -3);
3987
3988 /* Stores the query string. */
3989 lua_pushstring(L, "qs");
3990 if (*q == '?')
3991 q++;
3992 lua_pushlstring(L, q, end - q);
3993 lua_settable(L, -3);
3994 }
3995
3996 for (pos = htx_get_head(htx); pos != -1; pos = htx_get_next(htx, pos)) {
3997 struct htx_blk *blk = htx_get_blk(htx, pos);
3998 enum htx_blk_type type = htx_get_blk_type(blk);
3999
4000 if (type == HTX_BLK_EOM || type == HTX_BLK_EOD)
4001 break;
4002 if (type == HTX_BLK_DATA)
4003 len += htx_get_blksz(blk);
4004 }
4005 if (htx->extra != ULLONG_MAX)
4006 len += htx->extra;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004007
Thierry FOURNIER7d388632017-02-22 02:06:16 +01004008 /* Stores the request path. */
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004009 lua_pushstring(L, "length");
4010 lua_pushinteger(L, len);
4011 lua_settable(L, -3);
4012 }
4013 else {
4014 /* Legacy HTTP version */
4015 struct http_txn *txn = s->txn;
4016 const char *path;
4017 const char *end;
4018 const char *p;
4019
4020 /* Stores the request method. */
4021 lua_pushstring(L, "method");
4022 lua_pushlstring(L, ci_head(txn->req.chn), txn->req.sl.rq.m_l);
Thierry FOURNIER7d388632017-02-22 02:06:16 +01004023 lua_settable(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004024
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004025 /* Stores the http version. */
4026 lua_pushstring(L, "version");
4027 lua_pushlstring(L, ci_head(txn->req.chn) + txn->req.sl.rq.v, txn->req.sl.rq.v_l);
Thierry FOURNIER7d388632017-02-22 02:06:16 +01004028 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01004029
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004030 /* creates an array of headers. hlua_http_get_headers() crates and push
4031 * the array on the top of the stack.
4032 */
4033 lua_pushstring(L, "headers");
4034 htxn.s = s;
4035 htxn.p = px;
4036 htxn.dir = SMP_OPT_DIR_REQ;
4037 if (!hlua_http_get_headers(L, &htxn, &htxn.s->txn->req))
4038 return 0;
4039 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01004040
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004041 /* Get path and qs */
4042 path = http_txn_get_path(txn);
4043 if (path) {
4044 end = ci_head(txn->req.chn) + txn->req.sl.rq.u + txn->req.sl.rq.u_l;
4045 p = path;
4046 while (p < end && *p != '?')
4047 p++;
4048
4049 /* Stores the request path. */
4050 lua_pushstring(L, "path");
4051 lua_pushlstring(L, path, p - path);
4052 lua_settable(L, -3);
4053
4054 /* Stores the query string. */
4055 lua_pushstring(L, "qs");
4056 if (*p == '?')
4057 p++;
4058 lua_pushlstring(L, p, end - p);
4059 lua_settable(L, -3);
4060 }
4061
4062 /* Stores the request path. */
4063 lua_pushstring(L, "length");
4064 lua_pushinteger(L, txn->req.body_len);
4065 lua_settable(L, -3);
4066 }
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01004067
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004068 /* Create an empty array of HTTP request headers. */
4069 lua_pushstring(L, "response");
4070 lua_newtable(L);
4071 lua_settable(L, -3);
Thierry FOURNIER04c57b32015-03-18 13:43:10 +01004072
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004073 /* Pop a class stream metatable and affect it to the table. */
4074 lua_rawgeti(L, LUA_REGISTRYINDEX, class_applet_http_ref);
4075 lua_setmetatable(L, -2);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004076
4077 return 1;
4078}
4079
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01004080__LJMP static int hlua_applet_http_set_var(lua_State *L)
4081{
4082 struct hlua_appctx *appctx;
4083 struct stream *s;
4084 const char *name;
4085 size_t len;
4086 struct sample smp;
4087
4088 MAY_LJMP(check_args(L, 3, "set_var"));
4089
4090 /* It is useles to retrieve the stream, but this function
4091 * runs only in a stream context.
4092 */
4093 appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4094 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
4095 s = appctx->htxn.s;
4096
4097 /* Converts the third argument in a sample. */
4098 hlua_lua2smp(L, 3, &smp);
4099
4100 /* Store the sample in a variable. */
4101 smp_set_owner(&smp, s->be, s->sess, s, 0);
4102 vars_set_by_name(name, len, &smp);
4103 return 0;
4104}
4105
4106__LJMP static int hlua_applet_http_unset_var(lua_State *L)
4107{
4108 struct hlua_appctx *appctx;
4109 struct stream *s;
4110 const char *name;
4111 size_t len;
4112 struct sample smp;
4113
4114 MAY_LJMP(check_args(L, 2, "unset_var"));
4115
4116 /* It is useles to retrieve the stream, but this function
4117 * runs only in a stream context.
4118 */
4119 appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4120 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
4121 s = appctx->htxn.s;
4122
4123 /* Unset the variable. */
4124 smp_set_owner(&smp, s->be, s->sess, s, 0);
4125 vars_unset_by_name(name, len, &smp);
4126 return 0;
4127}
4128
4129__LJMP static int hlua_applet_http_get_var(lua_State *L)
4130{
4131 struct hlua_appctx *appctx;
4132 struct stream *s;
4133 const char *name;
4134 size_t len;
4135 struct sample smp;
4136
4137 MAY_LJMP(check_args(L, 2, "get_var"));
4138
4139 /* It is useles to retrieve the stream, but this function
4140 * runs only in a stream context.
4141 */
4142 appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4143 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
4144 s = appctx->htxn.s;
4145
4146 smp_set_owner(&smp, s->be, s->sess, s, 0);
4147 if (!vars_get_by_name(name, len, &smp)) {
4148 lua_pushnil(L);
4149 return 1;
4150 }
4151
4152 return hlua_smp2lua(L, &smp);
4153}
4154
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01004155__LJMP static int hlua_applet_http_set_priv(lua_State *L)
4156{
4157 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4158 struct stream *s = appctx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01004159 struct hlua *hlua;
4160
4161 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01004162 if (!s->hlua)
4163 return 0;
4164 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01004165
4166 MAY_LJMP(check_args(L, 2, "set_priv"));
4167
4168 /* Remove previous value. */
Thierry FOURNIERe068b602017-04-26 13:27:05 +02004169 luaL_unref(L, LUA_REGISTRYINDEX, hlua->Mref);
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01004170
4171 /* Get and store new value. */
4172 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
4173 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
4174
4175 return 0;
4176}
4177
4178__LJMP static int hlua_applet_http_get_priv(lua_State *L)
4179{
4180 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4181 struct stream *s = appctx->htxn.s;
Thierry FOURNIER3b0a6d42016-12-16 08:48:32 +01004182 struct hlua *hlua;
4183
4184 /* Note that this hlua struct is from the session and not from the applet. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01004185 if (!s->hlua) {
4186 lua_pushnil(L);
4187 return 1;
4188 }
4189 hlua = s->hlua;
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01004190
4191 /* Push configuration index in the stack. */
4192 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
4193
4194 return 1;
4195}
4196
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004197/* If expected data not yet available, it returns a yield. This function
4198 * consumes the data in the buffer. It returns a string containing the
4199 * data. This string can be empty.
4200 */
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004201__LJMP static int hlua_applet_htx_getline_yield(lua_State *L, int status, lua_KContext ctx)
4202{
4203 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4204 struct stream_interface *si = appctx->appctx->owner;
4205 struct channel *req = si_oc(si);
4206 struct htx *htx;
4207 struct htx_blk *blk;
4208 size_t count;
4209 int stop = 0;
4210
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004211 htx = htx_from_buf(&req->buf);
4212 count = co_data(req);
4213 blk = htx_get_head_blk(htx);
Christopher Fauletcc26b132018-12-18 21:20:57 +01004214
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004215 while (count && !stop && blk) {
4216 enum htx_blk_type type = htx_get_blk_type(blk);
4217 uint32_t sz = htx_get_blksz(blk);
4218 struct ist v;
4219 uint32_t vlen;
4220 char *nl;
4221
Christopher Faulete461e342018-12-18 16:43:35 +01004222 if (type == HTX_BLK_EOM) {
4223 stop = 1;
4224 break;
4225 }
4226
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004227 vlen = sz;
4228 if (vlen > count) {
4229 if (type != HTX_BLK_DATA)
4230 break;
4231 vlen = count;
4232 }
4233
4234 switch (type) {
4235 case HTX_BLK_UNUSED:
4236 break;
4237
4238 case HTX_BLK_DATA:
4239 v = htx_get_blk_value(htx, blk);
4240 v.len = vlen;
4241 nl = istchr(v, '\n');
4242 if (nl != NULL) {
4243 stop = 1;
4244 vlen = nl - v.ptr + 1;
4245 }
4246 luaL_addlstring(&appctx->b, v.ptr, vlen);
4247 break;
4248
4249 case HTX_BLK_EOD:
4250 case HTX_BLK_TLR:
4251 case HTX_BLK_EOM:
4252 stop = 1;
4253 break;
4254
4255 default:
4256 break;
4257 }
4258
4259 co_set_data(req, co_data(req) - vlen);
4260 count -= vlen;
4261 if (sz == vlen)
4262 blk = htx_remove_blk(htx, blk);
4263 else {
4264 htx_cut_data_blk(htx, blk, vlen);
4265 break;
4266 }
4267 }
4268
Christopher Faulet0ae79d02019-02-27 21:36:59 +01004269 htx_to_buf(htx, &req->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004270 if (!stop) {
4271 si_cant_get(si);
4272 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_htx_getline_yield, TICK_ETERNITY, 0));
4273 }
4274
4275 /* return the result. */
4276 luaL_pushresult(&appctx->b);
4277 return 1;
4278}
4279
4280
4281/* If expected data not yet available, it returns a yield. This function
4282 * consumes the data in the buffer. It returns a string containing the
4283 * data. This string can be empty.
4284 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004285__LJMP static int hlua_applet_http_getline_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004286{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004287 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4288 struct stream_interface *si = appctx->appctx->owner;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004289 int ret;
Willy Tarreau206ba832018-06-14 15:27:31 +02004290 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02004291 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02004292 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02004293 size_t len2;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004294
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004295 /* Check for the end of the data. */
4296 if (appctx->appctx->ctx.hlua_apphttp.left_bytes <= 0) {
4297 luaL_pushresult(&appctx->b);
4298 return 1;
4299 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004300
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004301 /* Read the maximum amount of data available. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02004302 ret = co_getline_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004303
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004304 /* Data not yet available. return yield. */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004305 if (ret == 0) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01004306 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02004307 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_getline_yield, TICK_ETERNITY, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004308 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004309
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004310 /* End of data: commit the total strings and return. */
4311 if (ret < 0) {
4312 luaL_pushresult(&appctx->b);
4313 return 1;
4314 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004315
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004316 /* Ensure that the block 2 length is usable. */
4317 if (ret == 1)
4318 len2 = 0;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004319
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004320 /* Copy the fisrt block caping to the length required. */
4321 if (len1 > appctx->appctx->ctx.hlua_apphttp.left_bytes)
4322 len1 = appctx->appctx->ctx.hlua_apphttp.left_bytes;
4323 luaL_addlstring(&appctx->b, blk1, len1);
4324 appctx->appctx->ctx.hlua_apphttp.left_bytes -= len1;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004325
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004326 /* Copy the second block. */
4327 if (len2 > appctx->appctx->ctx.hlua_apphttp.left_bytes)
4328 len2 = appctx->appctx->ctx.hlua_apphttp.left_bytes;
4329 luaL_addlstring(&appctx->b, blk2, len2);
4330 appctx->appctx->ctx.hlua_apphttp.left_bytes -= len2;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004331
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004332 /* Consume input channel output buffer data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02004333 co_skip(si_oc(si), len1 + len2);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004334 luaL_pushresult(&appctx->b);
4335 return 1;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004336}
4337
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004338/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004339__LJMP static int hlua_applet_http_getline(lua_State *L)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004340{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004341 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004342
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004343 /* Initialise the string catenation. */
4344 luaL_buffinit(L, &appctx->b);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004345
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004346 if (IS_HTX_STRM(si_strm(appctx->appctx->owner)))
4347 return MAY_LJMP(hlua_applet_htx_getline_yield(L, 0, 0));
4348 else
4349 return MAY_LJMP(hlua_applet_http_getline_yield(L, 0, 0));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004350}
4351
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004352/* If expected data not yet available, it returns a yield. This function
4353 * consumes the data in the buffer. It returns a string containing the
4354 * data. This string can be empty.
4355 */
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004356__LJMP static int hlua_applet_htx_recv_yield(lua_State *L, int status, lua_KContext ctx)
4357{
4358 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4359 struct stream_interface *si = appctx->appctx->owner;
4360 struct channel *req = si_oc(si);
4361 struct htx *htx;
4362 struct htx_blk *blk;
4363 size_t count;
4364 int len;
4365
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004366 htx = htx_from_buf(&req->buf);
4367 len = MAY_LJMP(luaL_checkinteger(L, 2));
4368 count = co_data(req);
4369 blk = htx_get_head_blk(htx);
4370 while (count && len && blk) {
4371 enum htx_blk_type type = htx_get_blk_type(blk);
4372 uint32_t sz = htx_get_blksz(blk);
4373 struct ist v;
4374 uint32_t vlen;
4375
Christopher Faulete461e342018-12-18 16:43:35 +01004376 if (type == HTX_BLK_EOM) {
4377 len = 0;
4378 break;
4379 }
4380
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004381 vlen = sz;
4382 if (len > 0 && vlen > len)
4383 vlen = len;
4384 if (vlen > count) {
4385 if (type != HTX_BLK_DATA)
4386 break;
4387 vlen = count;
4388 }
4389
4390 switch (type) {
4391 case HTX_BLK_UNUSED:
4392 break;
4393
4394 case HTX_BLK_DATA:
4395 v = htx_get_blk_value(htx, blk);
4396 luaL_addlstring(&appctx->b, v.ptr, vlen);
4397 break;
4398
4399 case HTX_BLK_EOD:
4400 case HTX_BLK_TLR:
4401 case HTX_BLK_EOM:
4402 len = 0;
4403 break;
4404
4405 default:
4406 break;
4407 }
4408
4409 co_set_data(req, co_data(req) - vlen);
4410 count -= vlen;
4411 if (len > 0)
4412 len -= vlen;
4413 if (sz == vlen)
4414 blk = htx_remove_blk(htx, blk);
4415 else {
4416 htx_cut_data_blk(htx, blk, vlen);
4417 break;
4418 }
4419 }
4420
Christopher Faulet0ae79d02019-02-27 21:36:59 +01004421 htx_to_buf(htx, &req->buf);
4422
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004423 /* If we are no other data available, yield waiting for new data. */
4424 if (len) {
4425 if (len > 0) {
4426 lua_pushinteger(L, len);
4427 lua_replace(L, 2);
4428 }
4429 si_cant_get(si);
4430 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_htx_recv_yield, TICK_ETERNITY, 0));
4431 }
4432
4433 /* return the result. */
4434 luaL_pushresult(&appctx->b);
4435 return 1;
4436}
4437
4438/* If expected data not yet available, it returns a yield. This function
4439 * consumes the data in the buffer. It returns a string containing the
4440 * data. This string can be empty.
4441 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004442__LJMP static int hlua_applet_http_recv_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004443{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004444 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4445 struct stream_interface *si = appctx->appctx->owner;
4446 int len = MAY_LJMP(luaL_checkinteger(L, 2));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004447 int ret;
Willy Tarreau206ba832018-06-14 15:27:31 +02004448 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02004449 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02004450 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02004451 size_t len2;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004452
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004453 /* Read the maximum amount of data available. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02004454 ret = co_getblk_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01004455
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004456 /* Data not yet available. return yield. */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004457 if (ret == 0) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01004458 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02004459 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004460 }
4461
4462 /* End of data: commit the total strings and return. */
4463 if (ret < 0) {
4464 luaL_pushresult(&appctx->b);
4465 return 1;
4466 }
4467
4468 /* Ensure that the block 2 length is usable. */
4469 if (ret == 1)
4470 len2 = 0;
4471
4472 /* Copy the fisrt block caping to the length required. */
4473 if (len1 > len)
4474 len1 = len;
4475 luaL_addlstring(&appctx->b, blk1, len1);
4476 len -= len1;
4477
4478 /* Copy the second block. */
4479 if (len2 > len)
4480 len2 = len;
4481 luaL_addlstring(&appctx->b, blk2, len2);
4482 len -= len2;
4483
4484 /* Consume input channel output buffer data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02004485 co_skip(si_oc(si), len1 + len2);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004486 if (appctx->appctx->ctx.hlua_apphttp.left_bytes != -1)
4487 appctx->appctx->ctx.hlua_apphttp.left_bytes -= len;
4488
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004489 /* If we are no other data available, yield waiting for new data. */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004490 if (len > 0) {
4491 lua_pushinteger(L, len);
4492 lua_replace(L, 2);
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01004493 si_cant_get(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02004494 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_recv_yield, TICK_ETERNITY, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004495 }
4496
4497 /* return the result. */
4498 luaL_pushresult(&appctx->b);
4499 return 1;
4500}
4501
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004502/* Check arguments for the function "hlua_channel_get_yield". */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004503__LJMP static int hlua_applet_http_recv(lua_State *L)
4504{
4505 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4506 int len = -1;
4507
4508 /* Check arguments. */
4509 if (lua_gettop(L) > 2)
4510 WILL_LJMP(luaL_error(L, "The 'recv' function requires between 1 and 2 arguments."));
4511 if (lua_gettop(L) >= 2) {
4512 len = MAY_LJMP(luaL_checkinteger(L, 2));
4513 lua_pop(L, 1);
4514 }
4515
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004516 if (IS_HTX_STRM(si_strm(appctx->appctx->owner))) {
4517 /* HTX version */
4518 lua_pushinteger(L, len);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004519
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004520 /* Initialise the string catenation. */
4521 luaL_buffinit(L, &appctx->b);
4522
4523 return MAY_LJMP(hlua_applet_htx_recv_yield(L, 0, 0));
4524 }
4525 else {
4526 /* Legacy HTTP version */
4527 /* Check the required length */
4528 if (len == -1 || len > appctx->appctx->ctx.hlua_apphttp.left_bytes)
4529 len = appctx->appctx->ctx.hlua_apphttp.left_bytes;
4530 lua_pushinteger(L, len);
4531
4532 /* Initialise the string catenation. */
4533 luaL_buffinit(L, &appctx->b);
4534
4535 return MAY_LJMP(hlua_applet_http_recv_yield(L, 0, 0));
4536 }
4537}
4538
4539/* Append data in the output side of the buffer. This data is immediately
4540 * sent. The function returns the amount of data written. If the buffer
4541 * cannot contain the data, the function yields. The function returns -1
4542 * if the channel is closed.
4543 */
4544__LJMP static int hlua_applet_htx_send_yield(lua_State *L, int status, lua_KContext ctx)
4545{
4546 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4547 struct stream_interface *si = appctx->appctx->owner;
4548 struct channel *res = si_ic(si);
4549 struct htx *htx = htx_from_buf(&res->buf);
4550 const char *data;
4551 size_t len;
4552 int l = MAY_LJMP(luaL_checkinteger(L, 3));
4553 int max;
4554
Christopher Faulet4b0e9b22019-01-09 12:16:58 +01004555 max = channel_htx_recv_max(res, htx);
4556 if (!max)
4557 goto snd_yield;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004558
4559 data = MAY_LJMP(luaL_checklstring(L, 2, &len));
4560
4561 /* Get the max amount of data which can write as input in the channel. */
4562 if (max > (len - l))
4563 max = len - l;
4564
4565 /* Copy data. */
Christopher Faulet4b0e9b22019-01-09 12:16:58 +01004566 if (!htx_add_data(htx, ist2(data + l, max)))
4567 goto snd_yield;
Christopher Fauletf6cce3f2019-02-27 21:20:09 +01004568 channel_add_input(res, max);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004569
4570 /* update counters. */
4571 l += max;
4572 lua_pop(L, 1);
4573 lua_pushinteger(L, l);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004574
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004575 /* If some data is not send, declares the situation to the
4576 * applet, and returns a yield.
4577 */
4578 if (l < len) {
Christopher Faulet4b0e9b22019-01-09 12:16:58 +01004579 snd_yield:
Christopher Faulet0ae79d02019-02-27 21:36:59 +01004580 htx_to_buf(htx, &res->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004581 si_rx_room_blk(si);
4582 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_htx_send_yield, TICK_ETERNITY, 0));
4583 }
4584
Christopher Faulet0ae79d02019-02-27 21:36:59 +01004585 htx_to_buf(htx, &res->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004586 return 1;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004587}
4588
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08004589/* Append data in the output side of the buffer. This data is immediately
4590 * sent. The function returns the amount of data written. If the buffer
4591 * cannot contain the data, the function yields. The function returns -1
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004592 * if the channel is closed.
4593 */
4594__LJMP static int hlua_applet_http_send_yield(lua_State *L, int status, lua_KContext ctx)
4595{
4596 size_t len;
4597 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4598 const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
4599 int l = MAY_LJMP(luaL_checkinteger(L, 3));
4600 struct stream_interface *si = appctx->appctx->owner;
4601 struct channel *chn = si_ic(si);
4602 int max;
4603
4604 /* Get the max amount of data which can write as input in the channel. */
4605 max = channel_recv_max(chn);
4606 if (max > (len - l))
4607 max = len - l;
4608
4609 /* Copy data. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02004610 ci_putblk(chn, str + l, max);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004611
4612 /* update counters. */
4613 l += max;
4614 lua_pop(L, 1);
4615 lua_pushinteger(L, l);
4616
4617 /* If some data is not send, declares the situation to the
4618 * applet, and returns a yield.
4619 */
4620 if (l < len) {
Willy Tarreaudb398432018-11-15 11:08:52 +01004621 si_rx_room_blk(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02004622 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_send_yield, TICK_ETERNITY, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004623 }
4624
4625 return 1;
4626}
4627
4628/* Just a wraper of "hlua_applet_send_yield". This wrapper permits
4629 * yield the LUA process, and resume it without checking the
4630 * input arguments.
4631 */
4632__LJMP static int hlua_applet_http_send(lua_State *L)
4633{
4634 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004635
4636 /* We want to send some data. Headers must be sent. */
4637 if (!(appctx->appctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT)) {
4638 hlua_pusherror(L, "Lua: 'send' you must call start_response() before sending data.");
4639 WILL_LJMP(lua_error(L));
4640 }
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004641
4642 if (IS_HTX_STRM(si_strm(appctx->appctx->owner))) {
4643 /* HTX version */
4644 /* This interger is used for followinf the amount of data sent. */
4645 lua_pushinteger(L, 0);
4646
4647 return MAY_LJMP(hlua_applet_htx_send_yield(L, 0, 0));
4648 }
4649 else {
4650 /* Legacy HTTP version */
4651 size_t len;
4652 char hex[10];
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004653
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004654 MAY_LJMP(luaL_checklstring(L, 2, &len));
4655
4656 /* If transfer encoding chunked is selected, we surround the data
4657 * by chunk data.
4658 */
4659 if (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_CHUNKED) {
4660 snprintf(hex, 9, "%x", (unsigned int)len);
4661 lua_pushfstring(L, "%s\r\n", hex);
4662 lua_insert(L, 2); /* swap the last 2 entries. */
4663 lua_pushstring(L, "\r\n");
4664 lua_concat(L, 3);
4665 }
4666
4667 /* This interger is used for followinf the amount of data sent. */
4668 lua_pushinteger(L, 0);
4669
4670 return MAY_LJMP(hlua_applet_http_send_yield(L, 0, 0));
4671 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004672}
4673
4674__LJMP static int hlua_applet_http_addheader(lua_State *L)
4675{
4676 const char *name;
4677 int ret;
4678
4679 MAY_LJMP(hlua_checkapplet_http(L, 1));
4680 name = MAY_LJMP(luaL_checkstring(L, 2));
4681 MAY_LJMP(luaL_checkstring(L, 3));
4682
4683 /* Push in the stack the "response" entry. */
4684 ret = lua_getfield(L, 1, "response");
4685 if (ret != LUA_TTABLE) {
4686 hlua_pusherror(L, "Lua: 'add_header' internal error: AppletHTTP['response'] "
4687 "is expected as an array. %s found", lua_typename(L, ret));
4688 WILL_LJMP(lua_error(L));
4689 }
4690
4691 /* check if the header is already registered if it is not
4692 * the case, register it.
4693 */
4694 ret = lua_getfield(L, -1, name);
4695 if (ret == LUA_TNIL) {
4696
4697 /* Entry not found. */
4698 lua_pop(L, 1); /* remove the nil. The "response" table is the top of the stack. */
4699
4700 /* Insert the new header name in the array in the top of the stack.
4701 * It left the new array in the top of the stack.
4702 */
4703 lua_newtable(L);
4704 lua_pushvalue(L, 2);
4705 lua_pushvalue(L, -2);
4706 lua_settable(L, -4);
4707
4708 } else if (ret != LUA_TTABLE) {
4709
4710 /* corruption error. */
4711 hlua_pusherror(L, "Lua: 'add_header' internal error: AppletHTTP['response']['%s'] "
4712 "is expected as an array. %s found", name, lua_typename(L, ret));
4713 WILL_LJMP(lua_error(L));
4714 }
4715
4716 /* Now the top od thestack is an array of values. We push
4717 * the header value as new entry.
4718 */
4719 lua_pushvalue(L, 3);
4720 ret = lua_rawlen(L, -2);
4721 lua_rawseti(L, -2, ret + 1);
4722 lua_pushboolean(L, 1);
4723 return 1;
4724}
4725
4726__LJMP static int hlua_applet_http_status(lua_State *L)
4727{
4728 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4729 int status = MAY_LJMP(luaL_checkinteger(L, 2));
Robin H. Johnson52f5db22017-01-01 13:10:52 -08004730 const char *reason = MAY_LJMP(luaL_optlstring(L, 3, NULL, NULL));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004731
4732 if (status < 100 || status > 599) {
4733 lua_pushboolean(L, 0);
4734 return 1;
4735 }
4736
4737 appctx->appctx->ctx.hlua_apphttp.status = status;
Robin H. Johnson52f5db22017-01-01 13:10:52 -08004738 appctx->appctx->ctx.hlua_apphttp.reason = reason;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004739 lua_pushboolean(L, 1);
4740 return 1;
4741}
4742
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004743
4744__LJMP static int hlua_applet_htx_send_response(lua_State *L)
4745{
4746 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4747 struct stream_interface *si = appctx->appctx->owner;
4748 struct channel *res = si_ic(si);
4749 struct htx *htx;
4750 struct htx_sl *sl;
4751 struct h1m h1m;
4752 const char *status, *reason;
4753 const char *name, *value;
4754 size_t nlen, vlen;
4755 unsigned int flags;
4756
4757 /* Send the message at once. */
4758 htx = htx_from_buf(&res->buf);
4759 h1m_init_res(&h1m);
4760
4761 /* Use the same http version than the request. */
4762 status = ultoa_r(appctx->appctx->ctx.hlua_apphttp.status, trash.area, trash.size);
4763 reason = appctx->appctx->ctx.hlua_apphttp.reason;
4764 if (reason == NULL)
4765 reason = http_get_reason(appctx->appctx->ctx.hlua_apphttp.status);
4766 if (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_HTTP11) {
4767 flags = (HTX_SL_F_IS_RESP|HTX_SL_F_VER_11);
4768 sl = htx_add_stline(htx, HTX_BLK_RES_SL, flags, ist("HTTP/1.1"), ist(status), ist(reason));
4769 }
4770 else {
4771 flags = HTX_SL_F_IS_RESP;
4772 sl = htx_add_stline(htx, HTX_BLK_RES_SL, flags, ist("HTTP/1.0"), ist(status), ist(reason));
4773 }
4774 if (!sl) {
4775 hlua_pusherror(L, "Lua applet http '%s': Failed to create response.\n",
4776 appctx->appctx->rule->arg.hlua_rule->fcn.name);
4777 WILL_LJMP(lua_error(L));
4778 }
4779 sl->info.res.status = appctx->appctx->ctx.hlua_apphttp.status;
4780
4781 /* Get the array associated to the field "response" in the object AppletHTTP. */
4782 lua_pushvalue(L, 0);
4783 if (lua_getfield(L, 1, "response") != LUA_TTABLE) {
4784 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response'] missing.\n",
4785 appctx->appctx->rule->arg.hlua_rule->fcn.name);
4786 WILL_LJMP(lua_error(L));
4787 }
4788
4789 /* Browse the list of headers. */
4790 lua_pushnil(L);
4791 while(lua_next(L, -2) != 0) {
4792 /* We expect a string as -2. */
4793 if (lua_type(L, -2) != LUA_TSTRING) {
4794 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response'][] element must be a string. got %s.\n",
4795 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4796 lua_typename(L, lua_type(L, -2)));
4797 WILL_LJMP(lua_error(L));
4798 }
4799 name = lua_tolstring(L, -2, &nlen);
4800
4801 /* We expect an array as -1. */
4802 if (lua_type(L, -1) != LUA_TTABLE) {
4803 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'] element must be an table. got %s.\n",
4804 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4805 name,
4806 lua_typename(L, lua_type(L, -1)));
4807 WILL_LJMP(lua_error(L));
4808 }
4809
4810 /* Browse the table who is on the top of the stack. */
4811 lua_pushnil(L);
4812 while(lua_next(L, -2) != 0) {
4813 int id;
4814
4815 /* We expect a number as -2. */
4816 if (lua_type(L, -2) != LUA_TNUMBER) {
4817 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'][] element must be a number. got %s.\n",
4818 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4819 name,
4820 lua_typename(L, lua_type(L, -2)));
4821 WILL_LJMP(lua_error(L));
4822 }
4823 id = lua_tointeger(L, -2);
4824
4825 /* We expect a string as -2. */
4826 if (lua_type(L, -1) != LUA_TSTRING) {
4827 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'][%d] element must be a string. got %s.\n",
4828 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4829 name, id,
4830 lua_typename(L, lua_type(L, -1)));
4831 WILL_LJMP(lua_error(L));
4832 }
4833 value = lua_tolstring(L, -1, &vlen);
4834
4835 /* Simple Protocol checks. */
4836 if (isteqi(ist2(name, nlen), ist("transfer-encoding")))
4837 h1_parse_xfer_enc_header(&h1m, ist2(name, nlen));
4838 else if (isteqi(ist2(name, nlen), ist("content-length"))) {
4839 struct ist v = ist2(value, vlen);
4840 int ret;
4841
4842 ret = h1_parse_cont_len_header(&h1m, &v);
4843 if (ret < 0) {
4844 hlua_pusherror(L, "Lua applet http '%s': Invalid '%s' header.\n",
4845 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4846 name);
4847 WILL_LJMP(lua_error(L));
4848 }
4849 else if (ret == 0)
4850 goto next; /* Skip it */
4851 }
4852
4853 /* Add a new header */
4854 if (!htx_add_header(htx, ist2(name, nlen), ist2(value, vlen))) {
4855 hlua_pusherror(L, "Lua applet http '%s': Failed to add header '%s' in the response.\n",
4856 appctx->appctx->rule->arg.hlua_rule->fcn.name,
4857 name);
4858 WILL_LJMP(lua_error(L));
4859 }
4860 next:
4861 /* Remove the array from the stack, and get next element with a remaining string. */
4862 lua_pop(L, 1);
4863 }
4864
4865 /* Remove the array from the stack, and get next element with a remaining string. */
4866 lua_pop(L, 1);
4867 }
4868
4869 if (h1m.flags & H1_MF_CHNK)
4870 h1m.flags &= ~H1_MF_CLEN;
4871 if (h1m.flags & (H1_MF_CLEN|H1_MF_CHNK))
4872 h1m.flags |= H1_MF_XFER_LEN;
4873
4874 /* Uset HTX start-line flags */
4875 if (h1m.flags & H1_MF_XFER_ENC)
4876 flags |= HTX_SL_F_XFER_ENC;
4877 if (h1m.flags & H1_MF_XFER_LEN) {
4878 flags |= HTX_SL_F_XFER_LEN;
4879 if (h1m.flags & H1_MF_CHNK)
4880 flags |= HTX_SL_F_CHNK;
4881 else if (h1m.flags & H1_MF_CLEN)
4882 flags |= HTX_SL_F_CLEN;
4883 if (h1m.body_len == 0)
4884 flags |= HTX_SL_F_BODYLESS;
4885 }
4886 sl->flags |= flags;
4887
4888 /* If we dont have a content-length set, and the HTTP version is 1.1
4889 * and the status code implies the presence of a message body, we must
4890 * announce a transfer encoding chunked. This is required by haproxy
4891 * for the keepalive compliance. If the applet annouces a transfer-encoding
4892 * chunked itslef, don't do anything.
4893 */
4894 if ((flags & (HTX_SL_F_VER_11|HTX_SL_F_XFER_LEN)) == HTX_SL_F_VER_11 &&
4895 appctx->appctx->ctx.hlua_apphttp.status >= 200 &&
4896 appctx->appctx->ctx.hlua_apphttp.status != 204 &&
4897 appctx->appctx->ctx.hlua_apphttp.status != 304) {
4898 /* Add a new header */
4899 sl->flags |= (HTX_SL_F_XFER_ENC|H1_MF_CHNK|H1_MF_XFER_LEN);
4900 if (!htx_add_header(htx, ist("transfer-encoding"), ist("chunked"))) {
4901 hlua_pusherror(L, "Lua applet http '%s': Failed to add header 'transfer-encoding' in the response.\n",
4902 appctx->appctx->rule->arg.hlua_rule->fcn.name);
4903 WILL_LJMP(lua_error(L));
4904 }
4905 }
4906
4907 /* Finalize headers. */
4908 if (!htx_add_endof(htx, HTX_BLK_EOH)) {
4909 hlua_pusherror(L, "Lua applet http '%s': Failed create the response.\n",
4910 appctx->appctx->rule->arg.hlua_rule->fcn.name);
4911 WILL_LJMP(lua_error(L));
4912 }
4913
4914 if (htx_used_space(htx) > b_size(&res->buf) - global.tune.maxrewrite) {
4915 b_reset(&res->buf);
4916 hlua_pusherror(L, "Lua: 'start_response': response header block too big");
4917 WILL_LJMP(lua_error(L));
4918 }
4919
4920 htx_to_buf(htx, &res->buf);
Christopher Fauletf6cce3f2019-02-27 21:20:09 +01004921 channel_add_input(res, htx->data);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004922
4923 /* Headers sent, set the flag. */
4924 appctx->appctx->ctx.hlua_apphttp.flags |= APPLET_HDR_SENT;
4925 return 0;
4926
4927}
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004928/* We will build the status line and the headers of the HTTP response.
4929 * We will try send at once if its not possible, we give back the hand
4930 * waiting for more room.
4931 */
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004932__LJMP static int hlua_applet_htx_start_response_yield(lua_State *L, int status, lua_KContext ctx)
4933{
4934 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4935 struct stream_interface *si = appctx->appctx->owner;
4936 struct channel *res = si_ic(si);
4937
4938 if (co_data(res)) {
4939 si_rx_room_blk(si);
4940 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_htx_start_response_yield, TICK_ETERNITY, 0));
4941 }
4942 return MAY_LJMP(hlua_applet_htx_send_response(L));
4943}
4944
4945
4946__LJMP static int hlua_applet_htx_start_response(lua_State *L)
4947{
4948 return MAY_LJMP(hlua_applet_htx_start_response_yield(L, 0, 0));
4949}
4950
4951/* We will build the status line and the headers of the HTTP response.
4952 * We will try send at once if its not possible, we give back the hand
4953 * waiting for more room.
4954 */
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004955__LJMP static int hlua_applet_http_start_response_yield(lua_State *L, int status, lua_KContext ctx)
4956{
4957 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4958 struct stream_interface *si = appctx->appctx->owner;
4959 struct channel *chn = si_ic(si);
4960 int ret;
4961 size_t len;
4962 const char *msg;
4963
4964 /* Get the message as the first argument on the stack. */
4965 msg = MAY_LJMP(luaL_checklstring(L, 2, &len));
4966
4967 /* Send the message at once. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02004968 ret = ci_putblk(chn, msg, len);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004969
4970 /* if ret == -2 or -3 the channel closed or the message si too
4971 * big for the buffers.
4972 */
4973 if (ret == -2 || ret == -3) {
4974 hlua_pusherror(L, "Lua: 'start_response': response header block too big");
4975 WILL_LJMP(lua_error(L));
4976 }
4977
4978 /* If ret is -1, we dont have room in the buffer, so we yield. */
4979 if (ret == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01004980 si_rx_room_blk(si);
Willy Tarreau9635e032018-10-16 17:52:55 +02004981 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_start_response_yield, TICK_ETERNITY, 0));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004982 }
4983
4984 /* Headers sent, set the flag. */
4985 appctx->appctx->ctx.hlua_apphttp.flags |= APPLET_HDR_SENT;
4986 return 0;
4987}
4988
4989__LJMP static int hlua_applet_http_start_response(lua_State *L)
4990{
Christopher Faulet9c832fc2018-12-14 13:34:05 +01004991 struct buffer *tmp;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004992 struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004993 const char *name;
Willy Tarreaua3294632017-08-23 11:24:47 +02004994 size_t name_len;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004995 const char *value;
Willy Tarreaua3294632017-08-23 11:24:47 +02004996 size_t value_len;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004997 int id;
Willy Tarreauc9f4ea02017-08-23 09:32:06 +02004998 long long hdr_contentlength = -1;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02004999 int hdr_chunked = 0;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01005000 const char *reason;
5001
5002 if (IS_HTX_STRM(si_strm(appctx->appctx->owner)))
5003 return MAY_LJMP(hlua_applet_htx_start_response(L));
Robin H. Johnson52f5db22017-01-01 13:10:52 -08005004
Christopher Faulet9c832fc2018-12-14 13:34:05 +01005005 reason = appctx->appctx->ctx.hlua_apphttp.reason;
Robin H. Johnson52f5db22017-01-01 13:10:52 -08005006 if (reason == NULL)
Willy Tarreau04f1e2d2018-09-10 18:04:24 +02005007 reason = http_get_reason(appctx->appctx->ctx.hlua_apphttp.status);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005008
Christopher Faulet9c832fc2018-12-14 13:34:05 +01005009 tmp = get_trash_chunk();
5010
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005011 /* Use the same http version than the request. */
5012 chunk_appendf(tmp, "HTTP/1.%c %d %s\r\n",
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +01005013 appctx->appctx->ctx.hlua_apphttp.flags & APPLET_HTTP11 ? '1' : '0',
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005014 appctx->appctx->ctx.hlua_apphttp.status,
Robin H. Johnson52f5db22017-01-01 13:10:52 -08005015 reason);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005016
5017 /* Get the array associated to the field "response" in the object AppletHTTP. */
5018 lua_pushvalue(L, 0);
5019 if (lua_getfield(L, 1, "response") != LUA_TTABLE) {
5020 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response'] missing.\n",
5021 appctx->appctx->rule->arg.hlua_rule->fcn.name);
5022 WILL_LJMP(lua_error(L));
5023 }
5024
5025 /* Browse the list of headers. */
5026 lua_pushnil(L);
5027 while(lua_next(L, -2) != 0) {
5028
5029 /* We expect a string as -2. */
5030 if (lua_type(L, -2) != LUA_TSTRING) {
5031 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response'][] element must be a string. got %s.\n",
5032 appctx->appctx->rule->arg.hlua_rule->fcn.name,
5033 lua_typename(L, lua_type(L, -2)));
5034 WILL_LJMP(lua_error(L));
5035 }
Willy Tarreaua3294632017-08-23 11:24:47 +02005036 name = lua_tolstring(L, -2, &name_len);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005037
5038 /* We expect an array as -1. */
5039 if (lua_type(L, -1) != LUA_TTABLE) {
5040 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'] element must be an table. got %s.\n",
5041 appctx->appctx->rule->arg.hlua_rule->fcn.name,
5042 name,
5043 lua_typename(L, lua_type(L, -1)));
5044 WILL_LJMP(lua_error(L));
5045 }
5046
5047 /* Browse the table who is on the top of the stack. */
5048 lua_pushnil(L);
5049 while(lua_next(L, -2) != 0) {
5050
5051 /* We expect a number as -2. */
5052 if (lua_type(L, -2) != LUA_TNUMBER) {
5053 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'][] element must be a number. got %s.\n",
5054 appctx->appctx->rule->arg.hlua_rule->fcn.name,
5055 name,
5056 lua_typename(L, lua_type(L, -2)));
5057 WILL_LJMP(lua_error(L));
5058 }
5059 id = lua_tointeger(L, -2);
5060
5061 /* We expect a string as -2. */
5062 if (lua_type(L, -1) != LUA_TSTRING) {
5063 hlua_pusherror(L, "Lua applet http '%s': AppletHTTP['response']['%s'][%d] element must be a string. got %s.\n",
5064 appctx->appctx->rule->arg.hlua_rule->fcn.name,
5065 name, id,
5066 lua_typename(L, lua_type(L, -1)));
5067 WILL_LJMP(lua_error(L));
5068 }
Willy Tarreaua3294632017-08-23 11:24:47 +02005069 value = lua_tolstring(L, -1, &value_len);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005070
5071 /* Catenate a new header. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005072 if (tmp->data + name_len + 2 + value_len + 2 < tmp->size) {
5073 memcpy(tmp->area + tmp->data, name, name_len);
5074 tmp->data += name_len;
5075 tmp->area[tmp->data++] = ':';
5076 tmp->area[tmp->data++] = ' ';
Willy Tarreaua3294632017-08-23 11:24:47 +02005077
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005078 memcpy(tmp->area + tmp->data, value,
5079 value_len);
5080 tmp->data += value_len;
5081 tmp->area[tmp->data++] = '\r';
5082 tmp->area[tmp->data++] = '\n';
Willy Tarreaua3294632017-08-23 11:24:47 +02005083 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005084
5085 /* Protocol checks. */
5086
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005087 /* Copy the header content length. The length conversion
Willy Tarreauc9f4ea02017-08-23 09:32:06 +02005088 * is done without control. If it contains a bad value,
5089 * the content-length remains negative so that we can
5090 * switch to either chunked encoding or close.
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005091 */
Willy Tarreaua3294632017-08-23 11:24:47 +02005092 if (name_len == 14 && strcasecmp("content-length", name) == 0)
Willy Tarreauc9f4ea02017-08-23 09:32:06 +02005093 strl2llrc(value, strlen(value), &hdr_contentlength);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005094
5095 /* Check if the client annouces a transfer-encoding chunked it self. */
Willy Tarreaua3294632017-08-23 11:24:47 +02005096 if (name_len == 17 && value_len == 7 &&
5097 strcasecmp("transfer-encoding", name) == 0 &&
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005098 strcasecmp("chunked", value) == 0)
5099 hdr_chunked = 1;
5100
5101 /* Remove the array from the stack, and get next element with a remaining string. */
5102 lua_pop(L, 1);
5103 }
5104
5105 /* Remove the array from the stack, and get next element with a remaining string. */
5106 lua_pop(L, 1);
5107 }
5108
Willy Tarreau06c75fe2017-08-23 09:10:38 +02005109 /* If we dont have a content-length set, and the HTTP version is 1.1
5110 * and the status code implies the presence of a message body, we must
5111 * announce a transfer encoding chunked. This is required by haproxy
5112 * for the keepalive compliance. If the applet annouces a transfer-encoding
5113 * chunked itslef, don't do anything.
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005114 */
Willy Tarreauc9f4ea02017-08-23 09:32:06 +02005115 if (hdr_contentlength < 0 && hdr_chunked == 0 &&
Willy Tarreau06c75fe2017-08-23 09:10:38 +02005116 (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_HTTP11) &&
5117 appctx->appctx->ctx.hlua_apphttp.status >= 200 &&
5118 appctx->appctx->ctx.hlua_apphttp.status != 204 &&
5119 appctx->appctx->ctx.hlua_apphttp.status != 304) {
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005120 chunk_appendf(tmp, "Transfer-encoding: chunked\r\n");
5121 appctx->appctx->ctx.hlua_apphttp.flags |= APPLET_CHUNKED;
5122 }
5123
5124 /* Finalize headers. */
5125 chunk_appendf(tmp, "\r\n");
5126
5127 /* Remove the last entry and the array of headers */
5128 lua_pop(L, 2);
5129
5130 /* Push the headers block. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005131 lua_pushlstring(L, tmp->area, tmp->data);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005132
5133 return MAY_LJMP(hlua_applet_http_start_response_yield(L, 0, 0));
5134}
5135
5136/*
5137 *
5138 *
5139 * Class HTTP
5140 *
5141 *
5142 */
5143
5144/* Returns a struct hlua_txn if the stack entry "ud" is
5145 * a class stream, otherwise it throws an error.
5146 */
5147__LJMP static struct hlua_txn *hlua_checkhttp(lua_State *L, int ud)
5148{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02005149 return MAY_LJMP(hlua_checkudata(L, ud, class_http_ref));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005150}
5151
5152/* This function creates and push in the stack a HTTP object
5153 * according with a current TXN.
5154 */
5155static int hlua_http_new(lua_State *L, struct hlua_txn *txn)
5156{
5157 struct hlua_txn *htxn;
5158
5159 /* Check stack size. */
5160 if (!lua_checkstack(L, 3))
5161 return 0;
5162
5163 /* Create the object: obj[0] = userdata.
5164 * Note that the base of the Converters object is the
5165 * same than the TXN object.
5166 */
5167 lua_newtable(L);
5168 htxn = lua_newuserdata(L, sizeof(*htxn));
5169 lua_rawseti(L, -2, 0);
5170
5171 htxn->s = txn->s;
5172 htxn->p = txn->p;
5173
5174 /* Pop a class stream metatable and affect it to the table. */
5175 lua_rawgeti(L, LUA_REGISTRYINDEX, class_http_ref);
5176 lua_setmetatable(L, -2);
5177
5178 return 1;
5179}
5180
5181/* This function creates ans returns an array of HTTP headers.
5182 * This function does not fails. It is used as wrapper with the
5183 * 2 following functions.
5184 */
5185__LJMP static int hlua_http_get_headers(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg)
5186{
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005187 /* Create the table. */
5188 lua_newtable(L);
5189
5190 if (!htxn->s->txn)
5191 return 1;
5192
Christopher Faulet724a12c2018-12-13 22:12:15 +01005193 if (IS_HTX_STRM(htxn->s)) {
5194 /* HTX version */
5195 struct htx *htx = htxbuf(&msg->chn->buf);
5196 int32_t pos;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005197
Christopher Faulet724a12c2018-12-13 22:12:15 +01005198 for (pos = htx_get_head(htx); pos != -1; pos = htx_get_next(htx, pos)) {
5199 struct htx_blk *blk = htx_get_blk(htx, pos);
5200 enum htx_blk_type type = htx_get_blk_type(blk);
5201 struct ist n, v;
5202 int len;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005203
Christopher Faulet724a12c2018-12-13 22:12:15 +01005204 if (type == HTX_BLK_HDR) {
5205 n = htx_get_blk_name(htx,blk);
5206 v = htx_get_blk_value(htx, blk);
5207 }
5208 else if (type == HTX_BLK_EOH)
5209 break;
5210 else
5211 continue;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005212
Christopher Faulet724a12c2018-12-13 22:12:15 +01005213 /* Check for existing entry:
5214 * assume that the table is on the top of the stack, and
5215 * push the key in the stack, the function lua_gettable()
5216 * perform the lookup.
5217 */
5218 lua_pushlstring(L, n.ptr, n.len);
5219 lua_gettable(L, -2);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005220
Christopher Faulet724a12c2018-12-13 22:12:15 +01005221 switch (lua_type(L, -1)) {
5222 case LUA_TNIL:
5223 /* Table not found, create it. */
5224 lua_pop(L, 1); /* remove the nil value. */
5225 lua_pushlstring(L, n.ptr, n.len); /* push the header name as key. */
5226 lua_newtable(L); /* create and push empty table. */
5227 lua_pushlstring(L, v.ptr, v.len); /* push header value. */
5228 lua_rawseti(L, -2, 0); /* index header value (pop it). */
5229 lua_rawset(L, -3); /* index new table with header name (pop the values). */
5230 break;
5231
5232 case LUA_TTABLE:
5233 /* Entry found: push the value in the table. */
5234 len = lua_rawlen(L, -1);
5235 lua_pushlstring(L, v.ptr, v.len); /* push header value. */
5236 lua_rawseti(L, -2, len+1); /* index header value (pop it). */
5237 lua_pop(L, 1); /* remove the table (it is stored in the main table). */
5238 break;
5239
5240 default:
5241 /* Other cases are errors. */
5242 hlua_pusherror(L, "internal error during the parsing of headers.");
5243 WILL_LJMP(lua_error(L));
5244 }
5245 }
5246 }
5247 else {
5248 /* Legacy HTTP version */
5249 const char *cur_ptr, *cur_next, *p;
5250 int old_idx, cur_idx;
5251 struct hdr_idx_elem *cur_hdr;
5252 const char *hn, *hv;
5253 int hnl, hvl;
5254 const char *in;
5255 char *out;
5256 int len;
5257
5258 /* Build array of headers. */
5259 old_idx = 0;
5260 cur_next = ci_head(msg->chn) + hdr_idx_first_pos(&htxn->s->txn->hdr_idx);
5261
5262 while (1) {
5263 cur_idx = htxn->s->txn->hdr_idx.v[old_idx].next;
5264 if (!cur_idx)
5265 break;
5266 old_idx = cur_idx;
5267
5268 cur_hdr = &htxn->s->txn->hdr_idx.v[cur_idx];
5269 cur_ptr = cur_next;
5270 cur_next = cur_ptr + cur_hdr->len + cur_hdr->cr + 1;
5271
5272 /* Now we have one full header at cur_ptr of len cur_hdr->len,
5273 * and the next header starts at cur_next. We'll check
5274 * this header in the list as well as against the default
5275 * rule.
5276 */
5277
5278 /* look for ': *'. */
5279 hn = cur_ptr;
5280 for (p = cur_ptr; p < cur_ptr + cur_hdr->len && *p != ':'; p++);
5281 if (p >= cur_ptr+cur_hdr->len)
5282 continue;
5283 hnl = p - hn;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005284 p++;
Christopher Faulet724a12c2018-12-13 22:12:15 +01005285 while (p < cur_ptr+cur_hdr->len && ( *p == ' ' || *p == '\t' ))
5286 p++;
5287 if (p >= cur_ptr+cur_hdr->len)
5288 continue;
5289 hv = p;
5290 hvl = cur_ptr+cur_hdr->len-p;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005291
Christopher Faulet724a12c2018-12-13 22:12:15 +01005292 /* Lowercase the key. Don't check the size of trash, it have
5293 * the size of one buffer and the input data contains in one
5294 * buffer.
5295 */
5296 out = trash.area;
5297 for (in=hn; in<hn+hnl; in++, out++)
5298 *out = tolower(*in);
5299 *out = '\0';
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005300
Christopher Faulet724a12c2018-12-13 22:12:15 +01005301 /* Check for existing entry:
5302 * assume that the table is on the top of the stack, and
5303 * push the key in the stack, the function lua_gettable()
5304 * perform the lookup.
5305 */
5306 lua_pushlstring(L, trash.area, hnl);
5307 lua_gettable(L, -2);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005308
Christopher Faulet724a12c2018-12-13 22:12:15 +01005309 switch (lua_type(L, -1)) {
5310 case LUA_TNIL:
5311 /* Table not found, create it. */
5312 lua_pop(L, 1); /* remove the nil value. */
5313 lua_pushlstring(L, trash.area, hnl); /* push the header name as key. */
5314 lua_newtable(L); /* create and push empty table. */
5315 lua_pushlstring(L, hv, hvl); /* push header value. */
5316 lua_rawseti(L, -2, 0); /* index header value (pop it). */
5317 lua_rawset(L, -3); /* index new table with header name (pop the values). */
5318 break;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005319
Christopher Faulet724a12c2018-12-13 22:12:15 +01005320 case LUA_TTABLE:
5321 /* Entry found: push the value in the table. */
5322 len = lua_rawlen(L, -1);
5323 lua_pushlstring(L, hv, hvl); /* push header value. */
5324 lua_rawseti(L, -2, len+1); /* index header value (pop it). */
5325 lua_pop(L, 1); /* remove the table (it is stored in the main table). */
5326 break;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005327
Christopher Faulet724a12c2018-12-13 22:12:15 +01005328 default:
5329 /* Other cases are errors. */
5330 hlua_pusherror(L, "internal error during the parsing of headers.");
5331 WILL_LJMP(lua_error(L));
5332 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005333 }
5334 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02005335 return 1;
5336}
5337
5338__LJMP static int hlua_http_req_get_headers(lua_State *L)
5339{
5340 struct hlua_txn *htxn;
5341
5342 MAY_LJMP(check_args(L, 1, "req_get_headers"));
5343 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5344
5345 return hlua_http_get_headers(L, htxn, &htxn->s->txn->req);
5346}
5347
5348__LJMP static int hlua_http_res_get_headers(lua_State *L)
5349{
5350 struct hlua_txn *htxn;
5351
5352 MAY_LJMP(check_args(L, 1, "res_get_headers"));
5353 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5354
5355 return hlua_http_get_headers(L, htxn, &htxn->s->txn->rsp);
5356}
5357
5358/* This function replace full header, or just a value in
5359 * the request or in the response. It is a wrapper fir the
5360 * 4 following functions.
5361 */
5362__LJMP static inline int hlua_http_rep_hdr(lua_State *L, struct hlua_txn *htxn,
5363 struct http_msg *msg, int action)
5364{
5365 size_t name_len;
5366 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
5367 const char *reg = MAY_LJMP(luaL_checkstring(L, 3));
5368 const char *value = MAY_LJMP(luaL_checkstring(L, 4));
5369 struct my_regex re;
5370
5371 if (!regex_comp(reg, &re, 1, 1, NULL))
5372 WILL_LJMP(luaL_argerror(L, 3, "invalid regex"));
5373
5374 http_transform_header_str(htxn->s, msg, name, name_len, value, &re, action);
5375 regex_free(&re);
5376 return 0;
5377}
5378
5379__LJMP static int hlua_http_req_rep_hdr(lua_State *L)
5380{
5381 struct hlua_txn *htxn;
5382
5383 MAY_LJMP(check_args(L, 4, "req_rep_hdr"));
5384 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5385
5386 return MAY_LJMP(hlua_http_rep_hdr(L, htxn, &htxn->s->txn->req, ACT_HTTP_REPLACE_HDR));
5387}
5388
5389__LJMP static int hlua_http_res_rep_hdr(lua_State *L)
5390{
5391 struct hlua_txn *htxn;
5392
5393 MAY_LJMP(check_args(L, 4, "res_rep_hdr"));
5394 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5395
5396 return MAY_LJMP(hlua_http_rep_hdr(L, htxn, &htxn->s->txn->rsp, ACT_HTTP_REPLACE_HDR));
5397}
5398
5399__LJMP static int hlua_http_req_rep_val(lua_State *L)
5400{
5401 struct hlua_txn *htxn;
5402
5403 MAY_LJMP(check_args(L, 4, "req_rep_hdr"));
5404 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5405
5406 return MAY_LJMP(hlua_http_rep_hdr(L, htxn, &htxn->s->txn->req, ACT_HTTP_REPLACE_VAL));
5407}
5408
5409__LJMP static int hlua_http_res_rep_val(lua_State *L)
5410{
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005411 struct hlua_txn *htxn;
5412
5413 MAY_LJMP(check_args(L, 4, "res_rep_val"));
5414 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5415
Thierry FOURNIER0ea5c7f2015-08-05 19:05:19 +02005416 return MAY_LJMP(hlua_http_rep_hdr(L, htxn, &htxn->s->txn->rsp, ACT_HTTP_REPLACE_VAL));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005417}
5418
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08005419/* This function deletes all the occurrences of an header.
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005420 * It is a wrapper for the 2 following functions.
5421 */
5422__LJMP static inline int hlua_http_del_hdr(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg)
5423{
5424 size_t len;
5425 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005426
Christopher Faulet724a12c2018-12-13 22:12:15 +01005427 if (IS_HTX_STRM(htxn->s)) {
5428 /* HTX version */
5429 struct htx *htx = htxbuf(&msg->chn->buf);
5430 struct http_hdr_ctx ctx;
5431
5432 ctx.blk = NULL;
5433 while (http_find_header(htx, ist2(name, len), &ctx, 1))
5434 http_remove_header(htx, &ctx);
5435 }
5436 else {
5437 /* Legacy HTTP version */
5438 struct hdr_ctx ctx;
5439 struct http_txn *txn = htxn->s->txn;
5440
5441 ctx.idx = 0;
5442 while (http_find_header2(name, len, ci_head(msg->chn), &txn->hdr_idx, &ctx))
5443 http_remove_header2(msg, &txn->hdr_idx, &ctx);
5444 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005445 return 0;
5446}
5447
5448__LJMP static int hlua_http_req_del_hdr(lua_State *L)
5449{
5450 struct hlua_txn *htxn;
5451
5452 MAY_LJMP(check_args(L, 2, "req_del_hdr"));
5453 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5454
Willy Tarreaueee5b512015-04-03 23:46:31 +02005455 return hlua_http_del_hdr(L, htxn, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005456}
5457
5458__LJMP static int hlua_http_res_del_hdr(lua_State *L)
5459{
5460 struct hlua_txn *htxn;
5461
5462 MAY_LJMP(check_args(L, 2, "req_del_hdr"));
5463 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5464
Willy Tarreaueee5b512015-04-03 23:46:31 +02005465 return hlua_http_del_hdr(L, htxn, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005466}
5467
5468/* This function adds an header. It is a wrapper used by
5469 * the 2 following functions.
5470 */
5471__LJMP static inline int hlua_http_add_hdr(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg)
5472{
5473 size_t name_len;
5474 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
5475 size_t value_len;
5476 const char *value = MAY_LJMP(luaL_checklstring(L, 3, &value_len));
5477 char *p;
5478
Christopher Faulet724a12c2018-12-13 22:12:15 +01005479 if (IS_HTX_STRM(htxn->s)) {
5480 /* HTX version */
5481 struct htx *htx = htxbuf(&msg->chn->buf);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005482
Christopher Faulet724a12c2018-12-13 22:12:15 +01005483 lua_pushboolean(L, http_add_header(htx, ist2(name, name_len),
5484 ist2(value, value_len)));
5485 }
5486 else {
5487 /* Legacy HTTP version */
5488 /* Check length. */
5489 trash.data = value_len + name_len + 2;
5490 if (trash.data > trash.size)
5491 return 0;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005492
Christopher Faulet724a12c2018-12-13 22:12:15 +01005493 /* Creates the header string. */
5494 p = trash.area;
5495 memcpy(p, name, name_len);
5496 p += name_len;
5497 *p = ':';
5498 p++;
5499 *p = ' ';
5500 p++;
5501 memcpy(p, value, value_len);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005502
Christopher Faulet724a12c2018-12-13 22:12:15 +01005503 lua_pushboolean(L, http_header_add_tail2(msg, &htxn->s->txn->hdr_idx,
5504 trash.area, trash.data) != 0);
5505 }
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005506 return 0;
5507}
5508
5509__LJMP static int hlua_http_req_add_hdr(lua_State *L)
5510{
5511 struct hlua_txn *htxn;
5512
5513 MAY_LJMP(check_args(L, 3, "req_add_hdr"));
5514 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5515
Willy Tarreaueee5b512015-04-03 23:46:31 +02005516 return hlua_http_add_hdr(L, htxn, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005517}
5518
5519__LJMP static int hlua_http_res_add_hdr(lua_State *L)
5520{
5521 struct hlua_txn *htxn;
5522
5523 MAY_LJMP(check_args(L, 3, "res_add_hdr"));
5524 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5525
Willy Tarreaueee5b512015-04-03 23:46:31 +02005526 return hlua_http_add_hdr(L, htxn, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005527}
5528
5529static int hlua_http_req_set_hdr(lua_State *L)
5530{
5531 struct hlua_txn *htxn;
5532
5533 MAY_LJMP(check_args(L, 3, "req_set_hdr"));
5534 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5535
Willy Tarreaueee5b512015-04-03 23:46:31 +02005536 hlua_http_del_hdr(L, htxn, &htxn->s->txn->req);
5537 return hlua_http_add_hdr(L, htxn, &htxn->s->txn->req);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005538}
5539
5540static int hlua_http_res_set_hdr(lua_State *L)
5541{
5542 struct hlua_txn *htxn;
5543
5544 MAY_LJMP(check_args(L, 3, "res_set_hdr"));
5545 htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5546
Willy Tarreaueee5b512015-04-03 23:46:31 +02005547 hlua_http_del_hdr(L, htxn, &htxn->s->txn->rsp);
5548 return hlua_http_add_hdr(L, htxn, &htxn->s->txn->rsp);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005549}
5550
5551/* This function set the method. */
5552static int hlua_http_req_set_meth(lua_State *L)
5553{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02005554 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005555 size_t name_len;
5556 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005557
Willy Tarreau987e3fb2015-04-04 01:09:08 +02005558 lua_pushboolean(L, http_replace_req_line(0, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005559 return 1;
5560}
5561
5562/* This function set the method. */
5563static int hlua_http_req_set_path(lua_State *L)
5564{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02005565 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005566 size_t name_len;
5567 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER / OZON.IOb84ae922016-08-02 23:44:58 +02005568
Willy Tarreau987e3fb2015-04-04 01:09:08 +02005569 lua_pushboolean(L, http_replace_req_line(1, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005570 return 1;
5571}
5572
5573/* This function set the query-string. */
5574static int hlua_http_req_set_query(lua_State *L)
5575{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02005576 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005577 size_t name_len;
5578 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005579
5580 /* Check length. */
5581 if (name_len > trash.size - 1) {
5582 lua_pushboolean(L, 0);
5583 return 1;
5584 }
5585
5586 /* Add the mark question as prefix. */
5587 chunk_reset(&trash);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005588 trash.area[trash.data++] = '?';
5589 memcpy(trash.area + trash.data, name, name_len);
5590 trash.data += name_len;
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005591
Willy Tarreau843b7cb2018-07-13 10:54:26 +02005592 lua_pushboolean(L,
5593 http_replace_req_line(2, trash.area, trash.data, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005594 return 1;
5595}
5596
5597/* This function set the uri. */
5598static int hlua_http_req_set_uri(lua_State *L)
5599{
Willy Tarreaubcb39cc2015-04-06 11:21:44 +02005600 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005601 size_t name_len;
5602 const char *name = MAY_LJMP(luaL_checklstring(L, 2, &name_len));
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005603
Willy Tarreau987e3fb2015-04-04 01:09:08 +02005604 lua_pushboolean(L, http_replace_req_line(3, name, name_len, htxn->p, htxn->s) != -1);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005605 return 1;
5606}
5607
Robin H. Johnson52f5db22017-01-01 13:10:52 -08005608/* This function set the response code & optionally reason. */
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02005609static int hlua_http_res_set_status(lua_State *L)
5610{
5611 struct hlua_txn *htxn = MAY_LJMP(hlua_checkhttp(L, 1));
5612 unsigned int code = MAY_LJMP(luaL_checkinteger(L, 2));
Robin H. Johnson52f5db22017-01-01 13:10:52 -08005613 const char *reason = MAY_LJMP(luaL_optlstring(L, 3, NULL, NULL));
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02005614
Robin H. Johnson52f5db22017-01-01 13:10:52 -08005615 http_set_status(code, reason, htxn->s);
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02005616 return 0;
5617}
5618
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005619/*
5620 *
5621 *
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005622 * Class TXN
5623 *
5624 *
5625 */
5626
5627/* Returns a struct hlua_session if the stack entry "ud" is
Willy Tarreau87b09662015-04-03 00:22:06 +02005628 * a class stream, otherwise it throws an error.
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005629 */
5630__LJMP static struct hlua_txn *hlua_checktxn(lua_State *L, int ud)
5631{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02005632 return MAY_LJMP(hlua_checkudata(L, ud, class_txn_ref));
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005633}
5634
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005635__LJMP static int hlua_set_var(lua_State *L)
5636{
5637 struct hlua_txn *htxn;
5638 const char *name;
5639 size_t len;
5640 struct sample smp;
5641
5642 MAY_LJMP(check_args(L, 3, "set_var"));
5643
5644 /* It is useles to retrieve the stream, but this function
5645 * runs only in a stream context.
5646 */
5647 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5648 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
5649
5650 /* Converts the third argument in a sample. */
5651 hlua_lua2smp(L, 3, &smp);
5652
5653 /* Store the sample in a variable. */
Willy Tarreau7560dd42016-03-10 16:28:58 +01005654 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
Willy Tarreau6204cd92016-03-10 16:33:04 +01005655 vars_set_by_name(name, len, &smp);
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005656 return 0;
5657}
5658
Christopher Faulet85d79c92016-11-09 16:54:56 +01005659__LJMP static int hlua_unset_var(lua_State *L)
5660{
5661 struct hlua_txn *htxn;
5662 const char *name;
5663 size_t len;
5664 struct sample smp;
5665
5666 MAY_LJMP(check_args(L, 2, "unset_var"));
5667
5668 /* It is useles to retrieve the stream, but this function
5669 * runs only in a stream context.
5670 */
5671 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5672 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
5673
5674 /* Unset the variable. */
5675 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
5676 vars_unset_by_name(name, len, &smp);
5677 return 0;
5678}
5679
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005680__LJMP static int hlua_get_var(lua_State *L)
5681{
5682 struct hlua_txn *htxn;
5683 const char *name;
5684 size_t len;
5685 struct sample smp;
5686
5687 MAY_LJMP(check_args(L, 2, "get_var"));
5688
5689 /* It is useles to retrieve the stream, but this function
5690 * runs only in a stream context.
5691 */
5692 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5693 name = MAY_LJMP(luaL_checklstring(L, 2, &len));
5694
Willy Tarreau7560dd42016-03-10 16:28:58 +01005695 smp_set_owner(&smp, htxn->p, htxn->s->sess, htxn->s, htxn->dir & SMP_OPT_DIR);
Willy Tarreau6204cd92016-03-10 16:33:04 +01005696 if (!vars_get_by_name(name, len, &smp)) {
Thierry FOURNIER053ba8ad2015-06-08 13:05:33 +02005697 lua_pushnil(L);
5698 return 1;
5699 }
5700
5701 return hlua_smp2lua(L, &smp);
5702}
5703
Willy Tarreau59551662015-03-10 14:23:13 +01005704__LJMP static int hlua_set_priv(lua_State *L)
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005705{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005706 struct hlua *hlua;
5707
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005708 MAY_LJMP(check_args(L, 2, "set_priv"));
5709
Willy Tarreau87b09662015-04-03 00:22:06 +02005710 /* It is useles to retrieve the stream, but this function
5711 * runs only in a stream context.
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005712 */
5713 MAY_LJMP(hlua_checktxn(L, 1));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005714 hlua = hlua_gethlua(L);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005715
5716 /* Remove previous value. */
Thierry FOURNIERe068b602017-04-26 13:27:05 +02005717 luaL_unref(L, LUA_REGISTRYINDEX, hlua->Mref);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005718
5719 /* Get and store new value. */
5720 lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
5721 hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
5722
5723 return 0;
5724}
5725
Willy Tarreau59551662015-03-10 14:23:13 +01005726__LJMP static int hlua_get_priv(lua_State *L)
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005727{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005728 struct hlua *hlua;
5729
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005730 MAY_LJMP(check_args(L, 1, "get_priv"));
5731
Willy Tarreau87b09662015-04-03 00:22:06 +02005732 /* It is useles to retrieve the stream, but this function
5733 * runs only in a stream context.
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005734 */
5735 MAY_LJMP(hlua_checktxn(L, 1));
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005736 hlua = hlua_gethlua(L);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01005737
5738 /* Push configuration index in the stack. */
5739 lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
5740
5741 return 1;
5742}
5743
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005744/* Create stack entry containing a class TXN. This function
5745 * return 0 if the stack does not contains free slots,
5746 * otherwise it returns 1.
5747 */
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005748static int hlua_txn_new(lua_State *L, struct stream *s, struct proxy *p, int dir, int flags)
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005749{
Willy Tarreaude491382015-04-06 11:04:28 +02005750 struct hlua_txn *htxn;
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005751
5752 /* Check stack size. */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01005753 if (!lua_checkstack(L, 3))
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005754 return 0;
5755
5756 /* NOTE: The allocation never fails. The failure
5757 * throw an error, and the function never returns.
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08005758 * if the throw is not available, the process is aborted.
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005759 */
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01005760 /* Create the object: obj[0] = userdata. */
5761 lua_newtable(L);
Willy Tarreaude491382015-04-06 11:04:28 +02005762 htxn = lua_newuserdata(L, sizeof(*htxn));
Thierry FOURNIER2297bc22015-03-11 17:43:33 +01005763 lua_rawseti(L, -2, 0);
5764
Willy Tarreaude491382015-04-06 11:04:28 +02005765 htxn->s = s;
5766 htxn->p = p;
Thierry FOURNIERc4eebc82015-11-02 10:01:59 +01005767 htxn->dir = dir;
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005768 htxn->flags = flags;
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005769
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01005770 /* Create the "f" field that contains a list of fetches. */
5771 lua_pushstring(L, "f");
Thierry FOURNIERca988662015-12-20 18:43:03 +01005772 if (!hlua_fetches_new(L, htxn, HLUA_F_MAY_USE_HTTP))
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01005773 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005774 lua_rawset(L, -3);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01005775
5776 /* Create the "sf" field that contains a list of stringsafe fetches. */
5777 lua_pushstring(L, "sf");
Thierry FOURNIERca988662015-12-20 18:43:03 +01005778 if (!hlua_fetches_new(L, htxn, HLUA_F_MAY_USE_HTTP | HLUA_F_AS_STRING))
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01005779 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005780 lua_rawset(L, -3);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01005781
Thierry FOURNIER594afe72015-03-10 23:58:30 +01005782 /* Create the "c" field that contains a list of converters. */
5783 lua_pushstring(L, "c");
Willy Tarreaude491382015-04-06 11:04:28 +02005784 if (!hlua_converters_new(L, htxn, 0))
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01005785 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005786 lua_rawset(L, -3);
Thierry FOURNIER2694a1a2015-03-11 20:13:36 +01005787
5788 /* Create the "sc" field that contains a list of stringsafe converters. */
5789 lua_pushstring(L, "sc");
Thierry FOURNIER7fa05492015-12-20 18:42:25 +01005790 if (!hlua_converters_new(L, htxn, HLUA_F_AS_STRING))
Thierry FOURNIER594afe72015-03-10 23:58:30 +01005791 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005792 lua_rawset(L, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01005793
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005794 /* Create the "req" field that contains the request channel object. */
5795 lua_pushstring(L, "req");
Willy Tarreau2a71af42015-03-10 13:51:50 +01005796 if (!hlua_channel_new(L, &s->req))
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005797 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005798 lua_rawset(L, -3);
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005799
5800 /* Create the "res" field that contains the response channel object. */
5801 lua_pushstring(L, "res");
Willy Tarreau2a71af42015-03-10 13:51:50 +01005802 if (!hlua_channel_new(L, &s->res))
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005803 return 0;
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005804 lua_rawset(L, -3);
Thierry FOURNIER397826a2015-03-11 19:39:09 +01005805
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005806 /* Creates the HTTP object is the current proxy allows http. */
5807 lua_pushstring(L, "http");
5808 if (p->mode == PR_MODE_HTTP) {
Willy Tarreaude491382015-04-06 11:04:28 +02005809 if (!hlua_http_new(L, htxn))
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005810 return 0;
5811 }
5812 else
5813 lua_pushnil(L);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02005814 lua_rawset(L, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01005815
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01005816 /* Pop a class sesison metatable and affect it to the userdata. */
5817 lua_rawgeti(L, LUA_REGISTRYINDEX, class_txn_ref);
5818 lua_setmetatable(L, -2);
5819
5820 return 1;
5821}
5822
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01005823__LJMP static int hlua_txn_deflog(lua_State *L)
5824{
5825 const char *msg;
5826 struct hlua_txn *htxn;
5827
5828 MAY_LJMP(check_args(L, 2, "deflog"));
5829 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5830 msg = MAY_LJMP(luaL_checkstring(L, 2));
5831
5832 hlua_sendlog(htxn->s->be, htxn->s->logs.level, msg);
5833 return 0;
5834}
5835
5836__LJMP static int hlua_txn_log(lua_State *L)
5837{
5838 int level;
5839 const char *msg;
5840 struct hlua_txn *htxn;
5841
5842 MAY_LJMP(check_args(L, 3, "log"));
5843 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5844 level = MAY_LJMP(luaL_checkinteger(L, 2));
5845 msg = MAY_LJMP(luaL_checkstring(L, 3));
5846
5847 if (level < 0 || level >= NB_LOG_LEVELS)
5848 WILL_LJMP(luaL_argerror(L, 1, "Invalid loglevel."));
5849
5850 hlua_sendlog(htxn->s->be, level, msg);
5851 return 0;
5852}
5853
5854__LJMP static int hlua_txn_log_debug(lua_State *L)
5855{
5856 const char *msg;
5857 struct hlua_txn *htxn;
5858
5859 MAY_LJMP(check_args(L, 2, "Debug"));
5860 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5861 msg = MAY_LJMP(luaL_checkstring(L, 2));
5862 hlua_sendlog(htxn->s->be, LOG_DEBUG, msg);
5863 return 0;
5864}
5865
5866__LJMP static int hlua_txn_log_info(lua_State *L)
5867{
5868 const char *msg;
5869 struct hlua_txn *htxn;
5870
5871 MAY_LJMP(check_args(L, 2, "Info"));
5872 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5873 msg = MAY_LJMP(luaL_checkstring(L, 2));
5874 hlua_sendlog(htxn->s->be, LOG_INFO, msg);
5875 return 0;
5876}
5877
5878__LJMP static int hlua_txn_log_warning(lua_State *L)
5879{
5880 const char *msg;
5881 struct hlua_txn *htxn;
5882
5883 MAY_LJMP(check_args(L, 2, "Warning"));
5884 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5885 msg = MAY_LJMP(luaL_checkstring(L, 2));
5886 hlua_sendlog(htxn->s->be, LOG_WARNING, msg);
5887 return 0;
5888}
5889
5890__LJMP static int hlua_txn_log_alert(lua_State *L)
5891{
5892 const char *msg;
5893 struct hlua_txn *htxn;
5894
5895 MAY_LJMP(check_args(L, 2, "Alert"));
5896 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5897 msg = MAY_LJMP(luaL_checkstring(L, 2));
5898 hlua_sendlog(htxn->s->be, LOG_ALERT, msg);
5899 return 0;
5900}
5901
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005902__LJMP static int hlua_txn_set_loglevel(lua_State *L)
5903{
5904 struct hlua_txn *htxn;
5905 int ll;
5906
5907 MAY_LJMP(check_args(L, 2, "set_loglevel"));
5908 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5909 ll = MAY_LJMP(luaL_checkinteger(L, 2));
5910
5911 if (ll < 0 || ll > 7)
5912 WILL_LJMP(luaL_argerror(L, 2, "Bad log level. It must be between 0 and 7"));
5913
5914 htxn->s->logs.level = ll;
5915 return 0;
5916}
5917
5918__LJMP static int hlua_txn_set_tos(lua_State *L)
5919{
5920 struct hlua_txn *htxn;
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005921 int tos;
5922
5923 MAY_LJMP(check_args(L, 2, "set_tos"));
5924 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5925 tos = MAY_LJMP(luaL_checkinteger(L, 2));
5926
Willy Tarreau1a18b542018-12-11 16:37:42 +01005927 conn_set_tos(objt_conn(htxn->s->sess->origin), tos);
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005928 return 0;
5929}
5930
5931__LJMP static int hlua_txn_set_mark(lua_State *L)
5932{
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005933 struct hlua_txn *htxn;
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005934 int mark;
5935
5936 MAY_LJMP(check_args(L, 2, "set_mark"));
5937 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5938 mark = MAY_LJMP(luaL_checkinteger(L, 2));
5939
Willy Tarreau1a18b542018-12-11 16:37:42 +01005940 conn_set_tos(objt_conn(htxn->s->sess->origin), mark);
Thierry FOURNIER2cce3532015-03-16 12:04:16 +01005941 return 0;
5942}
5943
Patrick Hemmer268a7072018-05-11 12:52:31 -04005944__LJMP static int hlua_txn_set_priority_class(lua_State *L)
5945{
5946 struct hlua_txn *htxn;
5947
5948 MAY_LJMP(check_args(L, 2, "set_priority_class"));
5949 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5950 htxn->s->priority_class = queue_limit_class(MAY_LJMP(luaL_checkinteger(L, 2)));
5951 return 0;
5952}
5953
5954__LJMP static int hlua_txn_set_priority_offset(lua_State *L)
5955{
5956 struct hlua_txn *htxn;
5957
5958 MAY_LJMP(check_args(L, 2, "set_priority_offset"));
5959 htxn = MAY_LJMP(hlua_checktxn(L, 1));
5960 htxn->s->priority_offset = queue_limit_offset(MAY_LJMP(luaL_checkinteger(L, 2)));
5961 return 0;
5962}
5963
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005964/* This function is an Lua binding that send pending data
5965 * to the client, and close the stream interface.
5966 */
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02005967__LJMP static int hlua_txn_done(lua_State *L)
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005968{
Willy Tarreaub2ccb562015-04-06 11:11:15 +02005969 struct hlua_txn *htxn;
Thierry FOURNIER9bd52d42016-07-14 11:45:33 +02005970 struct hlua *hlua;
Willy Tarreau81389672015-03-10 12:03:52 +01005971 struct channel *ic, *oc;
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005972
Willy Tarreau80f5fae2015-02-27 16:38:20 +01005973 MAY_LJMP(check_args(L, 1, "close"));
Willy Tarreaub2ccb562015-04-06 11:11:15 +02005974 htxn = MAY_LJMP(hlua_checktxn(L, 1));
Thierry FOURNIER9bd52d42016-07-14 11:45:33 +02005975 hlua = hlua_gethlua(L);
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01005976
Thierry FOURNIERab00df62016-07-14 11:42:37 +02005977 /* If the flags NOTERM is set, we cannot terminate the http
5978 * session, so we just end the execution of the current
5979 * lua code.
5980 */
5981 if (htxn->flags & HLUA_TXN_NOTERM) {
5982 WILL_LJMP(hlua_done(L));
5983 return 0;
5984 }
5985
Willy Tarreaub2ccb562015-04-06 11:11:15 +02005986 ic = &htxn->s->req;
5987 oc = &htxn->s->res;
Willy Tarreau81389672015-03-10 12:03:52 +01005988
Willy Tarreau630ef452015-08-28 10:06:15 +02005989 if (htxn->s->txn) {
5990 /* HTTP mode, let's stay in sync with the stream */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02005991 b_del(&ic->buf, htxn->s->txn->req.sov);
Willy Tarreau630ef452015-08-28 10:06:15 +02005992 htxn->s->txn->req.next -= htxn->s->txn->req.sov;
5993 htxn->s->txn->req.sov = 0;
5994 ic->analysers &= AN_REQ_HTTP_XFER_BODY;
5995 oc->analysers = AN_RES_HTTP_XFER_BODY;
5996 htxn->s->txn->req.msg_state = HTTP_MSG_CLOSED;
5997 htxn->s->txn->rsp.msg_state = HTTP_MSG_DONE;
5998
Willy Tarreau630ef452015-08-28 10:06:15 +02005999 /* Note that if we want to support keep-alive, we need
6000 * to bypass the close/shutr_now calls below, but that
6001 * may only be done if the HTTP request was already
6002 * processed and the connection header is known (ie
6003 * not during TCP rules).
6004 */
6005 }
6006
Thierry FOURNIER10ec2142015-08-24 17:23:45 +02006007 channel_auto_read(ic);
Willy Tarreau81389672015-03-10 12:03:52 +01006008 channel_abort(ic);
6009 channel_auto_close(ic);
6010 channel_erase(ic);
Thierry FOURNIER10ec2142015-08-24 17:23:45 +02006011
6012 oc->wex = tick_add_ifset(now_ms, oc->wto);
Willy Tarreau81389672015-03-10 12:03:52 +01006013 channel_auto_read(oc);
6014 channel_auto_close(oc);
6015 channel_shutr_now(oc);
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01006016
Willy Tarreau0458b082015-08-28 09:40:04 +02006017 ic->analysers = 0;
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02006018
Thierry FOURNIER9bd52d42016-07-14 11:45:33 +02006019 hlua->flags |= HLUA_STOP;
Thierry FOURNIER4bb375c2015-08-26 08:42:21 +02006020 WILL_LJMP(hlua_done(L));
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01006021 return 0;
6022}
6023
6024__LJMP static int hlua_log(lua_State *L)
6025{
6026 int level;
6027 const char *msg;
6028
6029 MAY_LJMP(check_args(L, 2, "log"));
6030 level = MAY_LJMP(luaL_checkinteger(L, 1));
6031 msg = MAY_LJMP(luaL_checkstring(L, 2));
6032
6033 if (level < 0 || level >= NB_LOG_LEVELS)
6034 WILL_LJMP(luaL_argerror(L, 1, "Invalid loglevel."));
6035
6036 hlua_sendlog(NULL, level, msg);
6037 return 0;
6038}
6039
6040__LJMP static int hlua_log_debug(lua_State *L)
6041{
6042 const char *msg;
6043
6044 MAY_LJMP(check_args(L, 1, "debug"));
6045 msg = MAY_LJMP(luaL_checkstring(L, 1));
6046 hlua_sendlog(NULL, LOG_DEBUG, msg);
6047 return 0;
6048}
6049
6050__LJMP static int hlua_log_info(lua_State *L)
6051{
6052 const char *msg;
6053
6054 MAY_LJMP(check_args(L, 1, "info"));
6055 msg = MAY_LJMP(luaL_checkstring(L, 1));
6056 hlua_sendlog(NULL, LOG_INFO, msg);
6057 return 0;
6058}
6059
6060__LJMP static int hlua_log_warning(lua_State *L)
6061{
6062 const char *msg;
6063
6064 MAY_LJMP(check_args(L, 1, "warning"));
6065 msg = MAY_LJMP(luaL_checkstring(L, 1));
6066 hlua_sendlog(NULL, LOG_WARNING, msg);
6067 return 0;
6068}
6069
6070__LJMP static int hlua_log_alert(lua_State *L)
6071{
6072 const char *msg;
6073
6074 MAY_LJMP(check_args(L, 1, "alert"));
6075 msg = MAY_LJMP(luaL_checkstring(L, 1));
6076 hlua_sendlog(NULL, LOG_ALERT, msg);
Thierry FOURNIER893bfa32015-02-17 18:42:34 +01006077 return 0;
6078}
6079
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01006080__LJMP static int hlua_sleep_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006081{
6082 int wakeup_ms = lua_tointeger(L, -1);
6083 if (now_ms < wakeup_ms)
Willy Tarreau9635e032018-10-16 17:52:55 +02006084 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006085 return 0;
6086}
6087
6088__LJMP static int hlua_sleep(lua_State *L)
6089{
6090 unsigned int delay;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006091 unsigned int wakeup_ms;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006092
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006093 MAY_LJMP(check_args(L, 1, "sleep"));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006094
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01006095 delay = MAY_LJMP(luaL_checkinteger(L, 1)) * 1000;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006096 wakeup_ms = tick_add(now_ms, delay);
6097 lua_pushinteger(L, wakeup_ms);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006098
Willy Tarreau9635e032018-10-16 17:52:55 +02006099 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006100 return 0;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006101}
6102
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006103__LJMP static int hlua_msleep(lua_State *L)
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006104{
6105 unsigned int delay;
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006106 unsigned int wakeup_ms;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006107
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006108 MAY_LJMP(check_args(L, 1, "msleep"));
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006109
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01006110 delay = MAY_LJMP(luaL_checkinteger(L, 1));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006111 wakeup_ms = tick_add(now_ms, delay);
6112 lua_pushinteger(L, wakeup_ms);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006113
Willy Tarreau9635e032018-10-16 17:52:55 +02006114 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_sleep_yield, wakeup_ms, 0));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006115 return 0;
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01006116}
6117
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01006118/* This functionis an LUA binding. it permits to give back
6119 * the hand at the HAProxy scheduler. It is used when the
6120 * LUA processing consumes a lot of time.
6121 */
Thierry FOURNIERf90838b2015-03-06 13:48:32 +01006122__LJMP static int hlua_yield_yield(lua_State *L, int status, lua_KContext ctx)
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006123{
6124 return 0;
6125}
6126
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01006127__LJMP static int hlua_yield(lua_State *L)
6128{
Willy Tarreau9635e032018-10-16 17:52:55 +02006129 MAY_LJMP(hlua_yieldk(L, 0, 0, hlua_yield_yield, TICK_ETERNITY, HLUA_CTRLYIELD));
Thierry FOURNIERd44731f2015-03-04 15:51:09 +01006130 return 0;
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01006131}
6132
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006133/* This function change the nice of the currently executed
6134 * task. It is used set low or high priority at the current
6135 * task.
6136 */
Willy Tarreau59551662015-03-10 14:23:13 +01006137__LJMP static int hlua_set_nice(lua_State *L)
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006138{
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006139 struct hlua *hlua;
6140 int nice;
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006141
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006142 MAY_LJMP(check_args(L, 1, "set_nice"));
6143 hlua = hlua_gethlua(L);
6144 nice = MAY_LJMP(luaL_checkinteger(L, 1));
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006145
6146 /* If he task is not set, I'm in a start mode. */
6147 if (!hlua || !hlua->task)
6148 return 0;
6149
6150 if (nice < -1024)
6151 nice = -1024;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01006152 else if (nice > 1024)
Thierry FOURNIER37196f42015-02-16 19:34:56 +01006153 nice = 1024;
6154
6155 hlua->task->nice = nice;
6156 return 0;
6157}
6158
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08006159/* This function is used as a callback of a task. It is called by the
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006160 * HAProxy task subsystem when the task is awaked. The LUA runtime can
6161 * return an E_AGAIN signal, the emmiter of this signal must set a
6162 * signal to wake the task.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006163 *
6164 * Task wrapper are longjmp safe because the only one Lua code
6165 * executed is the safe hlua_ctx_resume();
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006166 */
Olivier Houchard9f6af332018-05-25 14:04:04 +02006167static struct task *hlua_process_task(struct task *task, void *context, unsigned short state)
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006168{
Olivier Houchard9f6af332018-05-25 14:04:04 +02006169 struct hlua *hlua = context;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006170 enum hlua_exec status;
6171
Christopher Faulet5bc99722018-04-25 10:34:45 +02006172 if (task->thread_mask == MAX_THREADS_MASK)
6173 task_set_affinity(task, tid_bit);
6174
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006175 /* If it is the first call to the task, we must initialize the
6176 * execution timeouts.
6177 */
6178 if (!HLUA_IS_RUNNING(hlua))
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02006179 hlua->max_time = hlua_timeout_task;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006180
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006181 /* Execute the Lua code. */
6182 status = hlua_ctx_resume(hlua, 1);
6183
6184 switch (status) {
6185 /* finished or yield */
6186 case HLUA_E_OK:
6187 hlua_ctx_destroy(hlua);
Olivier Houchard3f795f72019-04-17 22:51:06 +02006188 task_destroy(task);
Tim Duesterhuscd235c62018-04-24 13:56:01 +02006189 task = NULL;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006190 break;
6191
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01006192 case HLUA_E_AGAIN: /* co process or timeout wake me later. */
Thierry FOURNIERcb146882017-12-10 17:10:57 +01006193 notification_gc(&hlua->com);
PiBa-NLfe971b32018-05-02 22:27:14 +02006194 task->expire = hlua->wake_time;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006195 break;
6196
6197 /* finished with error. */
6198 case HLUA_E_ERRMSG:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006199 SEND_ERR(NULL, "Lua task: %s.\n", lua_tostring(hlua->T, -1));
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006200 hlua_ctx_destroy(hlua);
Olivier Houchard3f795f72019-04-17 22:51:06 +02006201 task_destroy(task);
Emeric Brun253e53e2017-10-17 18:58:40 +02006202 task = NULL;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006203 break;
6204
6205 case HLUA_E_ERR:
6206 default:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006207 SEND_ERR(NULL, "Lua task: unknown error.\n");
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006208 hlua_ctx_destroy(hlua);
Olivier Houchard3f795f72019-04-17 22:51:06 +02006209 task_destroy(task);
Emeric Brun253e53e2017-10-17 18:58:40 +02006210 task = NULL;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006211 break;
6212 }
Emeric Brun253e53e2017-10-17 18:58:40 +02006213 return task;
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006214}
6215
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006216/* This function is an LUA binding that register LUA function to be
6217 * executed after the HAProxy configuration parsing and before the
6218 * HAProxy scheduler starts. This function expect only one LUA
6219 * argument that is a function. This function returns nothing, but
6220 * throws if an error is encountered.
6221 */
6222__LJMP static int hlua_register_init(lua_State *L)
6223{
6224 struct hlua_init_function *init;
6225 int ref;
6226
6227 MAY_LJMP(check_args(L, 1, "register_init"));
6228
6229 ref = MAY_LJMP(hlua_checkfunction(L, 1));
6230
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006231 init = calloc(1, sizeof(*init));
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006232 if (!init)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006233 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01006234
6235 init->function_ref = ref;
6236 LIST_ADDQ(&hlua_init_functions, &init->l);
6237 return 0;
6238}
6239
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006240/* This functio is an LUA binding. It permits to register a task
6241 * executed in parallel of the main HAroxy activity. The task is
6242 * created and it is set in the HAProxy scheduler. It can be called
6243 * from the "init" section, "post init" or during the runtime.
6244 *
6245 * Lua prototype:
6246 *
6247 * <none> core.register_task(<function>)
6248 */
6249static int hlua_register_task(lua_State *L)
6250{
6251 struct hlua *hlua;
6252 struct task *task;
6253 int ref;
6254
6255 MAY_LJMP(check_args(L, 1, "register_task"));
6256
6257 ref = MAY_LJMP(hlua_checkfunction(L, 1));
6258
Willy Tarreaubafbe012017-11-24 17:34:44 +01006259 hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006260 if (!hlua)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006261 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006262
Emeric Brunc60def82017-09-27 14:59:38 +02006263 task = task_new(MAX_THREADS_MASK);
Willy Tarreaue09101e2018-10-16 17:37:12 +02006264 if (!task)
6265 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
6266
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006267 task->context = hlua;
6268 task->process = hlua_process_task;
6269
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01006270 if (!hlua_ctx_init(hlua, task, 1))
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006271 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER24f33532015-01-23 12:13:00 +01006272
6273 /* Restore the function in the stack. */
6274 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ref);
6275 hlua->nargs = 0;
6276
6277 /* Schedule task. */
6278 task_schedule(task, now_ms);
6279
6280 return 0;
6281}
6282
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006283/* Wrapper called by HAProxy to execute an LUA converter. This wrapper
6284 * doesn't allow "yield" functions because the HAProxy engine cannot
6285 * resume converters.
6286 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006287static int hlua_sample_conv_wrapper(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006288{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02006289 struct hlua_function *fcn = private;
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006290 struct stream *stream = smp->strm;
Thierry Fournierfd107a22016-02-19 19:57:23 +01006291 const char *error;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006292
Willy Tarreaube508f12016-03-10 11:47:01 +01006293 if (!stream)
6294 return 0;
6295
Willy Tarreau87b09662015-04-03 00:22:06 +02006296 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006297 * Lua context can be not initialized. This behavior
6298 * permits to save performances because a systematic
6299 * Lua initialization cause 5% performances loss.
6300 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006301 if (!stream->hlua) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01006302 stream->hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006303 if (!stream->hlua) {
6304 SEND_ERR(stream->be, "Lua converter '%s': can't initialize Lua context.\n", fcn->name);
6305 return 0;
6306 }
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01006307 if (!hlua_ctx_init(stream->hlua, stream->task, 0)) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006308 SEND_ERR(stream->be, "Lua converter '%s': can't initialize Lua context.\n", fcn->name);
6309 return 0;
6310 }
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006311 }
6312
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006313 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006314 if (!HLUA_IS_RUNNING(stream->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006315
6316 /* The following Lua calls can fail. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006317 if (!SET_SAFE_LJMP(stream->hlua->T)) {
6318 if (lua_type(stream->hlua->T, -1) == LUA_TSTRING)
6319 error = lua_tostring(stream->hlua->T, -1);
Thierry Fournierfd107a22016-02-19 19:57:23 +01006320 else
6321 error = "critical error";
6322 SEND_ERR(stream->be, "Lua converter '%s': %s.\n", fcn->name, error);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006323 return 0;
6324 }
6325
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006326 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006327 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006328 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006329 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006330 return 0;
6331 }
6332
6333 /* Restore the function in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006334 lua_rawgeti(stream->hlua->T, LUA_REGISTRYINDEX, fcn->function_ref);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006335
6336 /* convert input sample and pust-it in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006337 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006338 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006339 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006340 return 0;
6341 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006342 hlua_smp2lua(stream->hlua->T, smp);
6343 stream->hlua->nargs = 1;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006344
6345 /* push keywords in the stack. */
6346 if (arg_p) {
6347 for (; arg_p->type != ARGT_STOP; arg_p++) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006348 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006349 SEND_ERR(stream->be, "Lua converter '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006350 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006351 return 0;
6352 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006353 hlua_arg2lua(stream->hlua->T, arg_p);
6354 stream->hlua->nargs++;
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006355 }
6356 }
6357
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006358 /* We must initialize the execution timeouts. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006359 stream->hlua->max_time = hlua_timeout_session;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006360
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006361 /* At this point the execution is safe. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006362 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006363 }
6364
6365 /* Execute the function. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006366 switch (hlua_ctx_resume(stream->hlua, 0)) {
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006367 /* finished. */
6368 case HLUA_E_OK:
Thierry FOURNIERfd80df12017-05-12 16:32:20 +02006369 /* If the stack is empty, the function fails. */
6370 if (lua_gettop(stream->hlua->T) <= 0)
6371 return 0;
6372
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006373 /* Convert the returned value in sample. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006374 hlua_lua2smp(stream->hlua->T, -1, smp);
6375 lua_pop(stream->hlua->T, 1);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006376 return 1;
6377
6378 /* yield. */
6379 case HLUA_E_AGAIN:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006380 SEND_ERR(stream->be, "Lua converter '%s': cannot use yielded functions.\n", fcn->name);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006381 return 0;
6382
6383 /* finished with error. */
6384 case HLUA_E_ERRMSG:
6385 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006386 SEND_ERR(stream->be, "Lua converter '%s': %s.\n",
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006387 fcn->name, lua_tostring(stream->hlua->T, -1));
6388 lua_pop(stream->hlua->T, 1);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006389 return 0;
6390
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006391 case HLUA_E_ETMOUT:
6392 SEND_ERR(stream->be, "Lua converter '%s': execution timeout.\n", fcn->name);
6393 return 0;
6394
6395 case HLUA_E_NOMEM:
6396 SEND_ERR(stream->be, "Lua converter '%s': out of memory error.\n", fcn->name);
6397 return 0;
6398
6399 case HLUA_E_YIELD:
6400 SEND_ERR(stream->be, "Lua converter '%s': yield functions like core.tcp() or core.sleep() are not allowed.\n", fcn->name);
6401 return 0;
6402
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006403 case HLUA_E_ERR:
6404 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006405 SEND_ERR(stream->be, "Lua converter '%s' returns an unknown error.\n", fcn->name);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006406
6407 default:
6408 return 0;
6409 }
6410}
6411
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006412/* Wrapper called by HAProxy to execute a sample-fetch. this wrapper
6413 * doesn't allow "yield" functions because the HAProxy engine cannot
Willy Tarreaube508f12016-03-10 11:47:01 +01006414 * resume sample-fetches. This function will be called by the sample
6415 * fetch engine to call lua-based fetch operations.
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006416 */
Thierry FOURNIER0786d052015-05-11 15:42:45 +02006417static int hlua_sample_fetch_wrapper(const struct arg *arg_p, struct sample *smp,
6418 const char *kw, void *private)
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006419{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02006420 struct hlua_function *fcn = private;
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006421 struct stream *stream = smp->strm;
Thierry Fournierfd107a22016-02-19 19:57:23 +01006422 const char *error;
Willy Tarreau83061a82018-07-13 11:56:34 +02006423 const struct buffer msg = { };
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006424
Willy Tarreaube508f12016-03-10 11:47:01 +01006425 if (!stream)
6426 return 0;
Christopher Fauletafd8f102018-11-08 11:34:21 +01006427
Willy Tarreau87b09662015-04-03 00:22:06 +02006428 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006429 * Lua context can be not initialized. This behavior
6430 * permits to save performances because a systematic
6431 * Lua initialization cause 5% performances loss.
6432 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006433 if (!stream->hlua) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01006434 stream->hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006435 if (!stream->hlua) {
6436 SEND_ERR(stream->be, "Lua sample-fetch '%s': can't initialize Lua context.\n", fcn->name);
6437 return 0;
6438 }
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01006439 if (!hlua_ctx_init(stream->hlua, stream->task, 0)) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006440 SEND_ERR(stream->be, "Lua sample-fetch '%s': can't initialize Lua context.\n", fcn->name);
6441 return 0;
6442 }
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006443 }
6444
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006445 consistency_set(stream, smp->opt, &stream->hlua->cons);
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01006446
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006447 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006448 if (!HLUA_IS_RUNNING(stream->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006449
6450 /* The following Lua calls can fail. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006451 if (!SET_SAFE_LJMP(stream->hlua->T)) {
6452 if (lua_type(stream->hlua->T, -1) == LUA_TSTRING)
6453 error = lua_tostring(stream->hlua->T, -1);
Thierry Fournierfd107a22016-02-19 19:57:23 +01006454 else
6455 error = "critical error";
6456 SEND_ERR(smp->px, "Lua sample-fetch '%s': %s.\n", fcn->name, error);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006457 return 0;
6458 }
6459
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006460 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006461 if (!lua_checkstack(stream->hlua->T, 2)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006462 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006463 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006464 return 0;
6465 }
6466
6467 /* Restore the function in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006468 lua_rawgeti(stream->hlua->T, LUA_REGISTRYINDEX, fcn->function_ref);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006469
6470 /* push arguments in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006471 if (!hlua_txn_new(stream->hlua->T, stream, smp->px, smp->opt & SMP_OPT_DIR,
Thierry FOURNIERab00df62016-07-14 11:42:37 +02006472 HLUA_TXN_NOTERM)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006473 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006474 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006475 return 0;
6476 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006477 stream->hlua->nargs = 1;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006478
6479 /* push keywords in the stack. */
6480 for (; arg_p && arg_p->type != ARGT_STOP; arg_p++) {
6481 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006482 if (!lua_checkstack(stream->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006483 SEND_ERR(smp->px, "Lua sample-fetch '%s': full stack.\n", fcn->name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006484 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006485 return 0;
6486 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006487 hlua_arg2lua(stream->hlua->T, arg_p);
6488 stream->hlua->nargs++;
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006489 }
6490
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006491 /* We must initialize the execution timeouts. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006492 stream->hlua->max_time = hlua_timeout_session;
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006493
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006494 /* At this point the execution is safe. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006495 RESET_SAFE_LJMP(stream->hlua->T);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006496 }
6497
6498 /* Execute the function. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006499 switch (hlua_ctx_resume(stream->hlua, 0)) {
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006500 /* finished. */
6501 case HLUA_E_OK:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006502 if (!consistency_check(stream, smp->opt, &stream->hlua->cons)) {
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006503 si_retnclose(&stream->si[0], &msg);
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02006504 return 0;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01006505 }
Thierry FOURNIERfd80df12017-05-12 16:32:20 +02006506 /* If the stack is empty, the function fails. */
6507 if (lua_gettop(stream->hlua->T) <= 0)
6508 return 0;
6509
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006510 /* Convert the returned value in sample. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006511 hlua_lua2smp(stream->hlua->T, -1, smp);
6512 lua_pop(stream->hlua->T, 1);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006513
6514 /* Set the end of execution flag. */
6515 smp->flags &= ~SMP_F_MAY_CHANGE;
6516 return 1;
6517
6518 /* yield. */
6519 case HLUA_E_AGAIN:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006520 if (!consistency_check(stream, smp->opt, &stream->hlua->cons))
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006521 si_retnclose(&stream->si[0], &msg);
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006522 SEND_ERR(smp->px, "Lua sample-fetch '%s': cannot use yielded functions.\n", fcn->name);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006523 return 0;
6524
6525 /* finished with error. */
6526 case HLUA_E_ERRMSG:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006527 if (!consistency_check(stream, smp->opt, &stream->hlua->cons))
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006528 si_retnclose(&stream->si[0], &msg);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006529 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006530 SEND_ERR(smp->px, "Lua sample-fetch '%s': %s.\n",
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006531 fcn->name, lua_tostring(stream->hlua->T, -1));
6532 lua_pop(stream->hlua->T, 1);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006533 return 0;
6534
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006535 case HLUA_E_ETMOUT:
6536 if (!consistency_check(stream, smp->opt, &stream->hlua->cons))
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006537 si_retnclose(&stream->si[0], &msg);
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006538 SEND_ERR(smp->px, "Lua sample-fetch '%s': execution timeout.\n", fcn->name);
6539 return 0;
6540
6541 case HLUA_E_NOMEM:
6542 if (!consistency_check(stream, smp->opt, &stream->hlua->cons))
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006543 si_retnclose(&stream->si[0], &msg);
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006544 SEND_ERR(smp->px, "Lua sample-fetch '%s': out of memory error.\n", fcn->name);
6545 return 0;
6546
6547 case HLUA_E_YIELD:
6548 if (!consistency_check(stream, smp->opt, &stream->hlua->cons))
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006549 si_retnclose(&stream->si[0], &msg);
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006550 SEND_ERR(smp->px, "Lua sample-fetch '%s': yield not allowed.\n", fcn->name);
6551 return 0;
6552
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006553 case HLUA_E_ERR:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006554 if (!consistency_check(stream, smp->opt, &stream->hlua->cons))
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006555 si_retnclose(&stream->si[0], &msg);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006556 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006557 SEND_ERR(smp->px, "Lua sample-fetch '%s' returns an unknown error.\n", fcn->name);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006558
6559 default:
6560 return 0;
6561 }
6562}
6563
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006564/* This function is an LUA binding used for registering
6565 * "sample-conv" functions. It expects a converter name used
6566 * in the haproxy configuration file, and an LUA function.
6567 */
6568__LJMP static int hlua_register_converters(lua_State *L)
6569{
6570 struct sample_conv_kw_list *sck;
6571 const char *name;
6572 int ref;
6573 int len;
6574 struct hlua_function *fcn;
6575
6576 MAY_LJMP(check_args(L, 2, "register_converters"));
6577
6578 /* First argument : converter name. */
6579 name = MAY_LJMP(luaL_checkstring(L, 1));
6580
6581 /* Second argument : lua function. */
6582 ref = MAY_LJMP(hlua_checkfunction(L, 2));
6583
6584 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006585 sck = calloc(1, sizeof(*sck) + sizeof(struct sample_conv) * 2);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006586 if (!sck)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006587 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006588 fcn = calloc(1, sizeof(*fcn));
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006589 if (!fcn)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006590 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006591
6592 /* Fill fcn. */
6593 fcn->name = strdup(name);
6594 if (!fcn->name)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006595 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006596 fcn->function_ref = ref;
6597
6598 /* List head */
6599 sck->list.n = sck->list.p = NULL;
6600
6601 /* converter keyword. */
6602 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006603 sck->kw[0].kw = calloc(1, len);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006604 if (!sck->kw[0].kw)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006605 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006606
6607 snprintf((char *)sck->kw[0].kw, len, "lua.%s", name);
6608 sck->kw[0].process = hlua_sample_conv_wrapper;
David Carlier0c437f42016-04-27 16:21:56 +01006609 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 +01006610 sck->kw[0].val_args = NULL;
6611 sck->kw[0].in_type = SMP_T_STR;
6612 sck->kw[0].out_type = SMP_T_STR;
6613 sck->kw[0].private = fcn;
6614
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01006615 /* Register this new converter */
6616 sample_register_convs(sck);
6617
6618 return 0;
6619}
6620
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08006621/* This function is an LUA binding used for registering
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006622 * "sample-fetch" functions. It expects a converter name used
6623 * in the haproxy configuration file, and an LUA function.
6624 */
6625__LJMP static int hlua_register_fetches(lua_State *L)
6626{
6627 const char *name;
6628 int ref;
6629 int len;
6630 struct sample_fetch_kw_list *sfk;
6631 struct hlua_function *fcn;
6632
6633 MAY_LJMP(check_args(L, 2, "register_fetches"));
6634
6635 /* First argument : sample-fetch name. */
6636 name = MAY_LJMP(luaL_checkstring(L, 1));
6637
6638 /* Second argument : lua function. */
6639 ref = MAY_LJMP(hlua_checkfunction(L, 2));
6640
6641 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006642 sfk = calloc(1, sizeof(*sfk) + sizeof(struct sample_fetch) * 2);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006643 if (!sfk)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006644 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006645 fcn = calloc(1, sizeof(*fcn));
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006646 if (!fcn)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006647 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006648
6649 /* Fill fcn. */
6650 fcn->name = strdup(name);
6651 if (!fcn->name)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006652 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006653 fcn->function_ref = ref;
6654
6655 /* List head */
6656 sfk->list.n = sfk->list.p = NULL;
6657
6658 /* sample-fetch keyword. */
6659 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02006660 sfk->kw[0].kw = calloc(1, len);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006661 if (!sfk->kw[0].kw)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01006662 return luaL_error(L, "Lua out of memory error.");
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006663
6664 snprintf((char *)sfk->kw[0].kw, len, "lua.%s", name);
6665 sfk->kw[0].process = hlua_sample_fetch_wrapper;
David Carlier0c437f42016-04-27 16:21:56 +01006666 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 +01006667 sfk->kw[0].val_args = NULL;
6668 sfk->kw[0].out_type = SMP_T_STR;
6669 sfk->kw[0].use = SMP_USE_HTTP_ANY;
6670 sfk->kw[0].val = 0;
6671 sfk->kw[0].private = fcn;
6672
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01006673 /* Register this new fetch. */
6674 sample_register_fetches(sfk);
6675
6676 return 0;
6677}
6678
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006679/* This function is a wrapper to execute each LUA function declared
6680 * as an action wrapper during the initialisation period. This function
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006681 * return ACT_RET_CONT if the processing is finished (with or without
6682 * error) and return ACT_RET_YIELD if the function must be called again
6683 * because the LUA returns a yield.
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006684 */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006685static enum act_return hlua_action(struct act_rule *rule, struct proxy *px,
Willy Tarreau658b85b2015-09-27 10:00:49 +02006686 struct session *sess, struct stream *s, int flags)
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006687{
6688 char **arg;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006689 unsigned int analyzer;
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02006690 int dir;
Thierry Fournierfd107a22016-02-19 19:57:23 +01006691 const char *error;
Willy Tarreau83061a82018-07-13 11:56:34 +02006692 const struct buffer msg = { };
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006693
6694 switch (rule->from) {
Thierry FOURNIER6e01f382015-11-02 09:52:54 +01006695 case ACT_F_TCP_REQ_CNT: analyzer = AN_REQ_INSPECT_FE ; dir = SMP_OPT_DIR_REQ; break;
6696 case ACT_F_TCP_RES_CNT: analyzer = AN_RES_INSPECT ; dir = SMP_OPT_DIR_RES; break;
6697 case ACT_F_HTTP_REQ: analyzer = AN_REQ_HTTP_PROCESS_FE; dir = SMP_OPT_DIR_REQ; break;
6698 case ACT_F_HTTP_RES: analyzer = AN_RES_HTTP_PROCESS_BE; dir = SMP_OPT_DIR_RES; break;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006699 default:
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006700 SEND_ERR(px, "Lua: internal error while execute action.\n");
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006701 return ACT_RET_CONT;
6702 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006703
Willy Tarreau87b09662015-04-03 00:22:06 +02006704 /* In the execution wrappers linked with a stream, the
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006705 * Lua context can be not initialized. This behavior
6706 * permits to save performances because a systematic
6707 * Lua initialization cause 5% performances loss.
6708 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006709 if (!s->hlua) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01006710 s->hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006711 if (!s->hlua) {
6712 SEND_ERR(px, "Lua action '%s': can't initialize Lua context.\n",
6713 rule->arg.hlua_rule->fcn.name);
6714 return ACT_RET_CONT;
6715 }
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01006716 if (!hlua_ctx_init(s->hlua, s->task, 0)) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006717 SEND_ERR(px, "Lua action '%s': can't initialize Lua context.\n",
6718 rule->arg.hlua_rule->fcn.name);
6719 return ACT_RET_CONT;
6720 }
Thierry FOURNIER05ac4242015-02-27 18:37:27 +01006721 }
6722
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006723 consistency_set(s, dir, &s->hlua->cons);
6724
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006725 /* If it is the first run, initialize the data for the call. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006726 if (!HLUA_IS_RUNNING(s->hlua)) {
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006727
6728 /* The following Lua calls can fail. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006729 if (!SET_SAFE_LJMP(s->hlua->T)) {
6730 if (lua_type(s->hlua->T, -1) == LUA_TSTRING)
6731 error = lua_tostring(s->hlua->T, -1);
Thierry Fournierfd107a22016-02-19 19:57:23 +01006732 else
6733 error = "critical error";
6734 SEND_ERR(px, "Lua function '%s': %s.\n",
6735 rule->arg.hlua_rule->fcn.name, error);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006736 return ACT_RET_CONT;
6737 }
6738
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006739 /* Check stack available size. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006740 if (!lua_checkstack(s->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006741 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006742 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006743 RESET_SAFE_LJMP(s->hlua->T);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02006744 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006745 }
6746
6747 /* Restore the function in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006748 lua_rawgeti(s->hlua->T, LUA_REGISTRYINDEX, rule->arg.hlua_rule->fcn.function_ref);
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006749
Willy Tarreau87b09662015-04-03 00:22:06 +02006750 /* Create and and push object stream in the stack. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006751 if (!hlua_txn_new(s->hlua->T, s, px, dir, 0)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006752 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006753 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006754 RESET_SAFE_LJMP(s->hlua->T);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02006755 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006756 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006757 s->hlua->nargs = 1;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006758
6759 /* push keywords in the stack. */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006760 for (arg = rule->arg.hlua_rule->args; arg && *arg; arg++) {
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006761 if (!lua_checkstack(s->hlua->T, 1)) {
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006762 SEND_ERR(px, "Lua function '%s': full stack.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006763 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006764 RESET_SAFE_LJMP(s->hlua->T);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02006765 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006766 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006767 lua_pushstring(s->hlua->T, *arg);
6768 s->hlua->nargs++;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006769 }
6770
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006771 /* Now the execution is safe. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006772 RESET_SAFE_LJMP(s->hlua->T);
Thierry FOURNIERbabae282015-09-17 11:36:37 +02006773
Thierry FOURNIERbd413492015-03-03 16:52:26 +01006774 /* We must initialize the execution timeouts. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006775 s->hlua->max_time = hlua_timeout_session;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006776 }
6777
6778 /* Execute the function. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006779 switch (hlua_ctx_resume(s->hlua, !(flags & ACT_FLAG_FINAL))) {
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006780 /* finished. */
6781 case HLUA_E_OK:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006782 if (!consistency_check(s, dir, &s->hlua->cons)) {
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006783 si_retnclose(&s->si[0], &msg);
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02006784 return ACT_RET_ERR;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01006785 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006786 if (s->hlua->flags & HLUA_STOP)
Thierry FOURNIER9bd52d42016-07-14 11:45:33 +02006787 return ACT_RET_STOP;
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02006788 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006789
6790 /* yield. */
6791 case HLUA_E_AGAIN:
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01006792 /* Set timeout in the required channel. */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006793 if (s->hlua->wake_time != TICK_ETERNITY) {
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01006794 if (analyzer & (AN_REQ_INSPECT_FE|AN_REQ_HTTP_PROCESS_FE))
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006795 s->req.analyse_exp = s->hlua->wake_time;
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01006796 else if (analyzer & (AN_RES_INSPECT|AN_RES_HTTP_PROCESS_BE))
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006797 s->res.analyse_exp = s->hlua->wake_time;
Thierry FOURNIERc42c1ae2015-03-03 17:17:55 +01006798 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006799 /* Some actions can be wake up when a "write" event
6800 * is detected on a response channel. This is useful
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08006801 * only for actions targeted on the requests.
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006802 */
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006803 if (HLUA_IS_WAKERESWR(s->hlua)) {
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01006804 s->res.flags |= CF_WAKE_WRITE;
Willy Tarreau76bd97f2015-03-10 17:16:10 +01006805 if ((analyzer & (AN_REQ_INSPECT_FE|AN_REQ_HTTP_PROCESS_FE)))
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01006806 s->res.analysers |= analyzer;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006807 }
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006808 if (HLUA_IS_WAKEREQWR(s->hlua))
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01006809 s->req.flags |= CF_WAKE_WRITE;
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08006810 /* We can quit the function without consistency check
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01006811 * because HAProxy is not able to manipulate data, it
6812 * is only allowed to call me again. */
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02006813 return ACT_RET_YIELD;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006814
6815 /* finished with error. */
6816 case HLUA_E_ERRMSG:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006817 if (!consistency_check(s, dir, &s->hlua->cons)) {
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006818 si_retnclose(&s->si[0], &msg);
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02006819 return ACT_RET_ERR;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01006820 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006821 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006822 SEND_ERR(px, "Lua function '%s': %s.\n",
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006823 rule->arg.hlua_rule->fcn.name, lua_tostring(s->hlua->T, -1));
6824 lua_pop(s->hlua->T, 1);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02006825 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006826
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006827 case HLUA_E_ETMOUT:
6828 if (!consistency_check(s, dir, &s->hlua->cons)) {
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006829 si_retnclose(&s->si[0], &msg);
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006830 return ACT_RET_ERR;
6831 }
6832 SEND_ERR(px, "Lua function '%s': execution timeout.\n", rule->arg.hlua_rule->fcn.name);
6833 return 0;
6834
6835 case HLUA_E_NOMEM:
6836 if (!consistency_check(s, dir, &s->hlua->cons)) {
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006837 si_retnclose(&s->si[0], &msg);
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006838 return ACT_RET_ERR;
6839 }
6840 SEND_ERR(px, "Lua function '%s': out of memory error.\n", rule->arg.hlua_rule->fcn.name);
6841 return 0;
6842
6843 case HLUA_E_YIELD:
6844 if (!consistency_check(s, dir, &s->hlua->cons)) {
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006845 si_retnclose(&s->si[0], &msg);
Thierry Fournierd5b073c2018-05-21 19:42:47 +02006846 return ACT_RET_ERR;
6847 }
6848 SEND_ERR(px, "Lua function '%s': aborting Lua processing on expired timeout.\n",
6849 rule->arg.hlua_rule->fcn.name);
6850 return 0;
6851
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006852 case HLUA_E_ERR:
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +01006853 if (!consistency_check(s, dir, &s->hlua->cons)) {
Willy Tarreau14bfe9a2018-12-19 15:19:27 +01006854 si_retnclose(&s->si[0], &msg);
Thierry FOURNIERd75cb0f2015-09-25 19:22:44 +02006855 return ACT_RET_ERR;
Thierry FOURNIER11cfb3d2016-12-13 13:06:23 +01006856 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006857 /* Display log. */
Thierry FOURNIER23bc3752015-09-11 19:15:43 +02006858 SEND_ERR(px, "Lua function '%s' return an unknown error.\n",
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02006859 rule->arg.hlua_rule->fcn.name);
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006860
6861 default:
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +02006862 return ACT_RET_CONT;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01006863 }
6864}
6865
Olivier Houchard9f6af332018-05-25 14:04:04 +02006866struct task *hlua_applet_wakeup(struct task *t, void *context, unsigned short state)
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006867{
Olivier Houchard9f6af332018-05-25 14:04:04 +02006868 struct appctx *ctx = context;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006869
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006870 appctx_wakeup(ctx);
Willy Tarreaud9587412017-08-23 16:07:33 +02006871 t->expire = TICK_ETERNITY;
Willy Tarreaud1aa41f2017-07-21 16:41:56 +02006872 return t;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006873}
6874
6875static int hlua_applet_tcp_init(struct appctx *ctx, struct proxy *px, struct stream *strm)
6876{
6877 struct stream_interface *si = ctx->owner;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006878 struct hlua *hlua;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006879 struct task *task;
6880 char **arg;
Thierry Fournierfd107a22016-02-19 19:57:23 +01006881 const char *error;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006882
Willy Tarreaubafbe012017-11-24 17:34:44 +01006883 hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006884 if (!hlua) {
6885 SEND_ERR(px, "Lua applet tcp '%s': out of memory.\n",
6886 ctx->rule->arg.hlua_rule->fcn.name);
6887 return 0;
6888 }
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006889 HLUA_INIT(hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006890 ctx->ctx.hlua_apptcp.hlua = hlua;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006891 ctx->ctx.hlua_apptcp.flags = 0;
6892
6893 /* Create task used by signal to wakeup applets. */
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01006894 task = task_new(tid_bit);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006895 if (!task) {
6896 SEND_ERR(px, "Lua applet tcp '%s': out of memory.\n",
6897 ctx->rule->arg.hlua_rule->fcn.name);
6898 return 0;
6899 }
6900 task->nice = 0;
6901 task->context = ctx;
6902 task->process = hlua_applet_wakeup;
6903 ctx->ctx.hlua_apptcp.task = task;
6904
6905 /* In the execution wrappers linked with a stream, the
6906 * Lua context can be not initialized. This behavior
6907 * permits to save performances because a systematic
6908 * Lua initialization cause 5% performances loss.
6909 */
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01006910 if (!hlua_ctx_init(hlua, task, 0)) {
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006911 SEND_ERR(px, "Lua applet tcp '%s': can't initialize Lua context.\n",
6912 ctx->rule->arg.hlua_rule->fcn.name);
6913 return 0;
6914 }
6915
6916 /* Set timeout according with the applet configuration. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02006917 hlua->max_time = ctx->applet->timeout;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006918
6919 /* The following Lua calls can fail. */
6920 if (!SET_SAFE_LJMP(hlua->T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01006921 if (lua_type(hlua->T, -1) == LUA_TSTRING)
6922 error = lua_tostring(hlua->T, -1);
6923 else
6924 error = "critical error";
6925 SEND_ERR(px, "Lua applet tcp '%s': %s.\n",
6926 ctx->rule->arg.hlua_rule->fcn.name, error);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006927 return 0;
6928 }
6929
6930 /* Check stack available size. */
6931 if (!lua_checkstack(hlua->T, 1)) {
6932 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
6933 ctx->rule->arg.hlua_rule->fcn.name);
6934 RESET_SAFE_LJMP(hlua->T);
6935 return 0;
6936 }
6937
6938 /* Restore the function in the stack. */
6939 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ctx->rule->arg.hlua_rule->fcn.function_ref);
6940
6941 /* Create and and push object stream in the stack. */
6942 if (!hlua_applet_tcp_new(hlua->T, ctx)) {
6943 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
6944 ctx->rule->arg.hlua_rule->fcn.name);
6945 RESET_SAFE_LJMP(hlua->T);
6946 return 0;
6947 }
6948 hlua->nargs = 1;
6949
6950 /* push keywords in the stack. */
6951 for (arg = ctx->rule->arg.hlua_rule->args; arg && *arg; arg++) {
6952 if (!lua_checkstack(hlua->T, 1)) {
6953 SEND_ERR(px, "Lua applet tcp '%s': full stack.\n",
6954 ctx->rule->arg.hlua_rule->fcn.name);
6955 RESET_SAFE_LJMP(hlua->T);
6956 return 0;
6957 }
6958 lua_pushstring(hlua->T, *arg);
6959 hlua->nargs++;
6960 }
6961
6962 RESET_SAFE_LJMP(hlua->T);
6963
6964 /* Wakeup the applet ASAP. */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01006965 si_cant_get(si);
Willy Tarreau3367d412018-11-15 10:57:41 +01006966 si_rx_endp_more(si);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006967
6968 return 1;
6969}
6970
6971static void hlua_applet_tcp_fct(struct appctx *ctx)
6972{
6973 struct stream_interface *si = ctx->owner;
6974 struct stream *strm = si_strm(si);
6975 struct channel *res = si_ic(si);
6976 struct act_rule *rule = ctx->rule;
6977 struct proxy *px = strm->be;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01006978 struct hlua *hlua = ctx->ctx.hlua_apptcp.hlua;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006979
6980 /* The applet execution is already done. */
Olivier Houchard594c8c52018-08-28 14:41:31 +02006981 if (ctx->ctx.hlua_apptcp.flags & APPLET_DONE) {
6982 /* eat the whole request */
6983 co_skip(si_oc(si), co_data(si_oc(si)));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006984 return;
Olivier Houchard594c8c52018-08-28 14:41:31 +02006985 }
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006986
6987 /* If the stream is disconnect or closed, ldo nothing. */
6988 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
6989 return;
6990
6991 /* Execute the function. */
6992 switch (hlua_ctx_resume(hlua, 1)) {
6993 /* finished. */
6994 case HLUA_E_OK:
6995 ctx->ctx.hlua_apptcp.flags |= APPLET_DONE;
6996
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006997 /* eat the whole request */
Willy Tarreaua79021a2018-06-15 18:07:57 +02006998 co_skip(si_oc(si), co_data(si_oc(si)));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02006999 res->flags |= CF_READ_NULL;
7000 si_shutr(si);
7001 return;
7002
7003 /* yield. */
7004 case HLUA_E_AGAIN:
Thierry Fournier0164f202016-02-20 17:47:43 +01007005 if (hlua->wake_time != TICK_ETERNITY)
7006 task_schedule(ctx->ctx.hlua_apptcp.task, hlua->wake_time);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007007 return;
7008
7009 /* finished with error. */
7010 case HLUA_E_ERRMSG:
7011 /* Display log. */
7012 SEND_ERR(px, "Lua applet tcp '%s': %s.\n",
7013 rule->arg.hlua_rule->fcn.name, lua_tostring(hlua->T, -1));
7014 lua_pop(hlua->T, 1);
7015 goto error;
7016
Thierry Fournierd5b073c2018-05-21 19:42:47 +02007017 case HLUA_E_ETMOUT:
7018 SEND_ERR(px, "Lua applet tcp '%s': execution timeout.\n",
7019 rule->arg.hlua_rule->fcn.name);
7020 goto error;
7021
7022 case HLUA_E_NOMEM:
7023 SEND_ERR(px, "Lua applet tcp '%s': out of memory error.\n",
7024 rule->arg.hlua_rule->fcn.name);
7025 goto error;
7026
7027 case HLUA_E_YIELD: /* unexpected */
7028 SEND_ERR(px, "Lua applet tcp '%s': yield not allowed.\n",
7029 rule->arg.hlua_rule->fcn.name);
7030 goto error;
7031
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007032 case HLUA_E_ERR:
7033 /* Display log. */
7034 SEND_ERR(px, "Lua applet tcp '%s' return an unknown error.\n",
7035 rule->arg.hlua_rule->fcn.name);
7036 goto error;
7037
7038 default:
7039 goto error;
7040 }
7041
7042error:
7043
7044 /* For all other cases, just close the stream. */
7045 si_shutw(si);
7046 si_shutr(si);
7047 ctx->ctx.hlua_apptcp.flags |= APPLET_DONE;
7048}
7049
7050static void hlua_applet_tcp_release(struct appctx *ctx)
7051{
Olivier Houchard3f795f72019-04-17 22:51:06 +02007052 task_destroy(ctx->ctx.hlua_apptcp.task);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007053 ctx->ctx.hlua_apptcp.task = NULL;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007054 hlua_ctx_destroy(ctx->ctx.hlua_apptcp.hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007055 ctx->ctx.hlua_apptcp.hlua = NULL;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007056}
7057
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007058/* The function returns 1 if the initialisation is complete, 0 if
7059 * an errors occurs and -1 if more data are required for initializing
7060 * the applet.
7061 */
7062static int hlua_applet_http_init(struct appctx *ctx, struct proxy *px, struct stream *strm)
7063{
7064 struct stream_interface *si = ctx->owner;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007065 struct http_txn *txn;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007066 struct hlua *hlua;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007067 char **arg;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007068 struct task *task;
Thierry Fournierfd107a22016-02-19 19:57:23 +01007069 const char *error;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007070
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007071 txn = strm->txn;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007072
Willy Tarreau0078bfc2015-10-07 20:20:28 +02007073 /* We want two things in HTTP mode :
7074 * - enforce server-close mode if we were in keep-alive, so that the
7075 * applet is released after each response ;
7076 * - enable request body transfer to the applet in order to resync
7077 * with the response body.
7078 */
7079 if ((txn->flags & TX_CON_WANT_MSK) == TX_CON_WANT_KAL)
7080 txn->flags = (txn->flags & ~TX_CON_WANT_MSK) | TX_CON_WANT_SCL;
Willy Tarreau0078bfc2015-10-07 20:20:28 +02007081
Willy Tarreaubafbe012017-11-24 17:34:44 +01007082 hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007083 if (!hlua) {
7084 SEND_ERR(px, "Lua applet http '%s': out of memory.\n",
7085 ctx->rule->arg.hlua_rule->fcn.name);
7086 return 0;
7087 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007088 HLUA_INIT(hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007089 ctx->ctx.hlua_apphttp.hlua = hlua;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007090 ctx->ctx.hlua_apphttp.left_bytes = -1;
7091 ctx->ctx.hlua_apphttp.flags = 0;
7092
Thierry FOURNIERd93ea2b2015-12-20 19:14:52 +01007093 if (txn->req.flags & HTTP_MSGF_VER_11)
7094 ctx->ctx.hlua_apphttp.flags |= APPLET_HTTP11;
7095
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007096 /* Create task used by signal to wakeup applets. */
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01007097 task = task_new(tid_bit);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007098 if (!task) {
7099 SEND_ERR(px, "Lua applet http '%s': out of memory.\n",
7100 ctx->rule->arg.hlua_rule->fcn.name);
7101 return 0;
7102 }
7103 task->nice = 0;
7104 task->context = ctx;
7105 task->process = hlua_applet_wakeup;
7106 ctx->ctx.hlua_apphttp.task = task;
7107
7108 /* In the execution wrappers linked with a stream, the
7109 * Lua context can be not initialized. This behavior
7110 * permits to save performances because a systematic
7111 * Lua initialization cause 5% performances loss.
7112 */
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01007113 if (!hlua_ctx_init(hlua, task, 0)) {
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007114 SEND_ERR(px, "Lua applet http '%s': can't initialize Lua context.\n",
7115 ctx->rule->arg.hlua_rule->fcn.name);
7116 return 0;
7117 }
7118
7119 /* Set timeout according with the applet configuration. */
Thierry FOURNIER10770fa2015-09-29 01:59:42 +02007120 hlua->max_time = ctx->applet->timeout;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007121
7122 /* The following Lua calls can fail. */
7123 if (!SET_SAFE_LJMP(hlua->T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01007124 if (lua_type(hlua->T, -1) == LUA_TSTRING)
7125 error = lua_tostring(hlua->T, -1);
7126 else
7127 error = "critical error";
7128 SEND_ERR(px, "Lua applet http '%s': %s.\n",
7129 ctx->rule->arg.hlua_rule->fcn.name, error);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007130 return 0;
7131 }
7132
7133 /* Check stack available size. */
7134 if (!lua_checkstack(hlua->T, 1)) {
7135 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
7136 ctx->rule->arg.hlua_rule->fcn.name);
7137 RESET_SAFE_LJMP(hlua->T);
7138 return 0;
7139 }
7140
7141 /* Restore the function in the stack. */
7142 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, ctx->rule->arg.hlua_rule->fcn.function_ref);
7143
7144 /* Create and and push object stream in the stack. */
7145 if (!hlua_applet_http_new(hlua->T, ctx)) {
7146 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
7147 ctx->rule->arg.hlua_rule->fcn.name);
7148 RESET_SAFE_LJMP(hlua->T);
7149 return 0;
7150 }
7151 hlua->nargs = 1;
7152
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007153 /* push keywords in the stack. */
7154 for (arg = ctx->rule->arg.hlua_rule->args; arg && *arg; arg++) {
7155 if (!lua_checkstack(hlua->T, 1)) {
7156 SEND_ERR(px, "Lua applet http '%s': full stack.\n",
7157 ctx->rule->arg.hlua_rule->fcn.name);
7158 RESET_SAFE_LJMP(hlua->T);
7159 return 0;
7160 }
7161 lua_pushstring(hlua->T, *arg);
7162 hlua->nargs++;
7163 }
7164
7165 RESET_SAFE_LJMP(hlua->T);
7166
7167 /* Wakeup the applet when data is ready for read. */
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01007168 si_cant_get(si);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007169
7170 return 1;
7171}
7172
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007173static void hlua_applet_htx_fct(struct appctx *ctx)
7174{
7175 struct stream_interface *si = ctx->owner;
7176 struct stream *strm = si_strm(si);
7177 struct channel *req = si_oc(si);
7178 struct channel *res = si_ic(si);
7179 struct act_rule *rule = ctx->rule;
7180 struct proxy *px = strm->be;
7181 struct hlua *hlua = ctx->ctx.hlua_apphttp.hlua;
7182 struct htx *req_htx, *res_htx;
7183
7184 res_htx = htx_from_buf(&res->buf);
7185
7186 /* If the stream is disconnect or closed, ldo nothing. */
7187 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
7188 goto out;
7189
7190 /* Check if the input buffer is avalaible. */
7191 if (!b_size(&res->buf)) {
7192 si_rx_room_blk(si);
7193 goto out;
7194 }
7195 /* check that the output is not closed */
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007196 if (res->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_SHUTR))
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007197 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
7198
7199 /* Set the currently running flag. */
7200 if (!HLUA_IS_RUNNING(hlua) &&
7201 !(ctx->ctx.hlua_apphttp.flags & APPLET_DONE)) {
7202 struct htx_blk *blk;
7203 size_t count = co_data(req);
7204
7205 if (!count) {
7206 si_cant_get(si);
7207 goto out;
7208 }
7209
7210 /* We need to flush the request header. This left the body for
7211 * the Lua.
7212 */
7213 req_htx = htx_from_buf(&req->buf);
7214 blk = htx_get_head_blk(req_htx);
7215 while (count && blk) {
7216 enum htx_blk_type type = htx_get_blk_type(blk);
7217 uint32_t sz = htx_get_blksz(blk);
7218
7219 if (sz > count) {
7220 si_cant_get(si);
Christopher Faulet0ae79d02019-02-27 21:36:59 +01007221 htx_to_buf(req_htx, &req->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007222 goto out;
7223 }
7224
7225 count -= sz;
7226 co_set_data(req, co_data(req) - sz);
7227 blk = htx_remove_blk(req_htx, blk);
7228
7229 if (type == HTX_BLK_EOH)
7230 break;
7231 }
Christopher Faulet0ae79d02019-02-27 21:36:59 +01007232 htx_to_buf(req_htx, &req->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007233 }
7234
7235 /* Executes The applet if it is not done. */
7236 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_DONE)) {
7237
7238 /* Execute the function. */
7239 switch (hlua_ctx_resume(hlua, 1)) {
7240 /* finished. */
7241 case HLUA_E_OK:
7242 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
7243 break;
7244
7245 /* yield. */
7246 case HLUA_E_AGAIN:
7247 if (hlua->wake_time != TICK_ETERNITY)
7248 task_schedule(ctx->ctx.hlua_apphttp.task, hlua->wake_time);
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007249 goto out;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007250
7251 /* finished with error. */
7252 case HLUA_E_ERRMSG:
7253 /* Display log. */
7254 SEND_ERR(px, "Lua applet http '%s': %s.\n",
7255 rule->arg.hlua_rule->fcn.name, lua_tostring(hlua->T, -1));
7256 lua_pop(hlua->T, 1);
7257 goto error;
7258
7259 case HLUA_E_ETMOUT:
7260 SEND_ERR(px, "Lua applet http '%s': execution timeout.\n",
7261 rule->arg.hlua_rule->fcn.name);
7262 goto error;
7263
7264 case HLUA_E_NOMEM:
7265 SEND_ERR(px, "Lua applet http '%s': out of memory error.\n",
7266 rule->arg.hlua_rule->fcn.name);
7267 goto error;
7268
7269 case HLUA_E_YIELD: /* unexpected */
7270 SEND_ERR(px, "Lua applet http '%s': yield not allowed.\n",
7271 rule->arg.hlua_rule->fcn.name);
7272 goto error;
7273
7274 case HLUA_E_ERR:
7275 /* Display log. */
7276 SEND_ERR(px, "Lua applet http '%s' return an unknown error.\n",
7277 rule->arg.hlua_rule->fcn.name);
7278 goto error;
7279
7280 default:
7281 goto error;
7282 }
7283 }
7284
7285 if (ctx->ctx.hlua_apphttp.flags & APPLET_DONE) {
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007286 if (ctx->ctx.hlua_apphttp.flags & APPLET_RSP_SENT)
7287 goto done;
7288
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007289 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT))
7290 goto error;
7291
7292 /* Don't add EOD and TLR because mux-h1 will take care of it */
7293 if (!htx_add_endof(res_htx, HTX_BLK_EOM)) {
7294 si_rx_room_blk(si);
7295 goto out;
7296 }
Christopher Fauletf6cce3f2019-02-27 21:20:09 +01007297 channel_add_input(res, 1);
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007298 strm->txn->status = ctx->ctx.hlua_apphttp.status;
7299 ctx->ctx.hlua_apphttp.flags |= APPLET_RSP_SENT;
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007300 }
7301
7302 done:
7303 if (ctx->ctx.hlua_apphttp.flags & APPLET_DONE) {
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007304 if (!(res->flags & CF_SHUTR)) {
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007305 res->flags |= CF_READ_NULL;
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007306 si_shutr(si);
7307 }
7308
7309 /* eat the whole request */
7310 if (co_data(req)) {
7311 req_htx = htx_from_buf(&req->buf);
7312 co_htx_skip(req, req_htx, co_data(req));
7313 htx_to_buf(req_htx, &req->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007314 }
7315 }
7316
7317 out:
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007318 htx_to_buf(res_htx, &res->buf);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007319 return;
7320
7321 error:
7322
7323 /* If we are in HTTP mode, and we are not send any
7324 * data, return a 500 server error in best effort:
7325 * if there is no room available in the buffer,
7326 * just close the connection.
7327 */
7328 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT)) {
7329 struct buffer *err = &htx_err_chunks[HTTP_ERR_500];
7330
7331 channel_erase(res);
7332 res->buf.data = b_data(err);
7333 memcpy(res->buf.area, b_head(err), b_data(err));
7334 res_htx = htx_from_buf(&res->buf);
Christopher Fauletf6cce3f2019-02-27 21:20:09 +01007335 channel_add_input(res, res_htx->data);
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007336 }
7337 if (!(strm->flags & SF_ERR_MASK))
7338 strm->flags |= SF_ERR_RESOURCE;
7339 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
7340 goto done;
7341}
7342
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007343static void hlua_applet_http_fct(struct appctx *ctx)
7344{
7345 struct stream_interface *si = ctx->owner;
7346 struct stream *strm = si_strm(si);
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007347 struct channel *req = si_oc(si);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007348 struct channel *res = si_ic(si);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007349 struct act_rule *rule = ctx->rule;
7350 struct proxy *px = strm->be;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007351 struct hlua *hlua = ctx->ctx.hlua_apphttp.hlua;
Willy Tarreau206ba832018-06-14 15:27:31 +02007352 const char *blk1;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02007353 size_t len1;
Willy Tarreau206ba832018-06-14 15:27:31 +02007354 const char *blk2;
Willy Tarreau55f3ce12018-07-18 11:49:27 +02007355 size_t len2;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007356 int ret;
7357
Christopher Faulet9c832fc2018-12-14 13:34:05 +01007358 if (IS_HTX_STRM(strm))
7359 return hlua_applet_htx_fct(ctx);
7360
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007361 /* If the stream is disconnect or closed, ldo nothing. */
7362 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007363 goto out;
7364
7365 /* Check if the input buffer is avalaible. */
7366 if (!b_size(&res->buf)) {
7367 si_rx_room_blk(si);
7368 goto out;
7369 }
7370 /* check that the output is not closed */
7371 if (res->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_SHUTR))
7372 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007373
7374 /* Set the currently running flag. */
7375 if (!HLUA_IS_RUNNING(hlua) &&
7376 !(ctx->ctx.hlua_apphttp.flags & APPLET_DONE)) {
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007377 /* Store the max amount of bytes that we can read. */
7378 ctx->ctx.hlua_apphttp.left_bytes = strm->txn->req.body_len;
7379
7380 /* We need to flush the request header. This left the body
7381 * for the Lua.
7382 */
7383
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08007384 /* Read the maximum amount of data available. */
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007385 ret = co_getblk_nc(req, &blk1, &len1, &blk2, &len2);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007386 if (ret == -1)
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007387 goto out;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007388
7389 /* No data available, ask for more data. */
7390 if (ret == 1)
7391 len2 = 0;
7392 if (ret == 0)
7393 len1 = 0;
Thierry FOURNIER70d318c2018-06-30 10:37:33 +02007394 if (len1 + len2 < strm->txn->req.eoh + strm->txn->req.eol) {
Willy Tarreau0cd3bd62018-11-06 18:46:37 +01007395 si_cant_get(si);
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007396 goto out;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007397 }
7398
7399 /* skip the requests bytes. */
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007400 co_skip(req, strm->txn->req.eoh + strm->txn->req.eol);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007401 }
7402
7403 /* Executes The applet if it is not done. */
7404 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_DONE)) {
7405
7406 /* Execute the function. */
7407 switch (hlua_ctx_resume(hlua, 1)) {
7408 /* finished. */
7409 case HLUA_E_OK:
7410 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
7411 break;
7412
7413 /* yield. */
7414 case HLUA_E_AGAIN:
Thierry Fournier0164f202016-02-20 17:47:43 +01007415 if (hlua->wake_time != TICK_ETERNITY)
7416 task_schedule(ctx->ctx.hlua_apphttp.task, hlua->wake_time);
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007417 goto out;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007418
7419 /* finished with error. */
7420 case HLUA_E_ERRMSG:
7421 /* Display log. */
7422 SEND_ERR(px, "Lua applet http '%s': %s.\n",
7423 rule->arg.hlua_rule->fcn.name, lua_tostring(hlua->T, -1));
7424 lua_pop(hlua->T, 1);
7425 goto error;
7426
Thierry Fournierd5b073c2018-05-21 19:42:47 +02007427 case HLUA_E_ETMOUT:
7428 SEND_ERR(px, "Lua applet http '%s': execution timeout.\n",
7429 rule->arg.hlua_rule->fcn.name);
7430 goto error;
7431
7432 case HLUA_E_NOMEM:
7433 SEND_ERR(px, "Lua applet http '%s': out of memory error.\n",
7434 rule->arg.hlua_rule->fcn.name);
7435 goto error;
7436
7437 case HLUA_E_YIELD: /* unexpected */
7438 SEND_ERR(px, "Lua applet http '%s': yield not allowed.\n",
7439 rule->arg.hlua_rule->fcn.name);
7440 goto error;
7441
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007442 case HLUA_E_ERR:
7443 /* Display log. */
7444 SEND_ERR(px, "Lua applet http '%s' return an unknown error.\n",
7445 rule->arg.hlua_rule->fcn.name);
7446 goto error;
7447
7448 default:
7449 goto error;
7450 }
7451 }
7452
7453 if (ctx->ctx.hlua_apphttp.flags & APPLET_DONE) {
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007454 if (ctx->ctx.hlua_apphttp.flags & APPLET_RSP_SENT)
7455 goto done;
7456
Christopher Fauletcc26b132018-12-18 21:20:57 +01007457 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT))
7458 goto error;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007459
7460 /* We must send the final chunk. */
7461 if (ctx->ctx.hlua_apphttp.flags & APPLET_CHUNKED &&
7462 !(ctx->ctx.hlua_apphttp.flags & APPLET_LAST_CHK)) {
7463
7464 /* sent last chunk at once. */
Willy Tarreau06d80a92017-10-19 14:32:15 +02007465 ret = ci_putblk(res, "0\r\n\r\n", 5);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007466
7467 /* critical error. */
7468 if (ret == -2 || ret == -3) {
7469 SEND_ERR(px, "Lua applet http '%s'cannont send last chunk.\n",
7470 rule->arg.hlua_rule->fcn.name);
7471 goto error;
7472 }
7473
7474 /* no enough space error. */
7475 if (ret == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01007476 si_rx_room_blk(si);
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007477 goto out;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007478 }
7479
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007480 strm->txn->status = ctx->ctx.hlua_apphttp.status;
7481 ctx->ctx.hlua_apphttp.flags |= (APPLET_LAST_CHK|APPLET_RSP_SENT);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007482 }
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007483 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007484
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007485 done:
7486 if (ctx->ctx.hlua_apphttp.flags & APPLET_DONE) {
7487 if (!(res->flags & CF_SHUTR)) {
7488 res->flags |= CF_READ_NULL;
7489 si_shutr(si);
7490 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007491
7492 /* eat the whole request */
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007493 if (co_data(req))
7494 co_skip(req, co_data(req));
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007495 }
7496
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007497 out:
7498 return;
7499
7500 error:
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007501
7502 /* If we are in HTTP mode, and we are not send any
7503 * data, return a 500 server error in best effort:
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08007504 * if there is no room available in the buffer,
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007505 * just close the connection.
7506 */
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007507 if (!(ctx->ctx.hlua_apphttp.flags & APPLET_HDR_SENT)) {
7508 channel_erase(res);
7509 ci_putblk(res, error_500, strlen(error_500));
7510 }
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007511 if (!(strm->flags & SF_ERR_MASK))
7512 strm->flags |= SF_ERR_RESOURCE;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007513 ctx->ctx.hlua_apphttp.flags |= APPLET_DONE;
Christopher Faulet56a3d6e2019-02-27 22:06:23 +01007514 goto done;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007515}
7516
7517static void hlua_applet_http_release(struct appctx *ctx)
7518{
Olivier Houchard3f795f72019-04-17 22:51:06 +02007519 task_destroy(ctx->ctx.hlua_apphttp.task);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007520 ctx->ctx.hlua_apphttp.task = NULL;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007521 hlua_ctx_destroy(ctx->ctx.hlua_apphttp.hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007522 ctx->ctx.hlua_apphttp.hlua = NULL;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007523}
7524
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007525/* global {tcp|http}-request parser. Return ACT_RET_PRS_OK in
7526 * succes case, else return ACT_RET_PRS_ERR.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02007527 *
7528 * This function can fail with an abort() due to an Lua critical error.
7529 * We are in the configuration parsing process of HAProxy, this abort() is
7530 * tolerated.
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007531 */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007532static enum act_parse_ret action_register_lua(const char **args, int *cur_arg, struct proxy *px,
7533 struct act_rule *rule, char **err)
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007534{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02007535 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007536 int i;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007537
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007538 /* Memory for the rule. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02007539 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007540 if (!rule->arg.hlua_rule) {
7541 memprintf(err, "out of memory error");
Thierry FOURNIERafa80492015-08-19 09:04:15 +02007542 return ACT_RET_PRS_ERR;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007543 }
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007544
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007545 /* Memory for arguments. */
7546 rule->arg.hlua_rule->args = calloc(fcn->nargs + 1, sizeof(char *));
7547 if (!rule->arg.hlua_rule->args) {
7548 memprintf(err, "out of memory error");
7549 return ACT_RET_PRS_ERR;
7550 }
7551
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007552 /* Reference the Lua function and store the reference. */
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007553 rule->arg.hlua_rule->fcn = *fcn;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007554
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007555 /* Expect some arguments */
7556 for (i = 0; i < fcn->nargs; i++) {
Thierry FOURNIER1725c2e2019-01-06 19:38:49 +01007557 if (*args[*cur_arg] == '\0') {
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007558 memprintf(err, "expect %d arguments", fcn->nargs);
7559 return ACT_RET_PRS_ERR;
7560 }
Thierry FOURNIER1725c2e2019-01-06 19:38:49 +01007561 rule->arg.hlua_rule->args[i] = strdup(args[*cur_arg]);
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007562 if (!rule->arg.hlua_rule->args[i]) {
7563 memprintf(err, "out of memory error");
7564 return ACT_RET_PRS_ERR;
7565 }
7566 (*cur_arg)++;
7567 }
7568 rule->arg.hlua_rule->args[i] = NULL;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007569
Thierry FOURNIER42148732015-09-02 17:17:33 +02007570 rule->action = ACT_CUSTOM;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +02007571 rule->action_ptr = hlua_action;
Thierry FOURNIERafa80492015-08-19 09:04:15 +02007572 return ACT_RET_PRS_OK;
Thierry FOURNIER258d8aa2015-02-16 20:23:40 +01007573}
7574
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007575static enum act_parse_ret action_register_service_http(const char **args, int *cur_arg, struct proxy *px,
7576 struct act_rule *rule, char **err)
7577{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02007578 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007579
Thierry FOURNIER718e2a72015-12-20 20:13:14 +01007580 /* HTTP applets are forbidden in tcp-request rules.
7581 * HTTP applet request requires everything initilized by
7582 * "http_process_request" (analyzer flag AN_REQ_HTTP_INNER).
7583 * The applet will be immediately initilized, but its before
7584 * the call of this analyzer.
7585 */
7586 if (rule->from != ACT_F_HTTP_REQ) {
7587 memprintf(err, "HTTP applets are forbidden from 'tcp-request' rulesets");
7588 return ACT_RET_PRS_ERR;
7589 }
7590
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007591 /* Memory for the rule. */
7592 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
7593 if (!rule->arg.hlua_rule) {
7594 memprintf(err, "out of memory error");
7595 return ACT_RET_PRS_ERR;
7596 }
7597
7598 /* Reference the Lua function and store the reference. */
7599 rule->arg.hlua_rule->fcn = *fcn;
7600
7601 /* TODO: later accept arguments. */
7602 rule->arg.hlua_rule->args = NULL;
7603
7604 /* Add applet pointer in the rule. */
7605 rule->applet.obj_type = OBJ_TYPE_APPLET;
7606 rule->applet.name = fcn->name;
7607 rule->applet.init = hlua_applet_http_init;
7608 rule->applet.fct = hlua_applet_http_fct;
7609 rule->applet.release = hlua_applet_http_release;
7610 rule->applet.timeout = hlua_timeout_applet;
7611
7612 return ACT_RET_PRS_OK;
7613}
7614
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007615/* This function is an LUA binding used for registering
7616 * "sample-conv" functions. It expects a converter name used
7617 * in the haproxy configuration file, and an LUA function.
7618 */
7619__LJMP static int hlua_register_action(lua_State *L)
7620{
7621 struct action_kw_list *akl;
7622 const char *name;
7623 int ref;
7624 int len;
7625 struct hlua_function *fcn;
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007626 int nargs;
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007627
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007628 /* Initialise the number of expected arguments at 0. */
7629 nargs = 0;
7630
7631 if (lua_gettop(L) < 3 || lua_gettop(L) > 4)
7632 WILL_LJMP(luaL_error(L, "'register_action' needs between 3 and 4 arguments"));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007633
7634 /* First argument : converter name. */
7635 name = MAY_LJMP(luaL_checkstring(L, 1));
7636
7637 /* Second argument : environment. */
7638 if (lua_type(L, 2) != LUA_TTABLE)
7639 WILL_LJMP(luaL_error(L, "register_action: second argument must be a table of strings"));
7640
7641 /* Third argument : lua function. */
7642 ref = MAY_LJMP(hlua_checkfunction(L, 3));
7643
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08007644 /* Fourth argument : number of mandatory arguments expected on the configuration line. */
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007645 if (lua_gettop(L) >= 4)
7646 nargs = MAY_LJMP(luaL_checkinteger(L, 4));
7647
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08007648 /* browse the second argument as an array. */
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007649 lua_pushnil(L);
7650 while (lua_next(L, 2) != 0) {
7651 if (lua_type(L, -1) != LUA_TSTRING)
7652 WILL_LJMP(luaL_error(L, "register_action: second argument must be a table of strings"));
7653
7654 /* Check required environment. Only accepted "http" or "tcp". */
7655 /* Allocate and fill the sample fetch keyword struct. */
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02007656 akl = calloc(1, sizeof(*akl) + sizeof(struct action_kw) * 2);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007657 if (!akl)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007658 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02007659 fcn = calloc(1, sizeof(*fcn));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007660 if (!fcn)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007661 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007662
7663 /* Fill fcn. */
7664 fcn->name = strdup(name);
7665 if (!fcn->name)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007666 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007667 fcn->function_ref = ref;
7668
Thierry FOURNIER / OZON.IO4b123be2016-12-09 18:03:31 +01007669 /* Set the expected number od arguments. */
7670 fcn->nargs = nargs;
7671
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007672 /* List head */
7673 akl->list.n = akl->list.p = NULL;
7674
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007675 /* action keyword. */
7676 len = strlen("lua.") + strlen(name) + 1;
Thierry FOURNIER3c7a77c2015-09-26 00:51:16 +02007677 akl->kw[0].kw = calloc(1, len);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007678 if (!akl->kw[0].kw)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007679 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007680
7681 snprintf((char *)akl->kw[0].kw, len, "lua.%s", name);
7682
7683 akl->kw[0].match_pfx = 0;
7684 akl->kw[0].private = fcn;
7685 akl->kw[0].parse = action_register_lua;
7686
7687 /* select the action registering point. */
7688 if (strcmp(lua_tostring(L, -1), "tcp-req") == 0)
7689 tcp_req_cont_keywords_register(akl);
7690 else if (strcmp(lua_tostring(L, -1), "tcp-res") == 0)
7691 tcp_res_cont_keywords_register(akl);
7692 else if (strcmp(lua_tostring(L, -1), "http-req") == 0)
7693 http_req_keywords_register(akl);
7694 else if (strcmp(lua_tostring(L, -1), "http-res") == 0)
7695 http_res_keywords_register(akl);
7696 else
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007697 WILL_LJMP(luaL_error(L, "Lua action environment '%s' is unknown. "
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007698 "'tcp-req', 'tcp-res', 'http-req' or 'http-res' "
7699 "are expected.", lua_tostring(L, -1)));
7700
7701 /* pop the environment string. */
7702 lua_pop(L, 1);
7703 }
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007704 return ACT_RET_PRS_OK;
7705}
7706
7707static enum act_parse_ret action_register_service_tcp(const char **args, int *cur_arg, struct proxy *px,
7708 struct act_rule *rule, char **err)
7709{
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02007710 struct hlua_function *fcn = rule->kw->private;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007711
Christopher Fauleteb709802019-04-11 22:04:08 +02007712 if (px->mode == PR_MODE_HTTP && (px->options2 & PR_O2_USE_HTX)) {
Christopher Fauletafd8f102018-11-08 11:34:21 +01007713 memprintf(err, "Lua services cannot be used when the HTX internal representation is enabled");
7714 return ACT_RET_PRS_ERR;
7715 }
7716
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007717 /* Memory for the rule. */
7718 rule->arg.hlua_rule = calloc(1, sizeof(*rule->arg.hlua_rule));
7719 if (!rule->arg.hlua_rule) {
7720 memprintf(err, "out of memory error");
7721 return ACT_RET_PRS_ERR;
7722 }
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007723
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007724 /* Reference the Lua function and store the reference. */
7725 rule->arg.hlua_rule->fcn = *fcn;
7726
7727 /* TODO: later accept arguments. */
7728 rule->arg.hlua_rule->args = NULL;
7729
7730 /* Add applet pointer in the rule. */
7731 rule->applet.obj_type = OBJ_TYPE_APPLET;
7732 rule->applet.name = fcn->name;
7733 rule->applet.init = hlua_applet_tcp_init;
7734 rule->applet.fct = hlua_applet_tcp_fct;
7735 rule->applet.release = hlua_applet_tcp_release;
7736 rule->applet.timeout = hlua_timeout_applet;
7737
7738 return 0;
7739}
7740
7741/* This function is an LUA binding used for registering
7742 * "sample-conv" functions. It expects a converter name used
7743 * in the haproxy configuration file, and an LUA function.
7744 */
7745__LJMP static int hlua_register_service(lua_State *L)
7746{
7747 struct action_kw_list *akl;
7748 const char *name;
7749 const char *env;
7750 int ref;
7751 int len;
7752 struct hlua_function *fcn;
7753
7754 MAY_LJMP(check_args(L, 3, "register_service"));
7755
7756 /* First argument : converter name. */
7757 name = MAY_LJMP(luaL_checkstring(L, 1));
7758
7759 /* Second argument : environment. */
7760 env = MAY_LJMP(luaL_checkstring(L, 2));
7761
7762 /* Third argument : lua function. */
7763 ref = MAY_LJMP(hlua_checkfunction(L, 3));
7764
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007765 /* Allocate and fill the sample fetch keyword struct. */
7766 akl = calloc(1, sizeof(*akl) + sizeof(struct action_kw) * 2);
7767 if (!akl)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007768 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007769 fcn = calloc(1, sizeof(*fcn));
7770 if (!fcn)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007771 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007772
7773 /* Fill fcn. */
7774 len = strlen("<lua.>") + strlen(name) + 1;
7775 fcn->name = calloc(1, len);
7776 if (!fcn->name)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007777 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007778 snprintf((char *)fcn->name, len, "<lua.%s>", name);
7779 fcn->function_ref = ref;
7780
7781 /* List head */
7782 akl->list.n = akl->list.p = NULL;
7783
7784 /* converter keyword. */
7785 len = strlen("lua.") + strlen(name) + 1;
7786 akl->kw[0].kw = calloc(1, len);
7787 if (!akl->kw[0].kw)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007788 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007789
7790 snprintf((char *)akl->kw[0].kw, len, "lua.%s", name);
7791
Thierry FOURNIER / OZON.IO02564fd2016-11-12 11:07:05 +01007792 /* Check required environment. Only accepted "http" or "tcp". */
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007793 if (strcmp(env, "tcp") == 0)
7794 akl->kw[0].parse = action_register_service_tcp;
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02007795 else if (strcmp(env, "http") == 0)
7796 akl->kw[0].parse = action_register_service_http;
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007797 else
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01007798 WILL_LJMP(luaL_error(L, "Lua service environment '%s' is unknown. "
Eric Salamafe7456f2017-12-21 14:30:07 +01007799 "'tcp' or 'http' are expected.", env));
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02007800
7801 akl->kw[0].match_pfx = 0;
7802 akl->kw[0].private = fcn;
7803
7804 /* End of array. */
7805 memset(&akl->kw[1], 0, sizeof(*akl->kw));
7806
7807 /* Register this new converter */
7808 service_keywords_register(akl);
7809
Thierry FOURNIER8255a752015-09-23 21:03:35 +02007810 return 0;
7811}
7812
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007813/* This function initialises Lua cli handler. It copies the
7814 * arguments in the Lua stack and create channel IO objects.
7815 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02007816static int hlua_cli_parse_fct(char **args, char *payload, struct appctx *appctx, void *private)
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007817{
7818 struct hlua *hlua;
7819 struct hlua_function *fcn;
7820 int i;
7821 const char *error;
7822
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007823 fcn = private;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007824 appctx->ctx.hlua_cli.fcn = private;
7825
Willy Tarreaubafbe012017-11-24 17:34:44 +01007826 hlua = pool_alloc(pool_head_hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007827 if (!hlua) {
7828 SEND_ERR(NULL, "Lua cli '%s': out of memory.\n", fcn->name);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01007829 return 1;
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007830 }
7831 HLUA_INIT(hlua);
7832 appctx->ctx.hlua_cli.hlua = hlua;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007833
7834 /* Create task used by signal to wakeup applets.
7835 * We use the same wakeup fonction than the Lua applet_tcp and
7836 * applet_http. It is absolutely compatible.
7837 */
Willy Tarreau5f4a47b2017-10-31 15:59:32 +01007838 appctx->ctx.hlua_cli.task = task_new(tid_bit);
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007839 if (!appctx->ctx.hlua_cli.task) {
Thierry FOURNIERffbf5692016-12-16 11:14:06 +01007840 SEND_ERR(NULL, "Lua cli '%s': out of memory.\n", fcn->name);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01007841 goto error;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007842 }
7843 appctx->ctx.hlua_cli.task->nice = 0;
7844 appctx->ctx.hlua_cli.task->context = appctx;
7845 appctx->ctx.hlua_cli.task->process = hlua_applet_wakeup;
7846
7847 /* Initialises the Lua context */
Thierry FOURNIERbf90ce12019-01-06 19:04:24 +01007848 if (!hlua_ctx_init(hlua, appctx->ctx.hlua_cli.task, 0)) {
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007849 SEND_ERR(NULL, "Lua cli '%s': can't initialize Lua context.\n", fcn->name);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01007850 goto error;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007851 }
7852
7853 /* The following Lua calls can fail. */
7854 if (!SET_SAFE_LJMP(hlua->T)) {
7855 if (lua_type(hlua->T, -1) == LUA_TSTRING)
7856 error = lua_tostring(hlua->T, -1);
7857 else
7858 error = "critical error";
7859 SEND_ERR(NULL, "Lua cli '%s': %s.\n", fcn->name, error);
7860 goto error;
7861 }
7862
7863 /* Check stack available size. */
7864 if (!lua_checkstack(hlua->T, 2)) {
7865 SEND_ERR(NULL, "Lua cli '%s': full stack.\n", fcn->name);
7866 goto error;
7867 }
7868
7869 /* Restore the function in the stack. */
7870 lua_rawgeti(hlua->T, LUA_REGISTRYINDEX, fcn->function_ref);
7871
7872 /* Once the arguments parsed, the CLI is like an AppletTCP,
7873 * so push AppletTCP in the stack.
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007874 */
7875 if (!hlua_applet_tcp_new(hlua->T, appctx)) {
7876 SEND_ERR(NULL, "Lua cli '%s': full stack.\n", fcn->name);
7877 goto error;
7878 }
7879 hlua->nargs = 1;
7880
7881 /* push keywords in the stack. */
7882 for (i = 0; *args[i]; i++) {
7883 /* Check stack available size. */
7884 if (!lua_checkstack(hlua->T, 1)) {
7885 SEND_ERR(NULL, "Lua cli '%s': full stack.\n", fcn->name);
7886 goto error;
7887 }
7888 lua_pushstring(hlua->T, args[i]);
7889 hlua->nargs++;
7890 }
7891
7892 /* We must initialize the execution timeouts. */
7893 hlua->max_time = hlua_timeout_session;
7894
7895 /* At this point the execution is safe. */
7896 RESET_SAFE_LJMP(hlua->T);
7897
7898 /* It's ok */
7899 return 0;
7900
7901 /* It's not ok. */
7902error:
7903 RESET_SAFE_LJMP(hlua->T);
7904 hlua_ctx_destroy(hlua);
Thierry FOURNIER1be34152016-12-17 12:09:51 +01007905 appctx->ctx.hlua_cli.hlua = NULL;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007906 return 1;
7907}
7908
7909static int hlua_cli_io_handler_fct(struct appctx *appctx)
7910{
7911 struct hlua *hlua;
7912 struct stream_interface *si;
7913 struct hlua_function *fcn;
7914
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007915 hlua = appctx->ctx.hlua_cli.hlua;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007916 si = appctx->owner;
Willy Tarreau8ae4f752016-12-14 15:41:45 +01007917 fcn = appctx->ctx.hlua_cli.fcn;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007918
7919 /* If the stream is disconnect or closed, ldo nothing. */
7920 if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
7921 return 1;
7922
7923 /* Execute the function. */
7924 switch (hlua_ctx_resume(hlua, 1)) {
7925
7926 /* finished. */
7927 case HLUA_E_OK:
7928 return 1;
7929
7930 /* yield. */
7931 case HLUA_E_AGAIN:
7932 /* We want write. */
7933 if (HLUA_IS_WAKERESWR(hlua))
Willy Tarreaudb398432018-11-15 11:08:52 +01007934 si_rx_room_blk(si);
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007935 /* Set the timeout. */
7936 if (hlua->wake_time != TICK_ETERNITY)
7937 task_schedule(hlua->task, hlua->wake_time);
7938 return 0;
7939
7940 /* finished with error. */
7941 case HLUA_E_ERRMSG:
7942 /* Display log. */
7943 SEND_ERR(NULL, "Lua cli '%s': %s.\n",
7944 fcn->name, lua_tostring(hlua->T, -1));
7945 lua_pop(hlua->T, 1);
7946 return 1;
7947
Thierry Fournierd5b073c2018-05-21 19:42:47 +02007948 case HLUA_E_ETMOUT:
7949 SEND_ERR(NULL, "Lua converter '%s': execution timeout.\n",
7950 fcn->name);
7951 return 1;
7952
7953 case HLUA_E_NOMEM:
7954 SEND_ERR(NULL, "Lua converter '%s': out of memory error.\n",
7955 fcn->name);
7956 return 1;
7957
7958 case HLUA_E_YIELD: /* unexpected */
7959 SEND_ERR(NULL, "Lua converter '%s': yield not allowed.\n",
7960 fcn->name);
7961 return 1;
7962
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007963 case HLUA_E_ERR:
7964 /* Display log. */
7965 SEND_ERR(NULL, "Lua cli '%s' return an unknown error.\n",
7966 fcn->name);
7967 return 1;
7968
7969 default:
7970 return 1;
7971 }
7972
7973 return 1;
7974}
7975
7976static void hlua_cli_io_release_fct(struct appctx *appctx)
7977{
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007978 hlua_ctx_destroy(appctx->ctx.hlua_cli.hlua);
Thierry FOURNIERebed6e92016-12-16 11:54:07 +01007979 appctx->ctx.hlua_cli.hlua = NULL;
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01007980}
7981
7982/* This function is an LUA binding used for registering
7983 * new keywords in the cli. It expects a list of keywords
7984 * which are the "path". It is limited to 5 keywords. A
7985 * description of the command, a function to be executed
7986 * for the parsing and a function for io handlers.
7987 */
7988__LJMP static int hlua_register_cli(lua_State *L)
7989{
7990 struct cli_kw_list *cli_kws;
7991 const char *message;
7992 int ref_io;
7993 int len;
7994 struct hlua_function *fcn;
7995 int index;
7996 int i;
7997
7998 MAY_LJMP(check_args(L, 3, "register_cli"));
7999
8000 /* First argument : an array of maximum 5 keywords. */
8001 if (!lua_istable(L, 1))
8002 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table"));
8003
8004 /* Second argument : string with contextual message. */
8005 message = MAY_LJMP(luaL_checkstring(L, 2));
8006
8007 /* Third and fourth argument : lua function. */
8008 ref_io = MAY_LJMP(hlua_checkfunction(L, 3));
8009
8010 /* Allocate and fill the sample fetch keyword struct. */
8011 cli_kws = calloc(1, sizeof(*cli_kws) + sizeof(struct cli_kw) * 2);
8012 if (!cli_kws)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008013 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008014 fcn = calloc(1, sizeof(*fcn));
8015 if (!fcn)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008016 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008017
8018 /* Fill path. */
8019 index = 0;
8020 lua_pushnil(L);
8021 while(lua_next(L, 1) != 0) {
8022 if (index >= 5)
8023 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table with a maximum of 5 entries"));
8024 if (lua_type(L, -1) != LUA_TSTRING)
8025 WILL_LJMP(luaL_argerror(L, 1, "1st argument must be a table filled with strings"));
8026 cli_kws->kw[0].str_kw[index] = strdup(lua_tostring(L, -1));
8027 if (!cli_kws->kw[0].str_kw[index])
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008028 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008029 index++;
8030 lua_pop(L, 1);
8031 }
8032
8033 /* Copy help message. */
8034 cli_kws->kw[0].usage = strdup(message);
8035 if (!cli_kws->kw[0].usage)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008036 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008037
8038 /* Fill fcn io handler. */
8039 len = strlen("<lua.cli>") + 1;
8040 for (i = 0; i < index; i++)
8041 len += strlen(cli_kws->kw[0].str_kw[i]) + 1;
8042 fcn->name = calloc(1, len);
8043 if (!fcn->name)
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008044 WILL_LJMP(luaL_error(L, "Lua out of memory error."));
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008045 strncat((char *)fcn->name, "<lua.cli", len);
8046 for (i = 0; i < index; i++) {
8047 strncat((char *)fcn->name, ".", len);
8048 strncat((char *)fcn->name, cli_kws->kw[0].str_kw[i], len);
8049 }
8050 strncat((char *)fcn->name, ">", len);
8051 fcn->function_ref = ref_io;
8052
8053 /* Fill last entries. */
8054 cli_kws->kw[0].private = fcn;
8055 cli_kws->kw[0].parse = hlua_cli_parse_fct;
8056 cli_kws->kw[0].io_handler = hlua_cli_io_handler_fct;
8057 cli_kws->kw[0].io_release = hlua_cli_io_release_fct;
8058
8059 /* Register this new converter */
8060 cli_register_kw(cli_kws);
8061
8062 return 0;
8063}
8064
Thierry FOURNIERbd413492015-03-03 16:52:26 +01008065static int hlua_read_timeout(char **args, int section_type, struct proxy *curpx,
8066 struct proxy *defpx, const char *file, int line,
8067 char **err, unsigned int *timeout)
8068{
8069 const char *error;
8070
8071 error = parse_time_err(args[1], timeout, TIME_UNIT_MS);
8072 if (error && *error != '\0') {
8073 memprintf(err, "%s: invalid timeout", args[0]);
8074 return -1;
8075 }
8076 return 0;
8077}
8078
8079static int hlua_session_timeout(char **args, int section_type, struct proxy *curpx,
8080 struct proxy *defpx, const char *file, int line,
8081 char **err)
8082{
8083 return hlua_read_timeout(args, section_type, curpx, defpx,
8084 file, line, err, &hlua_timeout_session);
8085}
8086
8087static int hlua_task_timeout(char **args, int section_type, struct proxy *curpx,
8088 struct proxy *defpx, const char *file, int line,
8089 char **err)
8090{
8091 return hlua_read_timeout(args, section_type, curpx, defpx,
8092 file, line, err, &hlua_timeout_task);
8093}
8094
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008095static int hlua_applet_timeout(char **args, int section_type, struct proxy *curpx,
8096 struct proxy *defpx, const char *file, int line,
8097 char **err)
8098{
8099 return hlua_read_timeout(args, section_type, curpx, defpx,
8100 file, line, err, &hlua_timeout_applet);
8101}
8102
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01008103static int hlua_forced_yield(char **args, int section_type, struct proxy *curpx,
8104 struct proxy *defpx, const char *file, int line,
8105 char **err)
8106{
8107 char *error;
8108
8109 hlua_nb_instruction = strtoll(args[1], &error, 10);
8110 if (*error != '\0') {
8111 memprintf(err, "%s: invalid number", args[0]);
8112 return -1;
8113 }
8114 return 0;
8115}
8116
Willy Tarreau32f61e22015-03-18 17:54:59 +01008117static int hlua_parse_maxmem(char **args, int section_type, struct proxy *curpx,
8118 struct proxy *defpx, const char *file, int line,
8119 char **err)
8120{
8121 char *error;
8122
8123 if (*(args[1]) == 0) {
8124 memprintf(err, "'%s' expects an integer argument (Lua memory size in MB).\n", args[0]);
8125 return -1;
8126 }
8127 hlua_global_allocator.limit = strtoll(args[1], &error, 10) * 1024L * 1024L;
8128 if (*error != '\0') {
8129 memprintf(err, "%s: invalid number %s (error at '%c')", args[0], args[1], *error);
8130 return -1;
8131 }
8132 return 0;
8133}
8134
8135
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008136/* This function is called by the main configuration key "lua-load". It loads and
8137 * execute an lua file during the parsing of the HAProxy configuration file. It is
8138 * the main lua entry point.
8139 *
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08008140 * This function runs with the HAProxy keywords API. It returns -1 if an error
8141 * occurs, otherwise it returns 0.
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008142 *
8143 * In some error case, LUA set an error message in top of the stack. This function
8144 * returns this error message in the HAProxy logs and pop it from the stack.
Thierry FOURNIERbabae282015-09-17 11:36:37 +02008145 *
8146 * This function can fail with an abort() due to an Lua critical error.
8147 * We are in the configuration parsing process of HAProxy, this abort() is
8148 * tolerated.
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008149 */
8150static int hlua_load(char **args, int section_type, struct proxy *curpx,
8151 struct proxy *defpx, const char *file, int line,
8152 char **err)
8153{
8154 int error;
8155
8156 /* Just load and compile the file. */
8157 error = luaL_loadfile(gL.T, args[1]);
8158 if (error) {
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008159 memprintf(err, "error in Lua file '%s': %s", args[1], lua_tostring(gL.T, -1));
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008160 lua_pop(gL.T, 1);
8161 return -1;
8162 }
8163
8164 /* If no syntax error where detected, execute the code. */
8165 error = lua_pcall(gL.T, 0, LUA_MULTRET, 0);
8166 switch (error) {
8167 case LUA_OK:
8168 break;
8169 case LUA_ERRRUN:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008170 memprintf(err, "Lua runtime error: %s\n", lua_tostring(gL.T, -1));
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008171 lua_pop(gL.T, 1);
8172 return -1;
8173 case LUA_ERRMEM:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008174 memprintf(err, "Lua out of memory error.n");
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008175 return -1;
8176 case LUA_ERRERR:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008177 memprintf(err, "Lua message handler error: %s\n", lua_tostring(gL.T, -1));
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008178 lua_pop(gL.T, 1);
8179 return -1;
8180 case LUA_ERRGCMM:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008181 memprintf(err, "Lua garbage collector error: %s\n", lua_tostring(gL.T, -1));
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008182 lua_pop(gL.T, 1);
8183 return -1;
8184 default:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008185 memprintf(err, "Lua unknonwn error: %s\n", lua_tostring(gL.T, -1));
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008186 lua_pop(gL.T, 1);
8187 return -1;
8188 }
8189
8190 return 0;
8191}
8192
8193/* configuration keywords declaration */
8194static struct cfg_kw_list cfg_kws = {{ },{
Thierry FOURNIERbd413492015-03-03 16:52:26 +01008195 { CFG_GLOBAL, "lua-load", hlua_load },
8196 { CFG_GLOBAL, "tune.lua.session-timeout", hlua_session_timeout },
8197 { CFG_GLOBAL, "tune.lua.task-timeout", hlua_task_timeout },
Thierry FOURNIER56da1012015-10-01 08:42:31 +02008198 { CFG_GLOBAL, "tune.lua.service-timeout", hlua_applet_timeout },
Thierry FOURNIERee9f8022015-03-03 17:37:37 +01008199 { CFG_GLOBAL, "tune.lua.forced-yield", hlua_forced_yield },
Willy Tarreau32f61e22015-03-18 17:54:59 +01008200 { CFG_GLOBAL, "tune.lua.maxmem", hlua_parse_maxmem },
Thierry FOURNIER6c9b52c2015-01-23 15:57:06 +01008201 { 0, NULL, NULL },
8202}};
8203
Willy Tarreau0108d902018-11-25 19:14:37 +01008204INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
8205
Christopher Fauletafd8f102018-11-08 11:34:21 +01008206
Thierry FOURNIERbabae282015-09-17 11:36:37 +02008207/* This function can fail with an abort() due to an Lua critical error.
8208 * We are in the initialisation process of HAProxy, this abort() is
8209 * tolerated.
8210 */
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008211int hlua_post_init()
8212{
8213 struct hlua_init_function *init;
8214 const char *msg;
8215 enum hlua_exec ret;
Thierry Fournierfd107a22016-02-19 19:57:23 +01008216 const char *error;
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008217
Thierry Fournier3d4a6752016-02-19 20:53:30 +01008218 /* Call post initialisation function in safe environement. */
8219 if (!SET_SAFE_LJMP(gL.T)) {
8220 if (lua_type(gL.T, -1) == LUA_TSTRING)
8221 error = lua_tostring(gL.T, -1);
8222 else
8223 error = "critical error";
8224 fprintf(stderr, "Lua post-init: %s.\n", error);
8225 exit(1);
8226 }
Frédéric Lécaille54f2bcf2018-08-29 13:46:24 +02008227
8228#if USE_OPENSSL
8229 /* Initialize SSL server. */
8230 if (socket_ssl.xprt->prepare_srv) {
8231 int saved_used_backed = global.ssl_used_backend;
8232 // don't affect maxconn automatic computation
8233 socket_ssl.xprt->prepare_srv(&socket_ssl);
8234 global.ssl_used_backend = saved_used_backed;
8235 }
8236#endif
8237
Thierry Fournier3d4a6752016-02-19 20:53:30 +01008238 hlua_fcn_post_init(gL.T);
8239 RESET_SAFE_LJMP(gL.T);
8240
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008241 list_for_each_entry(init, &hlua_init_functions, l) {
8242 lua_rawgeti(gL.T, LUA_REGISTRYINDEX, init->function_ref);
8243 ret = hlua_ctx_resume(&gL, 0);
8244 switch (ret) {
8245 case HLUA_E_OK:
8246 lua_pop(gL.T, -1);
8247 return 1;
8248 case HLUA_E_AGAIN:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008249 ha_alert("Lua init: yield not allowed.\n");
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008250 return 0;
8251 case HLUA_E_ERRMSG:
8252 msg = lua_tostring(gL.T, -1);
Christopher Faulet767a84b2017-11-24 16:50:31 +01008253 ha_alert("lua init: %s.\n", msg);
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008254 return 0;
8255 case HLUA_E_ERR:
8256 default:
Thierry FOURNIER2986c0d2018-02-25 14:32:36 +01008257 ha_alert("Lua init: unknown runtime error.\n");
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008258 return 0;
8259 }
8260 }
8261 return 1;
8262}
8263
Willy Tarreau32f61e22015-03-18 17:54:59 +01008264/* The memory allocator used by the Lua stack. <ud> is a pointer to the
8265 * allocator's context. <ptr> is the pointer to alloc/free/realloc. <osize>
8266 * is the previously allocated size or the kind of object in case of a new
8267 * allocation. <nsize> is the requested new size.
8268 */
8269static void *hlua_alloc(void *ud, void *ptr, size_t osize, size_t nsize)
8270{
8271 struct hlua_mem_allocator *zone = ud;
8272
8273 if (nsize == 0) {
8274 /* it's a free */
8275 if (ptr)
8276 zone->allocated -= osize;
8277 free(ptr);
8278 return NULL;
8279 }
8280
8281 if (!ptr) {
8282 /* it's a new allocation */
8283 if (zone->limit && zone->allocated + nsize > zone->limit)
8284 return NULL;
8285
8286 ptr = malloc(nsize);
8287 if (ptr)
8288 zone->allocated += nsize;
8289 return ptr;
8290 }
8291
8292 /* it's a realloc */
8293 if (zone->limit && zone->allocated + nsize - osize > zone->limit)
8294 return NULL;
8295
8296 ptr = realloc(ptr, nsize);
8297 if (ptr)
8298 zone->allocated += nsize - osize;
8299 return ptr;
8300}
8301
Thierry FOURNIERbabae282015-09-17 11:36:37 +02008302/* Ithis function can fail with an abort() due to an Lua critical error.
8303 * We are in the initialisation process of HAProxy, this abort() is
8304 * tolerated.
8305 */
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +01008306void hlua_init(void)
8307{
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008308 int i;
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008309 int idx;
8310 struct sample_fetch *sf;
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008311 struct sample_conv *sc;
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008312 char *p;
Thierry Fournierfd107a22016-02-19 19:57:23 +01008313 const char *error_msg;
Willy Tarreau80f5fae2015-02-27 16:38:20 +01008314#ifdef USE_OPENSSL
Willy Tarreau80f5fae2015-02-27 16:38:20 +01008315 struct srv_kw *kw;
8316 int tmp_error;
8317 char *error;
Thierry FOURNIER36d13742015-03-17 16:48:53 +01008318 char *args[] = { /* SSL client configuration. */
8319 "ssl",
8320 "verify",
8321 "none",
Thierry FOURNIER36d13742015-03-17 16:48:53 +01008322 NULL
8323 };
Willy Tarreau80f5fae2015-02-27 16:38:20 +01008324#endif
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008325
Thierry FOURNIER380d0932015-01-23 14:27:52 +01008326 /* Init main lua stack. */
8327 gL.Mref = LUA_REFNIL;
Thierry FOURNIERa097fdf2015-03-03 15:17:35 +01008328 gL.flags = 0;
Thierry FOURNIER9ff7e6e2015-01-23 11:08:20 +01008329 LIST_INIT(&gL.com);
Willy Tarreau42ef75f2017-04-12 21:40:29 +02008330 gL.T = lua_newstate(hlua_alloc, &hlua_global_allocator);
Thierry FOURNIER380d0932015-01-23 14:27:52 +01008331 hlua_sethlua(&gL);
8332 gL.Tref = LUA_REFNIL;
8333 gL.task = NULL;
8334
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08008335 /* From this point, until the end of the initialisation function,
Thierry FOURNIERbabae282015-09-17 11:36:37 +02008336 * the Lua function can fail with an abort. We are in the initialisation
8337 * process of HAProxy, this abort() is tolerated.
8338 */
8339
Thierry FOURNIER380d0932015-01-23 14:27:52 +01008340 /* Initialise lua. */
8341 luaL_openlibs(gL.T);
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008342
Thierry Fournier75933d42016-01-21 09:30:18 +01008343 /* Set safe environment for the initialisation. */
8344 if (!SET_SAFE_LJMP(gL.T)) {
Thierry Fournierfd107a22016-02-19 19:57:23 +01008345 if (lua_type(gL.T, -1) == LUA_TSTRING)
8346 error_msg = lua_tostring(gL.T, -1);
8347 else
8348 error_msg = "critical error";
8349 fprintf(stderr, "Lua init: %s.\n", error_msg);
Thierry Fournier75933d42016-01-21 09:30:18 +01008350 exit(1);
8351 }
8352
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008353 /*
8354 *
8355 * Create "core" object.
8356 *
8357 */
8358
Thierry FOURNIERa2d8c652015-03-11 17:29:39 +01008359 /* This table entry is the object "core" base. */
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008360 lua_newtable(gL.T);
8361
8362 /* Push the loglevel constants. */
Willy Tarreau80f5fae2015-02-27 16:38:20 +01008363 for (i = 0; i < NB_LOG_LEVELS; i++)
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008364 hlua_class_const_int(gL.T, log_levels[i], i);
8365
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008366 /* Register special functions. */
8367 hlua_class_function(gL.T, "register_init", hlua_register_init);
Thierry FOURNIER24f33532015-01-23 12:13:00 +01008368 hlua_class_function(gL.T, "register_task", hlua_register_task);
Thierry FOURNIERfa0e5dd2015-02-16 20:19:18 +01008369 hlua_class_function(gL.T, "register_fetches", hlua_register_fetches);
Thierry FOURNIER9be813f2015-02-16 20:21:12 +01008370 hlua_class_function(gL.T, "register_converters", hlua_register_converters);
Thierry FOURNIER8255a752015-09-23 21:03:35 +02008371 hlua_class_function(gL.T, "register_action", hlua_register_action);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008372 hlua_class_function(gL.T, "register_service", hlua_register_service);
Thierry FOURNIER / OZON.IOa44fdd92016-11-13 13:19:20 +01008373 hlua_class_function(gL.T, "register_cli", hlua_register_cli);
Thierry FOURNIER13416fe2015-02-17 15:01:59 +01008374 hlua_class_function(gL.T, "yield", hlua_yield);
Willy Tarreau59551662015-03-10 14:23:13 +01008375 hlua_class_function(gL.T, "set_nice", hlua_set_nice);
Thierry FOURNIER5b8608f2015-02-16 19:43:25 +01008376 hlua_class_function(gL.T, "sleep", hlua_sleep);
8377 hlua_class_function(gL.T, "msleep", hlua_msleep);
Thierry FOURNIER83758bb2015-02-04 13:21:04 +01008378 hlua_class_function(gL.T, "add_acl", hlua_add_acl);
8379 hlua_class_function(gL.T, "del_acl", hlua_del_acl);
8380 hlua_class_function(gL.T, "set_map", hlua_set_map);
8381 hlua_class_function(gL.T, "del_map", hlua_del_map);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008382 hlua_class_function(gL.T, "tcp", hlua_socket_new);
Thierry FOURNIERc798b5d2015-03-17 01:09:57 +01008383 hlua_class_function(gL.T, "log", hlua_log);
8384 hlua_class_function(gL.T, "Debug", hlua_log_debug);
8385 hlua_class_function(gL.T, "Info", hlua_log_info);
8386 hlua_class_function(gL.T, "Warning", hlua_log_warning);
8387 hlua_class_function(gL.T, "Alert", hlua_log_alert);
Thierry FOURNIER0a99b892015-08-26 00:14:17 +02008388 hlua_class_function(gL.T, "done", hlua_done);
Thierry Fournierfb0b5462016-01-21 09:28:58 +01008389 hlua_fcn_reg_core_fcn(gL.T);
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01008390
Thierry FOURNIER2ba18a22015-01-23 14:07:08 +01008391 lua_setglobal(gL.T, "core");
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01008392
8393 /*
8394 *
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008395 * Register class Map
8396 *
8397 */
8398
8399 /* This table entry is the object "Map" base. */
8400 lua_newtable(gL.T);
8401
8402 /* register pattern types. */
8403 for (i=0; i<PAT_MATCH_NUM; i++)
8404 hlua_class_const_int(gL.T, pat_match_names[i], i);
Thierry FOURNIER4dc71972017-01-28 08:33:08 +01008405 for (i=0; i<PAT_MATCH_NUM; i++) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008406 snprintf(trash.area, trash.size, "_%s", pat_match_names[i]);
8407 hlua_class_const_int(gL.T, trash.area, i);
Thierry FOURNIER4dc71972017-01-28 08:33:08 +01008408 }
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008409
8410 /* register constructor. */
8411 hlua_class_function(gL.T, "new", hlua_map_new);
8412
8413 /* Create and fill the metatable. */
8414 lua_newtable(gL.T);
8415
8416 /* Create and fille the __index entry. */
8417 lua_pushstring(gL.T, "__index");
8418 lua_newtable(gL.T);
8419
8420 /* Register . */
8421 hlua_class_function(gL.T, "lookup", hlua_map_lookup);
8422 hlua_class_function(gL.T, "slookup", hlua_map_slookup);
8423
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008424 lua_rawset(gL.T, -3);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008425
Thierry Fournier45e78d72016-02-19 18:34:46 +01008426 /* Register previous table in the registry with reference and named entry.
8427 * The function hlua_register_metatable() pops the stack, so we
8428 * previously create a copy of the table.
8429 */
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008430 lua_pushvalue(gL.T, -1); /* Copy the -1 entry and push it on the stack. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008431 class_map_ref = hlua_register_metatable(gL.T, CLASS_MAP);
Thierry FOURNIER3def3932015-04-07 11:27:54 +02008432
8433 /* Assign the metatable to the mai Map object. */
8434 lua_setmetatable(gL.T, -2);
8435
8436 /* Set a name to the table. */
8437 lua_setglobal(gL.T, "Map");
8438
8439 /*
8440 *
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008441 * Register class Channel
8442 *
8443 */
8444
8445 /* Create and fill the metatable. */
8446 lua_newtable(gL.T);
8447
8448 /* Create and fille the __index entry. */
8449 lua_pushstring(gL.T, "__index");
8450 lua_newtable(gL.T);
8451
8452 /* Register . */
8453 hlua_class_function(gL.T, "get", hlua_channel_get);
8454 hlua_class_function(gL.T, "dup", hlua_channel_dup);
8455 hlua_class_function(gL.T, "getline", hlua_channel_getline);
8456 hlua_class_function(gL.T, "set", hlua_channel_set);
8457 hlua_class_function(gL.T, "append", hlua_channel_append);
8458 hlua_class_function(gL.T, "send", hlua_channel_send);
8459 hlua_class_function(gL.T, "forward", hlua_channel_forward);
8460 hlua_class_function(gL.T, "get_in_len", hlua_channel_get_in_len);
8461 hlua_class_function(gL.T, "get_out_len", hlua_channel_get_out_len);
Thierry FOURNIER / OZON.IO65192f32016-11-07 15:28:40 +01008462 hlua_class_function(gL.T, "is_full", hlua_channel_is_full);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008463
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008464 lua_rawset(gL.T, -3);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008465
8466 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008467 class_channel_ref = hlua_register_metatable(gL.T, CLASS_CHANNEL);
Thierry FOURNIER5a6d3fd2015-02-09 16:38:34 +01008468
8469 /*
8470 *
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01008471 * Register class Fetches
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01008472 *
8473 */
8474
8475 /* Create and fill the metatable. */
8476 lua_newtable(gL.T);
8477
8478 /* Create and fille the __index entry. */
8479 lua_pushstring(gL.T, "__index");
8480 lua_newtable(gL.T);
8481
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008482 /* Browse existing fetches and create the associated
8483 * object method.
8484 */
8485 sf = NULL;
8486 while ((sf = sample_fetch_getnext(sf, &idx)) != NULL) {
8487
8488 /* Dont register the keywork if the arguments check function are
8489 * not safe during the runtime.
8490 */
8491 if ((sf->val_args != NULL) &&
8492 (sf->val_args != val_payload_lv) &&
8493 (sf->val_args != val_hdr))
8494 continue;
8495
8496 /* gL.Tua doesn't support '.' and '-' in the function names, replace it
8497 * by an underscore.
8498 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008499 strncpy(trash.area, sf->kw, trash.size);
8500 trash.area[trash.size - 1] = '\0';
8501 for (p = trash.area; *p; p++)
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008502 if (*p == '.' || *p == '-' || *p == '+')
8503 *p = '_';
8504
8505 /* Register the function. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008506 lua_pushstring(gL.T, trash.area);
Willy Tarreau2ec22742015-03-10 14:27:20 +01008507 lua_pushlightuserdata(gL.T, sf);
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008508 lua_pushcclosure(gL.T, hlua_run_sample_fetch, 1);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008509 lua_rawset(gL.T, -3);
Thierry FOURNIERd0fa5382015-02-16 20:14:51 +01008510 }
8511
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008512 lua_rawset(gL.T, -3);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01008513
8514 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008515 class_fetches_ref = hlua_register_metatable(gL.T, CLASS_FETCHES);
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01008516
8517 /*
8518 *
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008519 * Register class Converters
8520 *
8521 */
8522
8523 /* Create and fill the metatable. */
8524 lua_newtable(gL.T);
8525
8526 /* Create and fill the __index entry. */
8527 lua_pushstring(gL.T, "__index");
8528 lua_newtable(gL.T);
8529
8530 /* Browse existing converters and create the associated
8531 * object method.
8532 */
8533 sc = NULL;
8534 while ((sc = sample_conv_getnext(sc, &idx)) != NULL) {
8535 /* Dont register the keywork if the arguments check function are
8536 * not safe during the runtime.
8537 */
8538 if (sc->val_args != NULL)
8539 continue;
8540
8541 /* gL.Tua doesn't support '.' and '-' in the function names, replace it
8542 * by an underscore.
8543 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008544 strncpy(trash.area, sc->kw, trash.size);
8545 trash.area[trash.size - 1] = '\0';
8546 for (p = trash.area; *p; p++)
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008547 if (*p == '.' || *p == '-' || *p == '+')
8548 *p = '_';
8549
8550 /* Register the function. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008551 lua_pushstring(gL.T, trash.area);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008552 lua_pushlightuserdata(gL.T, sc);
8553 lua_pushcclosure(gL.T, hlua_run_sample_conv, 1);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008554 lua_rawset(gL.T, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008555 }
8556
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008557 lua_rawset(gL.T, -3);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008558
8559 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008560 class_converters_ref = hlua_register_metatable(gL.T, CLASS_CONVERTERS);
Thierry FOURNIER594afe72015-03-10 23:58:30 +01008561
8562 /*
8563 *
Thierry FOURNIER08504f42015-03-16 14:17:08 +01008564 * Register class HTTP
8565 *
8566 */
8567
8568 /* Create and fill the metatable. */
8569 lua_newtable(gL.T);
8570
8571 /* Create and fille the __index entry. */
8572 lua_pushstring(gL.T, "__index");
8573 lua_newtable(gL.T);
8574
8575 /* Register Lua functions. */
8576 hlua_class_function(gL.T, "req_get_headers",hlua_http_req_get_headers);
8577 hlua_class_function(gL.T, "req_del_header", hlua_http_req_del_hdr);
8578 hlua_class_function(gL.T, "req_rep_header", hlua_http_req_rep_hdr);
8579 hlua_class_function(gL.T, "req_rep_value", hlua_http_req_rep_val);
8580 hlua_class_function(gL.T, "req_add_header", hlua_http_req_add_hdr);
8581 hlua_class_function(gL.T, "req_set_header", hlua_http_req_set_hdr);
8582 hlua_class_function(gL.T, "req_set_method", hlua_http_req_set_meth);
8583 hlua_class_function(gL.T, "req_set_path", hlua_http_req_set_path);
8584 hlua_class_function(gL.T, "req_set_query", hlua_http_req_set_query);
8585 hlua_class_function(gL.T, "req_set_uri", hlua_http_req_set_uri);
8586
8587 hlua_class_function(gL.T, "res_get_headers",hlua_http_res_get_headers);
8588 hlua_class_function(gL.T, "res_del_header", hlua_http_res_del_hdr);
8589 hlua_class_function(gL.T, "res_rep_header", hlua_http_res_rep_hdr);
8590 hlua_class_function(gL.T, "res_rep_value", hlua_http_res_rep_val);
8591 hlua_class_function(gL.T, "res_add_header", hlua_http_res_add_hdr);
8592 hlua_class_function(gL.T, "res_set_header", hlua_http_res_set_hdr);
Thierry FOURNIER35d70ef2015-08-26 16:21:56 +02008593 hlua_class_function(gL.T, "res_set_status", hlua_http_res_set_status);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01008594
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008595 lua_rawset(gL.T, -3);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01008596
8597 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008598 class_http_ref = hlua_register_metatable(gL.T, CLASS_HTTP);
Thierry FOURNIER08504f42015-03-16 14:17:08 +01008599
8600 /*
8601 *
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008602 * Register class AppletTCP
8603 *
8604 */
8605
8606 /* Create and fill the metatable. */
8607 lua_newtable(gL.T);
8608
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008609 /* Create and fille the __index entry. */
8610 lua_pushstring(gL.T, "__index");
8611 lua_newtable(gL.T);
8612
8613 /* Register Lua functions. */
Thierry FOURNIER / OZON.IO3e1d7912016-12-12 12:29:34 +01008614 hlua_class_function(gL.T, "getline", hlua_applet_tcp_getline);
8615 hlua_class_function(gL.T, "receive", hlua_applet_tcp_recv);
8616 hlua_class_function(gL.T, "send", hlua_applet_tcp_send);
8617 hlua_class_function(gL.T, "set_priv", hlua_applet_tcp_set_priv);
8618 hlua_class_function(gL.T, "get_priv", hlua_applet_tcp_get_priv);
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01008619 hlua_class_function(gL.T, "set_var", hlua_applet_tcp_set_var);
8620 hlua_class_function(gL.T, "unset_var", hlua_applet_tcp_unset_var);
8621 hlua_class_function(gL.T, "get_var", hlua_applet_tcp_get_var);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008622
8623 lua_settable(gL.T, -3);
8624
8625 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008626 class_applet_tcp_ref = hlua_register_metatable(gL.T, CLASS_APPLET_TCP);
Thierry FOURNIERf0a64b62015-09-19 12:36:17 +02008627
8628 /*
8629 *
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02008630 * Register class AppletHTTP
8631 *
8632 */
8633
8634 /* Create and fill the metatable. */
8635 lua_newtable(gL.T);
8636
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02008637 /* Create and fille the __index entry. */
8638 lua_pushstring(gL.T, "__index");
8639 lua_newtable(gL.T);
8640
8641 /* Register Lua functions. */
Thierry FOURNIER8db004c2015-12-25 01:33:18 +01008642 hlua_class_function(gL.T, "set_priv", hlua_applet_http_set_priv);
8643 hlua_class_function(gL.T, "get_priv", hlua_applet_http_get_priv);
Thierry FOURNIER / OZON.IO4394a2c2016-12-12 12:31:54 +01008644 hlua_class_function(gL.T, "set_var", hlua_applet_http_set_var);
8645 hlua_class_function(gL.T, "unset_var", hlua_applet_http_unset_var);
8646 hlua_class_function(gL.T, "get_var", hlua_applet_http_get_var);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02008647 hlua_class_function(gL.T, "getline", hlua_applet_http_getline);
8648 hlua_class_function(gL.T, "receive", hlua_applet_http_recv);
8649 hlua_class_function(gL.T, "send", hlua_applet_http_send);
8650 hlua_class_function(gL.T, "add_header", hlua_applet_http_addheader);
8651 hlua_class_function(gL.T, "set_status", hlua_applet_http_status);
8652 hlua_class_function(gL.T, "start_response", hlua_applet_http_start_response);
8653
8654 lua_settable(gL.T, -3);
8655
8656 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008657 class_applet_http_ref = hlua_register_metatable(gL.T, CLASS_APPLET_HTTP);
Thierry FOURNIERa30b5db2015-09-18 09:04:27 +02008658
8659 /*
8660 *
Thierry FOURNIERbb53c7b2015-03-11 18:28:02 +01008661 * Register class TXN
8662 *
8663 */
8664
8665 /* Create and fill the metatable. */
8666 lua_newtable(gL.T);
8667
8668 /* Create and fille the __index entry. */
8669 lua_pushstring(gL.T, "__index");
8670 lua_newtable(gL.T);
8671
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01008672 /* Register Lua functions. */
Patrick Hemmer268a7072018-05-11 12:52:31 -04008673 hlua_class_function(gL.T, "set_priv", hlua_set_priv);
8674 hlua_class_function(gL.T, "get_priv", hlua_get_priv);
8675 hlua_class_function(gL.T, "set_var", hlua_set_var);
8676 hlua_class_function(gL.T, "unset_var", hlua_unset_var);
8677 hlua_class_function(gL.T, "get_var", hlua_get_var);
8678 hlua_class_function(gL.T, "done", hlua_txn_done);
8679 hlua_class_function(gL.T, "set_loglevel", hlua_txn_set_loglevel);
8680 hlua_class_function(gL.T, "set_tos", hlua_txn_set_tos);
8681 hlua_class_function(gL.T, "set_mark", hlua_txn_set_mark);
8682 hlua_class_function(gL.T, "set_priority_class", hlua_txn_set_priority_class);
8683 hlua_class_function(gL.T, "set_priority_offset", hlua_txn_set_priority_offset);
8684 hlua_class_function(gL.T, "deflog", hlua_txn_deflog);
8685 hlua_class_function(gL.T, "log", hlua_txn_log);
8686 hlua_class_function(gL.T, "Debug", hlua_txn_log_debug);
8687 hlua_class_function(gL.T, "Info", hlua_txn_log_info);
8688 hlua_class_function(gL.T, "Warning", hlua_txn_log_warning);
8689 hlua_class_function(gL.T, "Alert", hlua_txn_log_alert);
Thierry FOURNIER05c0b8a2015-02-25 11:43:21 +01008690
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008691 lua_rawset(gL.T, -3);
Thierry FOURNIER65f34c62015-02-16 20:11:43 +01008692
8693 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008694 class_txn_ref = hlua_register_metatable(gL.T, CLASS_TXN);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008695
8696 /*
8697 *
8698 * Register class Socket
8699 *
8700 */
8701
8702 /* Create and fill the metatable. */
8703 lua_newtable(gL.T);
8704
8705 /* Create and fille the __index entry. */
8706 lua_pushstring(gL.T, "__index");
8707 lua_newtable(gL.T);
8708
Baptiste Assmann84bb4932015-03-02 21:40:06 +01008709#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008710 hlua_class_function(gL.T, "connect_ssl", hlua_socket_connect_ssl);
Baptiste Assmann84bb4932015-03-02 21:40:06 +01008711#endif
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008712 hlua_class_function(gL.T, "connect", hlua_socket_connect);
8713 hlua_class_function(gL.T, "send", hlua_socket_send);
8714 hlua_class_function(gL.T, "receive", hlua_socket_receive);
8715 hlua_class_function(gL.T, "close", hlua_socket_close);
8716 hlua_class_function(gL.T, "getpeername", hlua_socket_getpeername);
8717 hlua_class_function(gL.T, "getsockname", hlua_socket_getsockname);
8718 hlua_class_function(gL.T, "setoption", hlua_socket_setoption);
8719 hlua_class_function(gL.T, "settimeout", hlua_socket_settimeout);
8720
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008721 lua_rawset(gL.T, -3); /* Push the last 2 entries in the table at index -3 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008722
8723 /* Register the garbage collector entry. */
8724 lua_pushstring(gL.T, "__gc");
8725 lua_pushcclosure(gL.T, hlua_socket_gc, 0);
Thierry FOURNIER84e73c82015-09-25 22:13:32 +02008726 lua_rawset(gL.T, -3); /* Push the last 2 entries in the table at index -3 */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008727
8728 /* Register previous table in the registry with reference and named entry. */
Thierry Fournier45e78d72016-02-19 18:34:46 +01008729 class_socket_ref = hlua_register_metatable(gL.T, CLASS_SOCKET);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008730
8731 /* Proxy and server configuration initialisation. */
8732 memset(&socket_proxy, 0, sizeof(socket_proxy));
8733 init_new_proxy(&socket_proxy);
8734 socket_proxy.parent = NULL;
8735 socket_proxy.last_change = now.tv_sec;
8736 socket_proxy.id = "LUA-SOCKET";
8737 socket_proxy.cap = PR_CAP_FE | PR_CAP_BE;
8738 socket_proxy.maxconn = 0;
8739 socket_proxy.accept = NULL;
8740 socket_proxy.options2 |= PR_O2_INDEPSTR;
8741 socket_proxy.srv = NULL;
8742 socket_proxy.conn_retries = 0;
8743 socket_proxy.timeout.connect = 5000; /* By default the timeout connection is 5s. */
8744
8745 /* Init TCP server: unchanged parameters */
8746 memset(&socket_tcp, 0, sizeof(socket_tcp));
8747 socket_tcp.next = NULL;
8748 socket_tcp.proxy = &socket_proxy;
8749 socket_tcp.obj_type = OBJ_TYPE_SERVER;
8750 LIST_INIT(&socket_tcp.actconns);
Patrick Hemmer0355dab2018-05-11 12:52:31 -04008751 socket_tcp.pendconns = EB_ROOT;
Christopher Faulet40a007c2017-07-03 15:41:01 +02008752 socket_tcp.priv_conns = NULL;
8753 socket_tcp.idle_conns = NULL;
8754 socket_tcp.safe_conns = NULL;
Emeric Brun52a91d32017-08-31 14:41:55 +02008755 socket_tcp.next_state = SRV_ST_RUNNING; /* early server setup */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008756 socket_tcp.last_change = 0;
8757 socket_tcp.id = "LUA-TCP-CONN";
8758 socket_tcp.check.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
8759 socket_tcp.agent.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
8760 socket_tcp.pp_opts = 0; /* Remove proxy protocol. */
8761
8762 /* XXX: Copy default parameter from default server,
8763 * but the default server is not initialized.
8764 */
8765 socket_tcp.maxqueue = socket_proxy.defsrv.maxqueue;
8766 socket_tcp.minconn = socket_proxy.defsrv.minconn;
8767 socket_tcp.maxconn = socket_proxy.defsrv.maxconn;
8768 socket_tcp.slowstart = socket_proxy.defsrv.slowstart;
8769 socket_tcp.onerror = socket_proxy.defsrv.onerror;
8770 socket_tcp.onmarkeddown = socket_proxy.defsrv.onmarkeddown;
8771 socket_tcp.onmarkedup = socket_proxy.defsrv.onmarkedup;
8772 socket_tcp.consecutive_errors_limit = socket_proxy.defsrv.consecutive_errors_limit;
8773 socket_tcp.uweight = socket_proxy.defsrv.iweight;
8774 socket_tcp.iweight = socket_proxy.defsrv.iweight;
8775
8776 socket_tcp.check.status = HCHK_STATUS_INI;
8777 socket_tcp.check.rise = socket_proxy.defsrv.check.rise;
8778 socket_tcp.check.fall = socket_proxy.defsrv.check.fall;
8779 socket_tcp.check.health = socket_tcp.check.rise; /* socket, but will fall down at first failure */
8780 socket_tcp.check.server = &socket_tcp;
8781
8782 socket_tcp.agent.status = HCHK_STATUS_INI;
8783 socket_tcp.agent.rise = socket_proxy.defsrv.agent.rise;
8784 socket_tcp.agent.fall = socket_proxy.defsrv.agent.fall;
8785 socket_tcp.agent.health = socket_tcp.agent.rise; /* socket, but will fall down at first failure */
8786 socket_tcp.agent.server = &socket_tcp;
8787
Willy Tarreaua261e9b2016-12-22 20:44:00 +01008788 socket_tcp.xprt = xprt_get(XPRT_RAW);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008789
8790#ifdef USE_OPENSSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008791 /* Init TCP server: unchanged parameters */
8792 memset(&socket_ssl, 0, sizeof(socket_ssl));
8793 socket_ssl.next = NULL;
8794 socket_ssl.proxy = &socket_proxy;
8795 socket_ssl.obj_type = OBJ_TYPE_SERVER;
8796 LIST_INIT(&socket_ssl.actconns);
Patrick Hemmer0355dab2018-05-11 12:52:31 -04008797 socket_ssl.pendconns = EB_ROOT;
Willy Tarreaub784b352019-02-07 14:48:24 +01008798 socket_ssl.priv_conns = NULL;
8799 socket_ssl.idle_conns = NULL;
8800 socket_ssl.safe_conns = NULL;
Emeric Brun52a91d32017-08-31 14:41:55 +02008801 socket_ssl.next_state = SRV_ST_RUNNING; /* early server setup */
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008802 socket_ssl.last_change = 0;
8803 socket_ssl.id = "LUA-SSL-CONN";
8804 socket_ssl.check.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
8805 socket_ssl.agent.state &= ~CHK_ST_ENABLED; /* Disable health checks. */
8806 socket_ssl.pp_opts = 0; /* Remove proxy protocol. */
8807
8808 /* XXX: Copy default parameter from default server,
8809 * but the default server is not initialized.
8810 */
8811 socket_ssl.maxqueue = socket_proxy.defsrv.maxqueue;
8812 socket_ssl.minconn = socket_proxy.defsrv.minconn;
8813 socket_ssl.maxconn = socket_proxy.defsrv.maxconn;
8814 socket_ssl.slowstart = socket_proxy.defsrv.slowstart;
8815 socket_ssl.onerror = socket_proxy.defsrv.onerror;
8816 socket_ssl.onmarkeddown = socket_proxy.defsrv.onmarkeddown;
8817 socket_ssl.onmarkedup = socket_proxy.defsrv.onmarkedup;
8818 socket_ssl.consecutive_errors_limit = socket_proxy.defsrv.consecutive_errors_limit;
8819 socket_ssl.uweight = socket_proxy.defsrv.iweight;
8820 socket_ssl.iweight = socket_proxy.defsrv.iweight;
8821
8822 socket_ssl.check.status = HCHK_STATUS_INI;
8823 socket_ssl.check.rise = socket_proxy.defsrv.check.rise;
8824 socket_ssl.check.fall = socket_proxy.defsrv.check.fall;
8825 socket_ssl.check.health = socket_ssl.check.rise; /* socket, but will fall down at first failure */
8826 socket_ssl.check.server = &socket_ssl;
8827
8828 socket_ssl.agent.status = HCHK_STATUS_INI;
8829 socket_ssl.agent.rise = socket_proxy.defsrv.agent.rise;
8830 socket_ssl.agent.fall = socket_proxy.defsrv.agent.fall;
8831 socket_ssl.agent.health = socket_ssl.agent.rise; /* socket, but will fall down at first failure */
8832 socket_ssl.agent.server = &socket_ssl;
8833
Thierry FOURNIER36d13742015-03-17 16:48:53 +01008834 socket_ssl.use_ssl = 1;
Willy Tarreaua261e9b2016-12-22 20:44:00 +01008835 socket_ssl.xprt = xprt_get(XPRT_SSL);
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008836
Thierry FOURNIER36d13742015-03-17 16:48:53 +01008837 for (idx = 0; args[idx] != NULL; idx++) {
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008838 if ((kw = srv_find_kw(args[idx])) != NULL) { /* Maybe it's registered server keyword */
8839 /*
8840 *
8841 * If the keyword is not known, we can search in the registered
Joseph Herlantb8f9c5e2018-11-15 10:06:08 -08008842 * server keywords. This is useful to configure special SSL
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008843 * features like client certificates and ssl_verify.
8844 *
8845 */
8846 tmp_error = kw->parse(args, &idx, &socket_proxy, &socket_ssl, &error);
8847 if (tmp_error != 0) {
8848 fprintf(stderr, "INTERNAL ERROR: %s\n", error);
8849 abort(); /* This must be never arrives because the command line
8850 not editable by the user. */
8851 }
8852 idx += kw->skip;
8853 }
8854 }
Thierry FOURNIER7e7ac322015-02-16 19:27:16 +01008855#endif
Thierry Fournier75933d42016-01-21 09:30:18 +01008856
8857 RESET_SAFE_LJMP(gL.T);
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +01008858}
Willy Tarreaubb57d942016-12-21 19:04:56 +01008859
Willy Tarreau80713382018-11-26 10:19:54 +01008860static void hlua_register_build_options(void)
8861{
Willy Tarreaubb57d942016-12-21 19:04:56 +01008862 char *ptr = NULL;
Willy Tarreau80713382018-11-26 10:19:54 +01008863
Willy Tarreaubb57d942016-12-21 19:04:56 +01008864 memprintf(&ptr, "Built with Lua version : %s", LUA_RELEASE);
8865 hap_register_build_opts(ptr, 1);
8866}
Willy Tarreau80713382018-11-26 10:19:54 +01008867
8868INITCALL0(STG_REGISTER, hlua_register_build_options);