BUG/MEDIUM: htx: When performing zero-copy, start from the right offset.
[haproxy.git] / src / hlua.c
1 /*
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
13 #include <ctype.h>
14 #include <setjmp.h>
15
16 #include <lauxlib.h>
17 #include <lua.h>
18 #include <lualib.h>
19
20 #if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 503
21 #error "Requires Lua 5.3 or later."
22 #endif
23
24 #include <ebpttree.h>
25
26 #include <common/cfgparse.h>
27 #include <common/xref.h>
28 #include <common/hathreads.h>
29
30 #include <types/cli.h>
31 #include <types/hlua.h>
32 #include <types/proxy.h>
33 #include <types/stats.h>
34
35 #include <proto/arg.h>
36 #include <proto/applet.h>
37 #include <proto/channel.h>
38 #include <proto/cli.h>
39 #include <proto/connection.h>
40 #include <proto/stats.h>
41 #include <proto/hdr_idx.h>
42 #include <proto/hlua.h>
43 #include <proto/hlua_fcn.h>
44 #include <proto/map.h>
45 #include <proto/obj_type.h>
46 #include <proto/pattern.h>
47 #include <proto/payload.h>
48 #include <proto/proto_http.h>
49 #include <proto/sample.h>
50 #include <proto/server.h>
51 #include <proto/session.h>
52 #include <proto/stream.h>
53 #include <proto/stream_interface.h>
54 #include <proto/task.h>
55 #include <proto/tcp_rules.h>
56 #include <proto/vars.h>
57
58 /* Lua uses longjmp to perform yield or throwing errors. This
59  * macro is used only for identifying the function that can
60  * not return because a longjmp is executed.
61  *   __LJMP marks a prototype of hlua file that can use longjmp.
62  *   WILL_LJMP() marks an lua function that will use longjmp.
63  *   MAY_LJMP() marks an lua function that may use longjmp.
64  */
65 #define __LJMP
66 #define WILL_LJMP(func) func
67 #define MAY_LJMP(func) func
68
69 /* This couple of function executes securely some Lua calls outside of
70  * the lua runtime environment. Each Lua call can return a longjmp
71  * if it encounter a memory error.
72  *
73  * Lua documentation extract:
74  *
75  *   If an error happens outside any protected environment, Lua calls
76  *   a panic function (see lua_atpanic) and then calls abort, thus
77  *   exiting the host application. Your panic function can avoid this
78  *   exit by never returning (e.g., doing a long jump to your own
79  *   recovery point outside Lua).
80  *
81  *   The panic function runs as if it were a message handler (see
82  *   §2.3); in particular, the error message is at the top of the
83  *   stack. However, there is no guarantee about stack space. To push
84  *   anything on the stack, the panic function must first check the
85  *   available space (see §4.2).
86  *
87  * We must check all the Lua entry point. This includes:
88  *  - The include/proto/hlua.h exported functions
89  *  - the task wrapper function
90  *  - The action wrapper function
91  *  - The converters wrapper function
92  *  - The sample-fetch wrapper functions
93  *
94  * It is tolerated that the initilisation function returns an abort.
95  * Before each Lua abort, an error message is writed on stderr.
96  *
97  * The macro SET_SAFE_LJMP initialise the longjmp. The Macro
98  * RESET_SAFE_LJMP reset the longjmp. These function must be macro
99  * because they must be exists in the program stack when the longjmp
100  * is called.
101  *
102  * Note that the Lua processing is not really thread safe. It provides
103  * heavy system which consists to add our own lock function in the Lua
104  * code and recompile the library. This system will probably not accepted
105  * by maintainers of various distribs.
106  *
107  * Our main excution point of the Lua is the function lua_resume(). A
108  * quick looking on the Lua sources displays a lua_lock() a the start
109  * of function and a lua_unlock() at the end of the function. So I
110  * conclude that the Lua thread safe mode just perform a mutex around
111  * all execution. So I prefer to do this in the HAProxy code, it will be
112  * easier for distro maintainers.
113  *
114  * Note that the HAProxy lua functions rounded by the macro SET_SAFE_LJMP
115  * and RESET_SAFE_LJMP manipulates the Lua stack, so it will be careful
116  * to set mutex around these functions.
117  */
118 __decl_hathreads(HA_SPINLOCK_T hlua_global_lock);
119 THREAD_LOCAL jmp_buf safe_ljmp_env;
120 static int hlua_panic_safe(lua_State *L) { return 0; }
121 static int hlua_panic_ljmp(lua_State *L) { longjmp(safe_ljmp_env, 1); }
122
123 #define SET_SAFE_LJMP(__L) \
124         ({ \
125                 int ret; \
126                 HA_SPIN_LOCK(LUA_LOCK, &hlua_global_lock); \
127                 if (setjmp(safe_ljmp_env) != 0) { \
128                         lua_atpanic(__L, hlua_panic_safe); \
129                         ret = 0; \
130                         HA_SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock); \
131                 } else { \
132                         lua_atpanic(__L, hlua_panic_ljmp); \
133                         ret = 1; \
134                 } \
135                 ret; \
136         })
137
138 /* If we are the last function catching Lua errors, we
139  * must reset the panic function.
140  */
141 #define RESET_SAFE_LJMP(__L) \
142         do { \
143                 lua_atpanic(__L, hlua_panic_safe); \
144                 HA_SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock); \
145         } while(0)
146
147 /* Applet status flags */
148 #define APPLET_DONE     0x01 /* applet processing is done. */
149 #define APPLET_100C     0x02 /* 100 continue expected. */
150 #define APPLET_HDR_SENT 0x04 /* Response header sent. */
151 #define APPLET_CHUNKED  0x08 /* Use transfer encoding chunked. */
152 #define APPLET_LAST_CHK 0x10 /* Last chunk sent. */
153 #define APPLET_HTTP11   0x20 /* Last chunk sent. */
154
155 #define HTTP_100C "HTTP/1.1 100 Continue\r\n\r\n"
156
157 /* The main Lua execution context. */
158 struct hlua gL;
159
160 /* This is the memory pool containing struct lua for applets
161  * (including cli).
162  */
163 struct pool_head *pool_head_hlua;
164
165 /* Used for Socket connection. */
166 static struct proxy socket_proxy;
167 static struct server socket_tcp;
168 #ifdef USE_OPENSSL
169 static struct server socket_ssl;
170 #endif
171
172 /* List head of the function called at the initialisation time. */
173 struct list hlua_init_functions = LIST_HEAD_INIT(hlua_init_functions);
174
175 /* The following variables contains the reference of the different
176  * Lua classes. These references are useful for identify metadata
177  * associated with an object.
178  */
179 static int class_txn_ref;
180 static int class_socket_ref;
181 static int class_channel_ref;
182 static int class_fetches_ref;
183 static int class_converters_ref;
184 static int class_http_ref;
185 static int class_map_ref;
186 static int class_applet_tcp_ref;
187 static int class_applet_http_ref;
188
189 /* Global Lua execution timeout. By default Lua, execution linked
190  * with stream (actions, sample-fetches and converters) have a
191  * short timeout. Lua linked with tasks doesn't have a timeout
192  * because a task may remain alive during all the haproxy execution.
193  */
194 static unsigned int hlua_timeout_session = 4000; /* session timeout. */
195 static unsigned int hlua_timeout_task = TICK_ETERNITY; /* task timeout. */
196 static unsigned int hlua_timeout_applet = 4000; /* applet timeout. */
197
198 /* Interrupts the Lua processing each "hlua_nb_instruction" instructions.
199  * it is used for preventing infinite loops.
200  *
201  * I test the scheer with an infinite loop containing one incrementation
202  * and one test. I run this loop between 10 seconds, I raise a ceil of
203  * 710M loops from one interrupt each 9000 instructions, so I fix the value
204  * to one interrupt each 10 000 instructions.
205  *
206  *  configured    | Number of
207  *  instructions  | loops executed
208  *  between two   | in milions
209  *  forced yields |
210  * ---------------+---------------
211  *  10            | 160
212  *  500           | 670
213  *  1000          | 680
214  *  5000          | 700
215  *  7000          | 700
216  *  8000          | 700
217  *  9000          | 710 <- ceil
218  *  10000         | 710
219  *  100000        | 710
220  *  1000000       | 710
221  *
222  */
223 static unsigned int hlua_nb_instruction = 10000;
224
225 /* Descriptor for the memory allocation state. If limit is not null, it will
226  * be enforced on any memory allocation.
227  */
228 struct hlua_mem_allocator {
229         size_t allocated;
230         size_t limit;
231 };
232
233 static struct hlua_mem_allocator hlua_global_allocator;
234
235 static const char error_500[] =
236         "HTTP/1.0 500 Internal Server Error\r\n"
237         "Cache-Control: no-cache\r\n"
238         "Connection: close\r\n"
239         "Content-Type: text/html\r\n"
240         "\r\n"
241         "<html><body><h1>500 Internal Server Error</h1>\nAn internal server error occured.\n</body></html>\n";
242
243 /* These functions converts types between HAProxy internal args or
244  * sample and LUA types. Another function permits to check if the
245  * LUA stack contains arguments according with an required ARG_T
246  * format.
247  */
248 static int hlua_arg2lua(lua_State *L, const struct arg *arg);
249 static int hlua_lua2arg(lua_State *L, int ud, struct arg *arg);
250 __LJMP static int hlua_lua2arg_check(lua_State *L, int first, struct arg *argp,
251                                      uint64_t mask, struct proxy *p);
252 static int hlua_smp2lua(lua_State *L, struct sample *smp);
253 static int hlua_smp2lua_str(lua_State *L, struct sample *smp);
254 static int hlua_lua2smp(lua_State *L, int ud, struct sample *smp);
255
256 __LJMP static int hlua_http_get_headers(lua_State *L, struct hlua_txn *htxn, struct http_msg *msg);
257
258 #define SEND_ERR(__be, __fmt, __args...) \
259         do { \
260                 send_log(__be, LOG_ERR, __fmt, ## __args); \
261                 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) \
262                         ha_alert(__fmt, ## __args); \
263         } while (0)
264
265 /* Used to check an Lua function type in the stack. It creates and
266  * returns a reference of the function. This function throws an
267  * error if the rgument is not a "function".
268  */
269 __LJMP unsigned int hlua_checkfunction(lua_State *L, int argno)
270 {
271         if (!lua_isfunction(L, argno)) {
272                 const char *msg = lua_pushfstring(L, "function expected, got %s", luaL_typename(L, -1));
273                 WILL_LJMP(luaL_argerror(L, argno, msg));
274         }
275         lua_pushvalue(L, argno);
276         return luaL_ref(L, LUA_REGISTRYINDEX);
277 }
278
279 /* Return the string that is of the top of the stack. */
280 const char *hlua_get_top_error_string(lua_State *L)
281 {
282         if (lua_gettop(L) < 1)
283                 return "unknown error";
284         if (lua_type(L, -1) != LUA_TSTRING)
285                 return "unknown error";
286         return lua_tostring(L, -1);
287 }
288
289 /* This function check the number of arguments available in the
290  * stack. If the number of arguments available is not the same
291  * then <nb> an error is throwed.
292  */
293 __LJMP static inline void check_args(lua_State *L, int nb, char *fcn)
294 {
295         if (lua_gettop(L) == nb)
296                 return;
297         WILL_LJMP(luaL_error(L, "'%s' needs %d arguments", fcn, nb));
298 }
299
300 /* This fucntion push an error string prefixed by the file name
301  * and the line number where the error is encountered.
302  */
303 static int hlua_pusherror(lua_State *L, const char *fmt, ...)
304 {
305         va_list argp;
306         va_start(argp, fmt);
307         luaL_where(L, 1);
308         lua_pushvfstring(L, fmt, argp);
309         va_end(argp);
310         lua_concat(L, 2);
311         return 1;
312 }
313
314 /* This functions is used with sample fetch and converters. It
315  * converts the HAProxy configuration argument in a lua stack
316  * values.
317  *
318  * It takes an array of "arg", and each entry of the array is
319  * converted and pushed in the LUA stack.
320  */
321 static int hlua_arg2lua(lua_State *L, const struct arg *arg)
322 {
323         switch (arg->type) {
324         case ARGT_SINT:
325         case ARGT_TIME:
326         case ARGT_SIZE:
327                 lua_pushinteger(L, arg->data.sint);
328                 break;
329
330         case ARGT_STR:
331                 lua_pushlstring(L, arg->data.str.str, arg->data.str.len);
332                 break;
333
334         case ARGT_IPV4:
335         case ARGT_IPV6:
336         case ARGT_MSK4:
337         case ARGT_MSK6:
338         case ARGT_FE:
339         case ARGT_BE:
340         case ARGT_TAB:
341         case ARGT_SRV:
342         case ARGT_USR:
343         case ARGT_MAP:
344         default:
345                 lua_pushnil(L);
346                 break;
347         }
348         return 1;
349 }
350
351 /* This function take one entrie in an LUA stack at the index "ud",
352  * and try to convert it in an HAProxy argument entry. This is useful
353  * with sample fetch wrappers. The input arguments are gived to the
354  * lua wrapper and converted as arg list by thi function.
355  */
356 static int hlua_lua2arg(lua_State *L, int ud, struct arg *arg)
357 {
358         switch (lua_type(L, ud)) {
359
360         case LUA_TNUMBER:
361         case LUA_TBOOLEAN:
362                 arg->type = ARGT_SINT;
363                 arg->data.sint = lua_tointeger(L, ud);
364                 break;
365
366         case LUA_TSTRING:
367                 arg->type = ARGT_STR;
368                 arg->data.str.str = (char *)lua_tolstring(L, ud, (size_t *)&arg->data.str.len);
369                 break;
370
371         case LUA_TUSERDATA:
372         case LUA_TNIL:
373         case LUA_TTABLE:
374         case LUA_TFUNCTION:
375         case LUA_TTHREAD:
376         case LUA_TLIGHTUSERDATA:
377                 arg->type = ARGT_SINT;
378                 arg->data.sint = 0;
379                 break;
380         }
381         return 1;
382 }
383
384 /* the following functions are used to convert a struct sample
385  * in Lua type. This useful to convert the return of the
386  * fetchs or converters.
387  */
388 static int hlua_smp2lua(lua_State *L, struct sample *smp)
389 {
390         switch (smp->data.type) {
391         case SMP_T_SINT:
392         case SMP_T_BOOL:
393                 lua_pushinteger(L, smp->data.u.sint);
394                 break;
395
396         case SMP_T_BIN:
397         case SMP_T_STR:
398                 lua_pushlstring(L, smp->data.u.str.str, smp->data.u.str.len);
399                 break;
400
401         case SMP_T_METH:
402                 switch (smp->data.u.meth.meth) {
403                 case HTTP_METH_OPTIONS: lua_pushstring(L, "OPTIONS"); break;
404                 case HTTP_METH_GET:     lua_pushstring(L, "GET");     break;
405                 case HTTP_METH_HEAD:    lua_pushstring(L, "HEAD");    break;
406                 case HTTP_METH_POST:    lua_pushstring(L, "POST");    break;
407                 case HTTP_METH_PUT:     lua_pushstring(L, "PUT");     break;
408                 case HTTP_METH_DELETE:  lua_pushstring(L, "DELETE");  break;
409                 case HTTP_METH_TRACE:   lua_pushstring(L, "TRACE");   break;
410                 case HTTP_METH_CONNECT: lua_pushstring(L, "CONNECT"); break;
411                 case HTTP_METH_OTHER:
412                         lua_pushlstring(L, smp->data.u.meth.str.str, smp->data.u.meth.str.len);
413                         break;
414                 default:
415                         lua_pushnil(L);
416                         break;
417                 }
418                 break;
419
420         case SMP_T_IPV4:
421         case SMP_T_IPV6:
422         case SMP_T_ADDR: /* This type is never used to qualify a sample. */
423                 if (sample_casts[smp->data.type][SMP_T_STR] &&
424                     sample_casts[smp->data.type][SMP_T_STR](smp))
425                         lua_pushlstring(L, smp->data.u.str.str, smp->data.u.str.len);
426                 else
427                         lua_pushnil(L);
428                 break;
429         default:
430                 lua_pushnil(L);
431                 break;
432         }
433         return 1;
434 }
435
436 /* the following functions are used to convert a struct sample
437  * in Lua strings. This is useful to convert the return of the
438  * fetchs or converters.
439  */
440 static int hlua_smp2lua_str(lua_State *L, struct sample *smp)
441 {
442         switch (smp->data.type) {
443
444         case SMP_T_BIN:
445         case SMP_T_STR:
446                 lua_pushlstring(L, smp->data.u.str.str, smp->data.u.str.len);
447                 break;
448
449         case SMP_T_METH:
450                 switch (smp->data.u.meth.meth) {
451                 case HTTP_METH_OPTIONS: lua_pushstring(L, "OPTIONS"); break;
452                 case HTTP_METH_GET:     lua_pushstring(L, "GET");     break;
453                 case HTTP_METH_HEAD:    lua_pushstring(L, "HEAD");    break;
454                 case HTTP_METH_POST:    lua_pushstring(L, "POST");    break;
455                 case HTTP_METH_PUT:     lua_pushstring(L, "PUT");     break;
456                 case HTTP_METH_DELETE:  lua_pushstring(L, "DELETE");  break;
457                 case HTTP_METH_TRACE:   lua_pushstring(L, "TRACE");   break;
458                 case HTTP_METH_CONNECT: lua_pushstring(L, "CONNECT"); break;
459                 case HTTP_METH_OTHER:
460                         lua_pushlstring(L, smp->data.u.meth.str.str, smp->data.u.meth.str.len);
461                         break;
462                 default:
463                         lua_pushstring(L, "");
464                         break;
465                 }
466                 break;
467
468         case SMP_T_SINT:
469         case SMP_T_BOOL:
470         case SMP_T_IPV4:
471         case SMP_T_IPV6:
472         case SMP_T_ADDR: /* This type is never used to qualify a sample. */
473                 if (sample_casts[smp->data.type][SMP_T_STR] &&
474                     sample_casts[smp->data.type][SMP_T_STR](smp))
475                         lua_pushlstring(L, smp->data.u.str.str, smp->data.u.str.len);
476                 else
477                         lua_pushstring(L, "");
478                 break;
479         default:
480                 lua_pushstring(L, "");
481                 break;
482         }
483         return 1;
484 }
485
486 /* the following functions are used to convert an Lua type in a
487  * struct sample. This is useful to provide data from a converter
488  * to the LUA code.
489  */
490 static int hlua_lua2smp(lua_State *L, int ud, struct sample *smp)
491 {
492         switch (lua_type(L, ud)) {
493
494         case LUA_TNUMBER:
495                 smp->data.type = SMP_T_SINT;
496                 smp->data.u.sint = lua_tointeger(L, ud);
497                 break;
498
499
500         case LUA_TBOOLEAN:
501                 smp->data.type = SMP_T_BOOL;
502                 smp->data.u.sint = lua_toboolean(L, ud);
503                 break;
504
505         case LUA_TSTRING:
506                 smp->data.type = SMP_T_STR;
507                 smp->flags |= SMP_F_CONST;
508                 smp->data.u.str.str = (char *)lua_tolstring(L, ud, (size_t *)&smp->data.u.str.len);
509                 break;
510
511         case LUA_TUSERDATA:
512         case LUA_TNIL:
513         case LUA_TTABLE:
514         case LUA_TFUNCTION:
515         case LUA_TTHREAD:
516         case LUA_TLIGHTUSERDATA:
517         case LUA_TNONE:
518         default:
519                 smp->data.type = SMP_T_BOOL;
520                 smp->data.u.sint = 0;
521                 break;
522         }
523         return 1;
524 }
525
526 /* This function check the "argp" builded by another conversion function
527  * is in accord with the expected argp defined by the "mask". The fucntion
528  * returns true or false. It can be adjust the types if there compatibles.
529  *
530  * This function assumes thant the argp argument contains ARGM_NBARGS + 1
531  * entries.
532  */
533 __LJMP int hlua_lua2arg_check(lua_State *L, int first, struct arg *argp,
534                               uint64_t mask, struct proxy *p)
535 {
536         int min_arg;
537         int idx;
538         struct proxy *px;
539         char *sname, *pname;
540
541         idx = 0;
542         min_arg = ARGM(mask);
543         mask >>= ARGM_BITS;
544
545         while (1) {
546
547                 /* Check oversize. */
548                 if (idx >= ARGM_NBARGS && argp[idx].type != ARGT_STOP) {
549                         WILL_LJMP(luaL_argerror(L, first + idx, "Malformed argument mask"));
550                 }
551
552                 /* Check for mandatory arguments. */
553                 if (argp[idx].type == ARGT_STOP) {
554                         if (idx < min_arg) {
555
556                                 /* If miss other argument than the first one, we return an error. */
557                                 if (idx > 0)
558                                         WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
559
560                                 /* If first argument have a certain type, some default values
561                                  * may be used. See the function smp_resolve_args().
562                                  */
563                                 switch (mask & ARGT_MASK) {
564
565                                 case ARGT_FE:
566                                         if (!(p->cap & PR_CAP_FE))
567                                                 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
568                                         argp[idx].data.prx = p;
569                                         argp[idx].type = ARGT_FE;
570                                         argp[idx+1].type = ARGT_STOP;
571                                         break;
572
573                                 case ARGT_BE:
574                                         if (!(p->cap & PR_CAP_BE))
575                                                 WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
576                                         argp[idx].data.prx = p;
577                                         argp[idx].type = ARGT_BE;
578                                         argp[idx+1].type = ARGT_STOP;
579                                         break;
580
581                                 case ARGT_TAB:
582                                         argp[idx].data.prx = p;
583                                         argp[idx].type = ARGT_TAB;
584                                         argp[idx+1].type = ARGT_STOP;
585                                         break;
586
587                                 default:
588                                         WILL_LJMP(luaL_argerror(L, first + idx, "Mandatory argument expected"));
589                                         break;
590                                 }
591                         }
592                         return 0;
593                 }
594
595                 /* Check for exceed the number of requiered argument. */
596                 if ((mask & ARGT_MASK) == ARGT_STOP &&
597                     argp[idx].type != ARGT_STOP) {
598                         WILL_LJMP(luaL_argerror(L, first + idx, "Last argument expected"));
599                 }
600
601                 if ((mask & ARGT_MASK) == ARGT_STOP &&
602                     argp[idx].type == ARGT_STOP) {
603                         return 0;
604                 }
605
606                 /* Convert some argument types. */
607                 switch (mask & ARGT_MASK) {
608                 case ARGT_SINT:
609                         if (argp[idx].type != ARGT_SINT)
610                                 WILL_LJMP(luaL_argerror(L, first + idx, "integer expected"));
611                         argp[idx].type = ARGT_SINT;
612                         break;
613
614                 case ARGT_TIME:
615                         if (argp[idx].type != ARGT_SINT)
616                                 WILL_LJMP(luaL_argerror(L, first + idx, "integer expected"));
617                         argp[idx].type = ARGT_TIME;
618                         break;
619
620                 case ARGT_SIZE:
621                         if (argp[idx].type != ARGT_SINT)
622                                 WILL_LJMP(luaL_argerror(L, first + idx, "integer expected"));
623                         argp[idx].type = ARGT_SIZE;
624                         break;
625
626                 case ARGT_FE:
627                         if (argp[idx].type != ARGT_STR)
628                                 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
629                         memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
630                         trash.str[argp[idx].data.str.len] = 0;
631                         argp[idx].data.prx = proxy_fe_by_name(trash.str);
632                         if (!argp[idx].data.prx)
633                                 WILL_LJMP(luaL_argerror(L, first + idx, "frontend doesn't exist"));
634                         argp[idx].type = ARGT_FE;
635                         break;
636
637                 case ARGT_BE:
638                         if (argp[idx].type != ARGT_STR)
639                                 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
640                         memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
641                         trash.str[argp[idx].data.str.len] = 0;
642                         argp[idx].data.prx = proxy_be_by_name(trash.str);
643                         if (!argp[idx].data.prx)
644                                 WILL_LJMP(luaL_argerror(L, first + idx, "backend doesn't exist"));
645                         argp[idx].type = ARGT_BE;
646                         break;
647
648                 case ARGT_TAB:
649                         if (argp[idx].type != ARGT_STR)
650                                 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
651                         memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
652                         trash.str[argp[idx].data.str.len] = 0;
653                         argp[idx].data.prx = proxy_tbl_by_name(trash.str);
654                         if (!argp[idx].data.prx)
655                                 WILL_LJMP(luaL_argerror(L, first + idx, "table doesn't exist"));
656                         argp[idx].type = ARGT_TAB;
657                         break;
658
659                 case ARGT_SRV:
660                         if (argp[idx].type != ARGT_STR)
661                                 WILL_LJMP(luaL_argerror(L, first + idx, "string expected"));
662                         memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
663                         trash.str[argp[idx].data.str.len] = 0;
664                         sname = strrchr(trash.str, '/');
665                         if (sname) {
666                                 *sname++ = '\0';
667                                 pname = trash.str;
668                                 px = proxy_be_by_name(pname);
669                                 if (!px)
670                                         WILL_LJMP(luaL_argerror(L, first + idx, "backend doesn't exist"));
671                         }
672                         else {
673                                 sname = trash.str;
674                                 px = p;
675                         }
676                         argp[idx].data.srv = findserver(px, sname);
677                         if (!argp[idx].data.srv)
678                                 WILL_LJMP(luaL_argerror(L, first + idx, "server doesn't exist"));
679                         argp[idx].type = ARGT_SRV;
680                         break;
681
682                 case ARGT_IPV4:
683                         memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
684                         trash.str[argp[idx].data.str.len] = 0;
685                         if (inet_pton(AF_INET, trash.str, &argp[idx].data.ipv4))
686                                 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv4 address"));
687                         argp[idx].type = ARGT_IPV4;
688                         break;
689
690                 case ARGT_MSK4:
691                         memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
692                         trash.str[argp[idx].data.str.len] = 0;
693                         if (!str2mask(trash.str, &argp[idx].data.ipv4))
694                                 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv4 mask"));
695                         argp[idx].type = ARGT_MSK4;
696                         break;
697
698                 case ARGT_IPV6:
699                         memcpy(trash.str, argp[idx].data.str.str, argp[idx].data.str.len);
700                         trash.str[argp[idx].data.str.len] = 0;
701                         if (inet_pton(AF_INET6, trash.str, &argp[idx].data.ipv6))
702                                 WILL_LJMP(luaL_argerror(L, first + idx, "invalid IPv6 address"));
703                         argp[idx].type = ARGT_IPV6;
704                         break;
705
706                 case ARGT_MSK6:
707                 case ARGT_MAP:
708                 case ARGT_REG:
709                 case ARGT_USR:
710                         WILL_LJMP(luaL_argerror(L, first + idx, "type not yet supported"));
711                         break;
712                 }
713
714                 /* Check for type of argument. */
715                 if ((mask & ARGT_MASK) != argp[idx].type) {
716                         const char *msg = lua_pushfstring(L, "'%s' expected, got '%s'",
717                                                           arg_type_names[(mask & ARGT_MASK)],
718                                                           arg_type_names[argp[idx].type & ARGT_MASK]);
719                         WILL_LJMP(luaL_argerror(L, first + idx, msg));
720                 }
721
722                 /* Next argument. */
723                 mask >>= ARGT_BITS;
724                 idx++;
725         }
726 }
727
728 /*
729  * The following functions are used to make correspondance between the the
730  * executed lua pointer and the "struct hlua *" that contain the context.
731  *
732  *  - hlua_gethlua : return the hlua context associated with an lua_State.
733  *  - hlua_sethlua : create the association between hlua context and lua_state.
734  */
735 static inline struct hlua *hlua_gethlua(lua_State *L)
736 {
737         struct hlua **hlua = lua_getextraspace(L);
738         return *hlua;
739 }
740 static inline void hlua_sethlua(struct hlua *hlua)
741 {
742         struct hlua **hlua_store = lua_getextraspace(hlua->T);
743         *hlua_store = hlua;
744 }
745
746 /* This function is used to send logs. It try to send on screen (stderr)
747  * and on the default syslog server.
748  */
749 static inline void hlua_sendlog(struct proxy *px, int level, const char *msg)
750 {
751         struct tm tm;
752         char *p;
753
754         /* Cleanup the log message. */
755         p = trash.str;
756         for (; *msg != '\0'; msg++, p++) {
757                 if (p >= trash.str + trash.size - 1) {
758                         /* Break the message if exceed the buffer size. */
759                         *(p-4) = ' ';
760                         *(p-3) = '.';
761                         *(p-2) = '.';
762                         *(p-1) = '.';
763                         break;
764                 }
765                 if (isprint(*msg))
766                         *p = *msg;
767                 else
768                         *p = '.';
769         }
770         *p = '\0';
771
772         send_log(px, level, "%s\n", trash.str);
773         if (!(global.mode & MODE_QUIET) || (global.mode & (MODE_VERBOSE | MODE_STARTING))) {
774                 get_localtime(date.tv_sec, &tm);
775                 fprintf(stderr, "[%s] %03d/%02d%02d%02d (%d) : %s\n",
776                         log_levels[level], tm.tm_yday, tm.tm_hour, tm.tm_min, tm.tm_sec,
777                         (int)getpid(), trash.str);
778                 fflush(stderr);
779         }
780 }
781
782 /* This function just ensure that the yield will be always
783  * returned with a timeout and permit to set some flags
784  */
785 __LJMP void hlua_yieldk(lua_State *L, int nresults, int ctx,
786                         lua_KFunction k, int timeout, unsigned int flags)
787 {
788         struct hlua *hlua = hlua_gethlua(L);
789
790         /* Set the wake timeout. If timeout is required, we set
791          * the expiration time.
792          */
793         hlua->wake_time = timeout;
794
795         hlua->flags |= flags;
796
797         /* Process the yield. */
798         WILL_LJMP(lua_yieldk(L, nresults, ctx, k));
799 }
800
801 /* This function initialises the Lua environment stored in the stream.
802  * It must be called at the start of the stream. This function creates
803  * an LUA coroutine. It can not be use to crete the main LUA context.
804  *
805  * This function is particular. it initialises a new Lua thread. If the
806  * initialisation fails (example: out of memory error), the lua function
807  * throws an error (longjmp).
808  *
809  * This function manipulates two Lua stack: the main and the thread. Only
810  * the main stack can fail. The thread is not manipulated. This function
811  * MUST NOT manipulate the created thread stack state, because is not
812  * proctected agains error throwed by the thread stack.
813  */
814 int hlua_ctx_init(struct hlua *lua, struct task *task)
815 {
816         if (!SET_SAFE_LJMP(gL.T)) {
817                 lua->Tref = LUA_REFNIL;
818                 return 0;
819         }
820         lua->Mref = LUA_REFNIL;
821         lua->flags = 0;
822         LIST_INIT(&lua->com);
823         lua->T = lua_newthread(gL.T);
824         if (!lua->T) {
825                 lua->Tref = LUA_REFNIL;
826                 RESET_SAFE_LJMP(gL.T);
827                 return 0;
828         }
829         hlua_sethlua(lua);
830         lua->Tref = luaL_ref(gL.T, LUA_REGISTRYINDEX);
831         lua->task = task;
832         RESET_SAFE_LJMP(gL.T);
833         return 1;
834 }
835
836 /* Used to destroy the Lua coroutine when the attached stream or task
837  * is destroyed. The destroy also the memory context. The struct "lua"
838  * is not freed.
839  */
840 void hlua_ctx_destroy(struct hlua *lua)
841 {
842         if (!lua)
843                 return;
844
845         if (!lua->T)
846                 goto end;
847
848         /* Purge all the pending signals. */
849         notification_purge(&lua->com);
850
851         if (!SET_SAFE_LJMP(lua->T))
852                 return;
853         luaL_unref(lua->T, LUA_REGISTRYINDEX, lua->Mref);
854         RESET_SAFE_LJMP(lua->T);
855
856         if (!SET_SAFE_LJMP(gL.T))
857                 return;
858         luaL_unref(gL.T, LUA_REGISTRYINDEX, lua->Tref);
859         RESET_SAFE_LJMP(gL.T);
860         /* Forces a garbage collecting process. If the Lua program is finished
861          * without error, we run the GC on the thread pointer. Its freed all
862          * the unused memory.
863          * If the thread is finnish with an error or is currently yielded,
864          * it seems that the GC applied on the thread doesn't clean anything,
865          * so e run the GC on the main thread.
866          * NOTE: maybe this action locks all the Lua threads untiml the en of
867          * the garbage collection.
868          */
869         if (lua->flags & HLUA_MUST_GC) {
870                 if (!SET_SAFE_LJMP(gL.T))
871                         return;
872                 lua_gc(gL.T, LUA_GCCOLLECT, 0);
873                 RESET_SAFE_LJMP(gL.T);
874         }
875
876         lua->T = NULL;
877
878 end:
879         pool_free(pool_head_hlua, lua);
880 }
881
882 /* This function is used to restore the Lua context when a coroutine
883  * fails. This function copy the common memory between old coroutine
884  * and the new coroutine. The old coroutine is destroyed, and its
885  * replaced by the new coroutine.
886  * If the flag "keep_msg" is set, the last entry of the old is assumed
887  * as string error message and it is copied in the new stack.
888  */
889 static int hlua_ctx_renew(struct hlua *lua, int keep_msg)
890 {
891         lua_State *T;
892         int new_ref;
893
894         /* Renew the main LUA stack doesn't have sense. */
895         if (lua == &gL)
896                 return 0;
897
898         /* New Lua coroutine. */
899         T = lua_newthread(gL.T);
900         if (!T)
901                 return 0;
902
903         /* Copy last error message. */
904         if (keep_msg)
905                 lua_xmove(lua->T, T, 1);
906
907         /* Copy data between the coroutines. */
908         lua_rawgeti(lua->T, LUA_REGISTRYINDEX, lua->Mref);
909         lua_xmove(lua->T, T, 1);
910         new_ref = luaL_ref(T, LUA_REGISTRYINDEX); /* Valur poped. */
911
912         /* Destroy old data. */
913         luaL_unref(lua->T, LUA_REGISTRYINDEX, lua->Mref);
914
915         /* The thread is garbage collected by Lua. */
916         luaL_unref(gL.T, LUA_REGISTRYINDEX, lua->Tref);
917
918         /* Fill the struct with the new coroutine values. */
919         lua->Mref = new_ref;
920         lua->T = T;
921         lua->Tref = luaL_ref(gL.T, LUA_REGISTRYINDEX);
922
923         /* Set context. */
924         hlua_sethlua(lua);
925
926         return 1;
927 }
928
929 void hlua_hook(lua_State *L, lua_Debug *ar)
930 {
931         struct hlua *hlua = hlua_gethlua(L);
932
933         /* Lua cannot yield when its returning from a function,
934          * so, we can fix the interrupt hook to 1 instruction,
935          * expecting that the function is finnished.
936          */
937         if (lua_gethookmask(L) & LUA_MASKRET) {
938                 lua_sethook(hlua->T, hlua_hook, LUA_MASKCOUNT, 1);
939                 return;
940         }
941
942         /* restore the interrupt condition. */
943         lua_sethook(hlua->T, hlua_hook, LUA_MASKCOUNT, hlua_nb_instruction);
944
945         /* If we interrupt the Lua processing in yieldable state, we yield.
946          * If the state is not yieldable, trying yield causes an error.
947          */
948         if (lua_isyieldable(L))
949                 WILL_LJMP(hlua_yieldk(L, 0, 0, NULL, TICK_ETERNITY, HLUA_CTRLYIELD));
950
951         /* If we cannot yield, update the clock and check the timeout. */
952         tv_update_date(0, 1);
953         hlua->run_time += now_ms - hlua->start_time;
954         if (hlua->max_time && hlua->run_time >= hlua->max_time) {
955                 lua_pushfstring(L, "execution timeout");
956                 WILL_LJMP(lua_error(L));
957         }
958
959         /* Update the start time. */
960         hlua->start_time = now_ms;
961
962         /* Try to interrupt the process at the end of the current
963          * unyieldable function.
964          */
965         lua_sethook(hlua->T, hlua_hook, LUA_MASKRET|LUA_MASKCOUNT, hlua_nb_instruction);
966 }
967
968 /* This function start or resumes the Lua stack execution. If the flag
969  * "yield_allowed" if no set and the  LUA stack execution returns a yield
970  * The function return an error.
971  *
972  * The function can returns 4 values:
973  *  - HLUA_E_OK     : The execution is terminated without any errors.
974  *  - HLUA_E_AGAIN  : The execution must continue at the next associated
975  *                    task wakeup.
976  *  - HLUA_E_ERRMSG : An error has occured, an error message is set in
977  *                    the top of the stack.
978  *  - HLUA_E_ERR    : An error has occured without error message.
979  *
980  * If an error occured, the stack is renewed and it is ready to run new
981  * LUA code.
982  */
983 static enum hlua_exec hlua_ctx_resume(struct hlua *lua, int yield_allowed)
984 {
985         int ret;
986         const char *msg;
987
988         /* Initialise run time counter. */
989         if (!HLUA_IS_RUNNING(lua))
990                 lua->run_time = 0;
991
992         /* Lock the whole Lua execution. This lock must be before the
993          * label "resume_execution".
994          */
995         HA_SPIN_LOCK(LUA_LOCK, &hlua_global_lock);
996
997 resume_execution:
998
999         /* This hook interrupts the Lua processing each 'hlua_nb_instruction'
1000          * instructions. it is used for preventing infinite loops.
1001          */
1002         lua_sethook(lua->T, hlua_hook, LUA_MASKCOUNT, hlua_nb_instruction);
1003
1004         /* Remove all flags except the running flags. */
1005         HLUA_SET_RUN(lua);
1006         HLUA_CLR_CTRLYIELD(lua);
1007         HLUA_CLR_WAKERESWR(lua);
1008         HLUA_CLR_WAKEREQWR(lua);
1009
1010         /* Update the start time. */
1011         lua->start_time = now_ms;
1012
1013         /* Call the function. */
1014         ret = lua_resume(lua->T, gL.T, lua->nargs);
1015         switch (ret) {
1016
1017         case LUA_OK:
1018                 ret = HLUA_E_OK;
1019                 break;
1020
1021         case LUA_YIELD:
1022                 /* Check if the execution timeout is expired. It it is the case, we
1023                  * break the Lua execution.
1024                  */
1025                 tv_update_date(0, 1);
1026                 lua->run_time += now_ms - lua->start_time;
1027                 if (lua->max_time && lua->run_time > lua->max_time) {
1028                         lua_settop(lua->T, 0); /* Empty the stack. */
1029                         if (!lua_checkstack(lua->T, 1)) {
1030                                 ret = HLUA_E_ERR;
1031                                 break;
1032                         }
1033                         lua_pushfstring(lua->T, "execution timeout");
1034                         ret = HLUA_E_ERRMSG;
1035                         break;
1036                 }
1037                 /* Process the forced yield. if the general yield is not allowed or
1038                  * if no task were associated this the current Lua execution
1039                  * coroutine, we resume the execution. Else we want to return in the
1040                  * scheduler and we want to be waked up again, to continue the
1041                  * current Lua execution. So we schedule our own task.
1042                  */
1043                 if (HLUA_IS_CTRLYIELDING(lua)) {
1044                         if (!yield_allowed || !lua->task)
1045                                 goto resume_execution;
1046                         task_wakeup(lua->task, TASK_WOKEN_MSG);
1047                 }
1048                 if (!yield_allowed) {
1049                         lua_settop(lua->T, 0); /* Empty the stack. */
1050                         if (!lua_checkstack(lua->T, 1)) {
1051                                 ret = HLUA_E_ERR;
1052                                 break;
1053                         }
1054                         lua_pushfstring(lua->T, "yield not allowed");
1055                         ret = HLUA_E_ERRMSG;
1056                         break;
1057                 }
1058                 ret = HLUA_E_AGAIN;
1059                 break;
1060
1061         case LUA_ERRRUN:
1062
1063                 /* Special exit case. The traditionnal exit is returned as an error
1064                  * because the errors ares the only one mean to return immediately
1065                  * from and lua execution.
1066                  */
1067                 if (lua->flags & HLUA_EXIT) {
1068                         ret = HLUA_E_OK;
1069                         hlua_ctx_renew(lua, 0);
1070                         break;
1071                 }
1072
1073                 lua->wake_time = TICK_ETERNITY;
1074                 if (!lua_checkstack(lua->T, 1)) {
1075                         ret = HLUA_E_ERR;
1076                         break;
1077                 }
1078                 msg = lua_tostring(lua->T, -1);
1079                 lua_settop(lua->T, 0); /* Empty the stack. */
1080                 lua_pop(lua->T, 1);
1081                 if (msg)
1082                         lua_pushfstring(lua->T, "runtime error: %s", msg);
1083                 else
1084                         lua_pushfstring(lua->T, "unknown runtime error");
1085                 ret = HLUA_E_ERRMSG;
1086                 break;
1087
1088         case LUA_ERRMEM:
1089                 lua->wake_time = TICK_ETERNITY;
1090                 lua_settop(lua->T, 0); /* Empty the stack. */
1091                 if (!lua_checkstack(lua->T, 1)) {
1092                         ret = HLUA_E_ERR;
1093                         break;
1094                 }
1095                 lua_pushfstring(lua->T, "out of memory error");
1096                 ret = HLUA_E_ERRMSG;
1097                 break;
1098
1099         case LUA_ERRERR:
1100                 lua->wake_time = TICK_ETERNITY;
1101                 if (!lua_checkstack(lua->T, 1)) {
1102                         ret = HLUA_E_ERR;
1103                         break;
1104                 }
1105                 msg = lua_tostring(lua->T, -1);
1106                 lua_settop(lua->T, 0); /* Empty the stack. */
1107                 lua_pop(lua->T, 1);
1108                 if (msg)
1109                         lua_pushfstring(lua->T, "message handler error: %s", msg);
1110                 else
1111                         lua_pushfstring(lua->T, "message handler error");
1112                 ret = HLUA_E_ERRMSG;
1113                 break;
1114
1115         default:
1116                 lua->wake_time = TICK_ETERNITY;
1117                 lua_settop(lua->T, 0); /* Empty the stack. */
1118                 if (!lua_checkstack(lua->T, 1)) {
1119                         ret = HLUA_E_ERR;
1120                         break;
1121                 }
1122                 lua_pushfstring(lua->T, "unknonwn error");
1123                 ret = HLUA_E_ERRMSG;
1124                 break;
1125         }
1126
1127         /* This GC permits to destroy some object when a Lua timeout strikes. */
1128         if (lua->flags & HLUA_MUST_GC &&
1129             ret != HLUA_E_AGAIN)
1130                 lua_gc(lua->T, LUA_GCCOLLECT, 0);
1131
1132         switch (ret) {
1133         case HLUA_E_AGAIN:
1134                 break;
1135
1136         case HLUA_E_ERRMSG:
1137                 notification_purge(&lua->com);
1138                 hlua_ctx_renew(lua, 1);
1139                 HLUA_CLR_RUN(lua);
1140                 break;
1141
1142         case HLUA_E_ERR:
1143                 HLUA_CLR_RUN(lua);
1144                 notification_purge(&lua->com);
1145                 hlua_ctx_renew(lua, 0);
1146                 break;
1147
1148         case HLUA_E_OK:
1149                 HLUA_CLR_RUN(lua);
1150                 notification_purge(&lua->com);
1151                 break;
1152         }
1153
1154         /* This is the main exit point, remove the Lua lock. */
1155         HA_SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock);
1156
1157         return ret;
1158 }
1159
1160 /* This function exit the current code. */
1161 __LJMP static int hlua_done(lua_State *L)
1162 {
1163         struct hlua *hlua = hlua_gethlua(L);
1164
1165         hlua->flags |= HLUA_EXIT;
1166         WILL_LJMP(lua_error(L));
1167
1168         return 0;
1169 }
1170
1171 /* This function is an LUA binding. It provides a function
1172  * for deleting ACL from a referenced ACL file.
1173  */
1174 __LJMP static int hlua_del_acl(lua_State *L)
1175 {
1176         const char *name;
1177         const char *key;
1178         struct pat_ref *ref;
1179
1180         MAY_LJMP(check_args(L, 2, "del_acl"));
1181
1182         name = MAY_LJMP(luaL_checkstring(L, 1));
1183         key = MAY_LJMP(luaL_checkstring(L, 2));
1184
1185         ref = pat_ref_lookup(name);
1186         if (!ref)
1187                 WILL_LJMP(luaL_error(L, "'del_acl': unknown acl file '%s'", name));
1188
1189         pat_ref_delete(ref, key);
1190         return 0;
1191 }
1192
1193 /* This function is an LUA binding. It provides a function
1194  * for deleting map entry from a referenced map file.
1195  */
1196 static int hlua_del_map(lua_State *L)
1197 {
1198         const char *name;
1199         const char *key;
1200         struct pat_ref *ref;
1201
1202         MAY_LJMP(check_args(L, 2, "del_map"));
1203
1204         name = MAY_LJMP(luaL_checkstring(L, 1));
1205         key = MAY_LJMP(luaL_checkstring(L, 2));
1206
1207         ref = pat_ref_lookup(name);
1208         if (!ref)
1209                 WILL_LJMP(luaL_error(L, "'del_map': unknown acl file '%s'", name));
1210
1211         pat_ref_delete(ref, key);
1212         return 0;
1213 }
1214
1215 /* This function is an LUA binding. It provides a function
1216  * for adding ACL pattern from a referenced ACL file.
1217  */
1218 static int hlua_add_acl(lua_State *L)
1219 {
1220         const char *name;
1221         const char *key;
1222         struct pat_ref *ref;
1223
1224         MAY_LJMP(check_args(L, 2, "add_acl"));
1225
1226         name = MAY_LJMP(luaL_checkstring(L, 1));
1227         key = MAY_LJMP(luaL_checkstring(L, 2));
1228
1229         ref = pat_ref_lookup(name);
1230         if (!ref)
1231                 WILL_LJMP(luaL_error(L, "'add_acl': unknown acl file '%s'", name));
1232
1233         if (pat_ref_find_elt(ref, key) == NULL)
1234                 pat_ref_add(ref, key, NULL, NULL);
1235         return 0;
1236 }
1237
1238 /* This function is an LUA binding. It provides a function
1239  * for setting map pattern and sample from a referenced map
1240  * file.
1241  */
1242 static int hlua_set_map(lua_State *L)
1243 {
1244         const char *name;
1245         const char *key;
1246         const char *value;
1247         struct pat_ref *ref;
1248
1249         MAY_LJMP(check_args(L, 3, "set_map"));
1250
1251         name = MAY_LJMP(luaL_checkstring(L, 1));
1252         key = MAY_LJMP(luaL_checkstring(L, 2));
1253         value = MAY_LJMP(luaL_checkstring(L, 3));
1254
1255         ref = pat_ref_lookup(name);
1256         if (!ref)
1257                 WILL_LJMP(luaL_error(L, "'set_map': unknown map file '%s'", name));
1258
1259         if (pat_ref_find_elt(ref, key) != NULL)
1260                 pat_ref_set(ref, key, value, NULL);
1261         else
1262                 pat_ref_add(ref, key, value, NULL);
1263         return 0;
1264 }
1265
1266 /* A class is a lot of memory that contain data. This data can be a table,
1267  * an integer or user data. This data is associated with a metatable. This
1268  * metatable have an original version registred in the global context with
1269  * the name of the object (_G[<name>] = <metable> ).
1270  *
1271  * A metable is a table that modify the standard behavior of a standard
1272  * access to the associated data. The entries of this new metatable are
1273  * defined as is:
1274  *
1275  * http://lua-users.org/wiki/MetatableEvents
1276  *
1277  *    __index
1278  *
1279  * we access an absent field in a table, the result is nil. This is
1280  * true, but it is not the whole truth. Actually, such access triggers
1281  * the interpreter to look for an __index metamethod: If there is no
1282  * such method, as usually happens, then the access results in nil;
1283  * otherwise, the metamethod will provide the result.
1284  *
1285  * Control 'prototype' inheritance. When accessing "myTable[key]" and
1286  * the key does not appear in the table, but the metatable has an __index
1287  * property:
1288  *
1289  * - if the value is a function, the function is called, passing in the
1290  *   table and the key; the return value of that function is returned as
1291  *   the result.
1292  *
1293  * - if the value is another table, the value of the key in that table is
1294  *   asked for and returned (and if it doesn't exist in that table, but that
1295  *   table's metatable has an __index property, then it continues on up)
1296  *
1297  * - Use "rawget(myTable,key)" to skip this metamethod.
1298  *
1299  * http://www.lua.org/pil/13.4.1.html
1300  *
1301  *    __newindex
1302  *
1303  * Like __index, but control property assignment.
1304  *
1305  *    __mode - Control weak references. A string value with one or both
1306  *             of the characters 'k' and 'v' which specifies that the the
1307  *             keys and/or values in the table are weak references.
1308  *
1309  *    __call - Treat a table like a function. When a table is followed by
1310  *             parenthesis such as "myTable( 'foo' )" and the metatable has
1311  *             a __call key pointing to a function, that function is invoked
1312  *             (passing any specified arguments) and the return value is
1313  *             returned.
1314  *
1315  *    __metatable - Hide the metatable. When "getmetatable( myTable )" is
1316  *                  called, if the metatable for myTable has a __metatable
1317  *                  key, the value of that key is returned instead of the
1318  *                  actual metatable.
1319  *
1320  *    __tostring - Control string representation. When the builtin
1321  *                 "tostring( myTable )" function is called, if the metatable
1322  *                 for myTable has a __tostring property set to a function,
1323  *                 that function is invoked (passing myTable to it) and the
1324  *                 return value is used as the string representation.
1325  *
1326  *    __len - Control table length. When the table length is requested using
1327  *            the length operator ( '#' ), if the metatable for myTable has
1328  *            a __len key pointing to a function, that function is invoked
1329  *            (passing myTable to it) and the return value used as the value
1330  *            of "#myTable".
1331  *
1332  *    __gc - Userdata finalizer code. When userdata is set to be garbage
1333  *           collected, if the metatable has a __gc field pointing to a
1334  *           function, that function is first invoked, passing the userdata
1335  *           to it. The __gc metamethod is not called for tables.
1336  *           (See http://lua-users.org/lists/lua-l/2006-11/msg00508.html)
1337  *
1338  * Special metamethods for redefining standard operators:
1339  * http://www.lua.org/pil/13.1.html
1340  *
1341  *    __add    "+"
1342  *    __sub    "-"
1343  *    __mul    "*"
1344  *    __div    "/"
1345  *    __unm    "!"
1346  *    __pow    "^"
1347  *    __concat ".."
1348  *
1349  * Special methods for redfining standar relations
1350  * http://www.lua.org/pil/13.2.html
1351  *
1352  *    __eq "=="
1353  *    __lt "<"
1354  *    __le "<="
1355  */
1356
1357 /*
1358  *
1359  *
1360  * Class Map
1361  *
1362  *
1363  */
1364
1365 /* Returns a struct hlua_map if the stack entry "ud" is
1366  * a class session, otherwise it throws an error.
1367  */
1368 __LJMP static struct map_descriptor *hlua_checkmap(lua_State *L, int ud)
1369 {
1370         return MAY_LJMP(hlua_checkudata(L, ud, class_map_ref));
1371 }
1372
1373 /* This function is the map constructor. It don't need
1374  * the class Map object. It creates and return a new Map
1375  * object. It must be called only during "body" or "init"
1376  * context because it process some filesystem accesses.
1377  */
1378 __LJMP static int hlua_map_new(struct lua_State *L)
1379 {
1380         const char *fn;
1381         int match = PAT_MATCH_STR;
1382         struct sample_conv conv;
1383         const char *file = "";
1384         int line = 0;
1385         lua_Debug ar;
1386         char *err = NULL;
1387         struct arg args[2];
1388
1389         if (lua_gettop(L) < 1 || lua_gettop(L) > 2)
1390                 WILL_LJMP(luaL_error(L, "'new' needs at least 1 argument."));
1391
1392         fn = MAY_LJMP(luaL_checkstring(L, 1));
1393
1394         if (lua_gettop(L) >= 2) {
1395                 match = MAY_LJMP(luaL_checkinteger(L, 2));
1396                 if (match < 0 || match >= PAT_MATCH_NUM)
1397                         WILL_LJMP(luaL_error(L, "'new' needs a valid match method."));
1398         }
1399
1400         /* Get Lua filename and line number. */
1401         if (lua_getstack(L, 1, &ar)) {  /* check function at level */
1402                 lua_getinfo(L, "Sl", &ar);  /* get info about it */
1403                 if (ar.currentline > 0) {  /* is there info? */
1404                         file = ar.short_src;
1405                         line = ar.currentline;
1406                 }
1407         }
1408
1409         /* fill fake sample_conv struct. */
1410         conv.kw = ""; /* unused. */
1411         conv.process = NULL; /* unused. */
1412         conv.arg_mask = 0; /* unused. */
1413         conv.val_args = NULL; /* unused. */
1414         conv.out_type = SMP_T_STR;
1415         conv.private = (void *)(long)match;
1416         switch (match) {
1417         case PAT_MATCH_STR: conv.in_type = SMP_T_STR;  break;
1418         case PAT_MATCH_BEG: conv.in_type = SMP_T_STR;  break;
1419         case PAT_MATCH_SUB: conv.in_type = SMP_T_STR;  break;
1420         case PAT_MATCH_DIR: conv.in_type = SMP_T_STR;  break;
1421         case PAT_MATCH_DOM: conv.in_type = SMP_T_STR;  break;
1422         case PAT_MATCH_END: conv.in_type = SMP_T_STR;  break;
1423         case PAT_MATCH_REG: conv.in_type = SMP_T_STR;  break;
1424         case PAT_MATCH_INT: conv.in_type = SMP_T_SINT; break;
1425         case PAT_MATCH_IP:  conv.in_type = SMP_T_ADDR; break;
1426         default:
1427                 WILL_LJMP(luaL_error(L, "'new' doesn't support this match mode."));
1428         }
1429
1430         /* fill fake args. */
1431         args[0].type = ARGT_STR;
1432         args[0].data.str.str = (char *)fn;
1433         args[1].type = ARGT_STOP;
1434
1435         /* load the map. */
1436         if (!sample_load_map(args, &conv, file, line, &err)) {
1437                 /* error case: we cant use luaL_error because we must
1438                  * free the err variable.
1439                  */
1440                 luaL_where(L, 1);
1441                 lua_pushfstring(L, "'new': %s.", err);
1442                 lua_concat(L, 2);
1443                 free(err);
1444                 WILL_LJMP(lua_error(L));
1445         }
1446
1447         /* create the lua object. */
1448         lua_newtable(L);
1449         lua_pushlightuserdata(L, args[0].data.map);
1450         lua_rawseti(L, -2, 0);
1451
1452         /* Pop a class Map metatable and affect it to the userdata. */
1453         lua_rawgeti(L, LUA_REGISTRYINDEX, class_map_ref);
1454         lua_setmetatable(L, -2);
1455
1456
1457         return 1;
1458 }
1459
1460 __LJMP static inline int _hlua_map_lookup(struct lua_State *L, int str)
1461 {
1462         struct map_descriptor *desc;
1463         struct pattern *pat;
1464         struct sample smp;
1465
1466         MAY_LJMP(check_args(L, 2, "lookup"));
1467         desc = MAY_LJMP(hlua_checkmap(L, 1));
1468         if (desc->pat.expect_type == SMP_T_SINT) {
1469                 smp.data.type = SMP_T_SINT;
1470                 smp.data.u.sint = MAY_LJMP(luaL_checkinteger(L, 2));
1471         }
1472         else {
1473                 smp.data.type = SMP_T_STR;
1474                 smp.flags = SMP_F_CONST;
1475                 smp.data.u.str.str = (char *)MAY_LJMP(luaL_checklstring(L, 2, (size_t *)&smp.data.u.str.len));
1476         }
1477
1478         pat = pattern_exec_match(&desc->pat, &smp, 1);
1479         if (!pat || !pat->data) {
1480                 if (str)
1481                         lua_pushstring(L, "");
1482                 else
1483                         lua_pushnil(L);
1484                 return 1;
1485         }
1486
1487         /* The Lua pattern must return a string, so we can't check the returned type */
1488         lua_pushlstring(L, pat->data->u.str.str, pat->data->u.str.len);
1489         return 1;
1490 }
1491
1492 __LJMP static int hlua_map_lookup(struct lua_State *L)
1493 {
1494         return _hlua_map_lookup(L, 0);
1495 }
1496
1497 __LJMP static int hlua_map_slookup(struct lua_State *L)
1498 {
1499         return _hlua_map_lookup(L, 1);
1500 }
1501
1502 /*
1503  *
1504  *
1505  * Class Socket
1506  *
1507  *
1508  */
1509
1510 __LJMP static struct hlua_socket *hlua_checksocket(lua_State *L, int ud)
1511 {
1512         return MAY_LJMP(hlua_checkudata(L, ud, class_socket_ref));
1513 }
1514
1515 /* This function is the handler called for each I/O on the established
1516  * connection. It is used for notify space avalaible to send or data
1517  * received.
1518  */
1519 static void hlua_socket_handler(struct appctx *appctx)
1520 {
1521         struct stream_interface *si = appctx->owner;
1522         struct connection *c = cs_conn(objt_cs(si_opposite(si)->end));
1523
1524         if (appctx->ctx.hlua_cosocket.die) {
1525                 si_shutw(si);
1526                 si_shutr(si);
1527                 si_ic(si)->flags |= CF_READ_NULL;
1528                 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1529                 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
1530                 stream_shutdown(si_strm(si), SF_ERR_KILLED);
1531         }
1532
1533         /* If the connection object is not avalaible, close all the
1534          * streams and wakeup everithing waiting for.
1535          */
1536         if (!c) {
1537                 si_shutw(si);
1538                 si_shutr(si);
1539                 si_ic(si)->flags |= CF_READ_NULL;
1540                 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1541                 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
1542                 return;
1543         }
1544
1545         /* If we cant write, wakeup the pending write signals. */
1546         if (channel_output_closed(si_ic(si)))
1547                 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
1548
1549         /* If we cant read, wakeup the pending read signals. */
1550         if (channel_input_closed(si_oc(si)))
1551                 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1552
1553         /* if the connection is not estabkished, inform the stream that we want
1554          * to be notified whenever the connection completes.
1555          */
1556         if (!(c->flags & CO_FL_CONNECTED)) {
1557                 si_applet_cant_get(si);
1558                 si_applet_cant_put(si);
1559                 return;
1560         }
1561
1562         /* This function is called after the connect. */
1563         appctx->ctx.hlua_cosocket.connected = 1;
1564
1565         /* Wake the tasks which wants to write if the buffer have avalaible space. */
1566         if (channel_may_recv(si_ic(si)))
1567                 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
1568
1569         /* Wake the tasks which wants to read if the buffer contains data. */
1570         if (!channel_is_empty(si_oc(si)))
1571                 notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1572 }
1573
1574 /* This function is called when the "struct stream" is destroyed.
1575  * Remove the link from the object to this stream.
1576  * Wake all the pending signals.
1577  */
1578 static void hlua_socket_release(struct appctx *appctx)
1579 {
1580         struct xref *peer;
1581
1582         /* Remove my link in the original object. */
1583         peer = xref_get_peer_and_lock(&appctx->ctx.hlua_cosocket.xref);
1584         if (peer)
1585                 xref_disconnect(&appctx->ctx.hlua_cosocket.xref, peer);
1586
1587         /* Wake all the task waiting for me. */
1588         notification_wake(&appctx->ctx.hlua_cosocket.wake_on_read);
1589         notification_wake(&appctx->ctx.hlua_cosocket.wake_on_write);
1590 }
1591
1592 /* If the garbage collectio of the object is launch, nobody
1593  * uses this object. If the stream does not exists, just quit.
1594  * Send the shutdown signal to the stream. In some cases,
1595  * pending signal can rest in the read and write lists. destroy
1596  * it.
1597  */
1598 __LJMP static int hlua_socket_gc(lua_State *L)
1599 {
1600         struct hlua_socket *socket;
1601         struct appctx *appctx;
1602         struct xref *peer;
1603
1604         MAY_LJMP(check_args(L, 1, "__gc"));
1605
1606         socket = MAY_LJMP(hlua_checksocket(L, 1));
1607         peer = xref_get_peer_and_lock(&socket->xref);
1608         if (!peer)
1609                 return 0;
1610         appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
1611
1612         /* Set the flag which destroy the session. */
1613         appctx->ctx.hlua_cosocket.die = 1;
1614         appctx_wakeup(appctx);
1615
1616         /* Remove all reference between the Lua stack and the coroutine stream. */
1617         xref_disconnect(&socket->xref, peer);
1618         return 0;
1619 }
1620
1621 /* The close function send shutdown signal and break the
1622  * links between the stream and the object.
1623  */
1624 __LJMP static int hlua_socket_close(lua_State *L)
1625 {
1626         struct hlua_socket *socket;
1627         struct appctx *appctx;
1628         struct xref *peer;
1629
1630         MAY_LJMP(check_args(L, 1, "close"));
1631
1632         socket = MAY_LJMP(hlua_checksocket(L, 1));
1633
1634         /* Check if we run on the same thread than the xreator thread.
1635          * We cannot access to the socket if the thread is different.
1636          */
1637         if (socket->tid != tid)
1638                 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
1639
1640         peer = xref_get_peer_and_lock(&socket->xref);
1641         if (!peer)
1642                 return 0;
1643         appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
1644
1645         /* Set the flag which destroy the session. */
1646         appctx->ctx.hlua_cosocket.die = 1;
1647         appctx_wakeup(appctx);
1648
1649         /* Remove all reference between the Lua stack and the coroutine stream. */
1650         xref_disconnect(&socket->xref, peer);
1651         return 0;
1652 }
1653
1654 /* This Lua function assumes that the stack contain three parameters.
1655  *  1 - USERDATA containing a struct socket
1656  *  2 - INTEGER with values of the macro defined below
1657  *      If the integer is -1, we must read at most one line.
1658  *      If the integer is -2, we ust read all the data until the
1659  *      end of the stream.
1660  *      If the integer is positive value, we must read a number of
1661  *      bytes corresponding to this value.
1662  */
1663 #define HLSR_READ_LINE (-1)
1664 #define HLSR_READ_ALL (-2)
1665 __LJMP static int hlua_socket_receive_yield(struct lua_State *L, int status, lua_KContext ctx)
1666 {
1667         struct hlua_socket *socket = MAY_LJMP(hlua_checksocket(L, 1));
1668         int wanted = lua_tointeger(L, 2);
1669         struct hlua *hlua = hlua_gethlua(L);
1670         struct appctx *appctx;
1671         int len;
1672         int nblk;
1673         char *blk1;
1674         int len1;
1675         char *blk2;
1676         int len2;
1677         int skip_at_end = 0;
1678         struct channel *oc;
1679         struct stream_interface *si;
1680         struct stream *s;
1681         struct xref *peer;
1682
1683         /* Check if this lua stack is schedulable. */
1684         if (!hlua || !hlua->task)
1685                 WILL_LJMP(luaL_error(L, "The 'receive' function is only allowed in "
1686                                       "'frontend', 'backend' or 'task'"));
1687
1688         /* Check if we run on the same thread than the xreator thread.
1689          * We cannot access to the socket if the thread is different.
1690          */
1691         if (socket->tid != tid)
1692                 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
1693
1694         /* check for connection break. If some data where read, return it. */
1695         peer = xref_get_peer_and_lock(&socket->xref);
1696         if (!peer)
1697                 goto no_peer;
1698         appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
1699         si = appctx->owner;
1700         s = si_strm(si);
1701
1702         oc = &s->res;
1703         if (wanted == HLSR_READ_LINE) {
1704                 /* Read line. */
1705                 nblk = co_getline_nc(oc, &blk1, &len1, &blk2, &len2);
1706                 if (nblk < 0) /* Connection close. */
1707                         goto connection_closed;
1708                 if (nblk == 0) /* No data avalaible. */
1709                         goto connection_empty;
1710
1711                 /* remove final \r\n. */
1712                 if (nblk == 1) {
1713                         if (blk1[len1-1] == '\n') {
1714                                 len1--;
1715                                 skip_at_end++;
1716                                 if (blk1[len1-1] == '\r') {
1717                                         len1--;
1718                                         skip_at_end++;
1719                                 }
1720                         }
1721                 }
1722                 else {
1723                         if (blk2[len2-1] == '\n') {
1724                                 len2--;
1725                                 skip_at_end++;
1726                                 if (blk2[len2-1] == '\r') {
1727                                         len2--;
1728                                         skip_at_end++;
1729                                 }
1730                         }
1731                 }
1732         }
1733
1734         else if (wanted == HLSR_READ_ALL) {
1735                 /* Read all the available data. */
1736                 nblk = co_getblk_nc(oc, &blk1, &len1, &blk2, &len2);
1737                 if (nblk < 0) /* Connection close. */
1738                         goto connection_closed;
1739                 if (nblk == 0) /* No data avalaible. */
1740                         goto connection_empty;
1741         }
1742
1743         else {
1744                 /* Read a block of data. */
1745                 nblk = co_getblk_nc(oc, &blk1, &len1, &blk2, &len2);
1746                 if (nblk < 0) /* Connection close. */
1747                         goto connection_closed;
1748                 if (nblk == 0) /* No data avalaible. */
1749                         goto connection_empty;
1750
1751                 if (len1 > wanted) {
1752                         nblk = 1;
1753                         len1 = wanted;
1754                 } if (nblk == 2 && len1 + len2 > wanted)
1755                         len2 = wanted - len1;
1756         }
1757
1758         len = len1;
1759
1760         luaL_addlstring(&socket->b, blk1, len1);
1761         if (nblk == 2) {
1762                 len += len2;
1763                 luaL_addlstring(&socket->b, blk2, len2);
1764         }
1765
1766         /* Consume data. */
1767         co_skip(oc, len + skip_at_end);
1768
1769         /* Don't wait anything. */
1770         stream_int_notify(&s->si[0]);
1771         stream_int_update_applet(&s->si[0]);
1772
1773         /* If the pattern reclaim to read all the data
1774          * in the connection, got out.
1775          */
1776         if (wanted == HLSR_READ_ALL)
1777                 goto connection_empty;
1778         else if (wanted >= 0 && len < wanted)
1779                 goto connection_empty;
1780
1781         /* Return result. */
1782         luaL_pushresult(&socket->b);
1783         xref_unlock(&socket->xref, peer);
1784         return 1;
1785
1786 connection_closed:
1787
1788         xref_unlock(&socket->xref, peer);
1789
1790 no_peer:
1791
1792         /* If the buffer containds data. */
1793         if (socket->b.n > 0) {
1794                 luaL_pushresult(&socket->b);
1795                 return 1;
1796         }
1797         lua_pushnil(L);
1798         lua_pushstring(L, "connection closed.");
1799         return 2;
1800
1801 connection_empty:
1802
1803         appctx = objt_appctx(s->si[0].end);
1804         if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_read, hlua->task)) {
1805                 xref_unlock(&socket->xref, peer);
1806                 WILL_LJMP(luaL_error(L, "out of memory"));
1807         }
1808         xref_unlock(&socket->xref, peer);
1809         WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_receive_yield, TICK_ETERNITY, 0));
1810         return 0;
1811 }
1812
1813 /* This Lua function gets two parameters. The first one can be string
1814  * or a number. If the string is "*l", the user requires one line. If
1815  * the string is "*a", the user requires all the contents of the stream.
1816  * If the value is a number, the user require a number of bytes equal
1817  * to the value. The default value is "*l" (a line).
1818  *
1819  * This parameter with a variable type is converted in integer. This
1820  * integer takes this values:
1821  *  -1 : read a line
1822  *  -2 : read all the stream
1823  *  >0 : amount of bytes.
1824  *
1825  * The second parameter is optional. It contains a string that must be
1826  * concatenated with the read data.
1827  */
1828 __LJMP static int hlua_socket_receive(struct lua_State *L)
1829 {
1830         int wanted = HLSR_READ_LINE;
1831         const char *pattern;
1832         int type;
1833         char *error;
1834         size_t len;
1835         struct hlua_socket *socket;
1836
1837         if (lua_gettop(L) < 1 || lua_gettop(L) > 3)
1838                 WILL_LJMP(luaL_error(L, "The 'receive' function requires between 1 and 3 arguments."));
1839
1840         socket = MAY_LJMP(hlua_checksocket(L, 1));
1841
1842         /* Check if we run on the same thread than the xreator thread.
1843          * We cannot access to the socket if the thread is different.
1844          */
1845         if (socket->tid != tid)
1846                 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
1847
1848         /* check for pattern. */
1849         if (lua_gettop(L) >= 2) {
1850                 type = lua_type(L, 2);
1851                 if (type == LUA_TSTRING) {
1852                         pattern = lua_tostring(L, 2);
1853                         if (strcmp(pattern, "*a") == 0)
1854                                 wanted = HLSR_READ_ALL;
1855                         else if (strcmp(pattern, "*l") == 0)
1856                                 wanted = HLSR_READ_LINE;
1857                         else {
1858                                 wanted = strtoll(pattern, &error, 10);
1859                                 if (*error != '\0')
1860                                         WILL_LJMP(luaL_error(L, "Unsupported pattern."));
1861                         }
1862                 }
1863                 else if (type == LUA_TNUMBER) {
1864                         wanted = lua_tointeger(L, 2);
1865                         if (wanted < 0)
1866                                 WILL_LJMP(luaL_error(L, "Unsupported size."));
1867                 }
1868         }
1869
1870         /* Set pattern. */
1871         lua_pushinteger(L, wanted);
1872
1873         /* Check if we would replace the top by itself. */
1874         if (lua_gettop(L) != 2)
1875                 lua_replace(L, 2);
1876
1877         /* init buffer, and fill it with prefix. */
1878         luaL_buffinit(L, &socket->b);
1879
1880         /* Check prefix. */
1881         if (lua_gettop(L) >= 3) {
1882                 if (lua_type(L, 3) != LUA_TSTRING)
1883                         WILL_LJMP(luaL_error(L, "Expect a 'string' for the prefix"));
1884                 pattern = lua_tolstring(L, 3, &len);
1885                 luaL_addlstring(&socket->b, pattern, len);
1886         }
1887
1888         return __LJMP(hlua_socket_receive_yield(L, 0, 0));
1889 }
1890
1891 /* Write the Lua input string in the output buffer.
1892  * This fucntion returns a yield if no space are available.
1893  */
1894 static int hlua_socket_write_yield(struct lua_State *L,int status, lua_KContext ctx)
1895 {
1896         struct hlua_socket *socket;
1897         struct hlua *hlua = hlua_gethlua(L);
1898         struct appctx *appctx;
1899         size_t buf_len;
1900         const char *buf;
1901         int len;
1902         int send_len;
1903         int sent;
1904         struct xref *peer;
1905         struct stream_interface *si;
1906         struct stream *s;
1907
1908         /* Check if this lua stack is schedulable. */
1909         if (!hlua || !hlua->task)
1910                 WILL_LJMP(luaL_error(L, "The 'write' function is only allowed in "
1911                                       "'frontend', 'backend' or 'task'"));
1912
1913         /* Get object */
1914         socket = MAY_LJMP(hlua_checksocket(L, 1));
1915         buf = MAY_LJMP(luaL_checklstring(L, 2, &buf_len));
1916         sent = MAY_LJMP(luaL_checkinteger(L, 3));
1917
1918         /* Check if we run on the same thread than the xreator thread.
1919          * We cannot access to the socket if the thread is different.
1920          */
1921         if (socket->tid != tid)
1922                 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
1923
1924         /* check for connection break. If some data where read, return it. */
1925         peer = xref_get_peer_and_lock(&socket->xref);
1926         if (!peer) {
1927                 lua_pushinteger(L, -1);
1928                 return 1;
1929         }
1930         appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
1931         si = appctx->owner;
1932         s = si_strm(si);
1933
1934         /* Check for connection close. */
1935         if (channel_output_closed(&s->req)) {
1936                 xref_unlock(&socket->xref, peer);
1937                 lua_pushinteger(L, -1);
1938                 return 1;
1939         }
1940
1941         /* Update the input buffer data. */
1942         buf += sent;
1943         send_len = buf_len - sent;
1944
1945         /* All the data are sent. */
1946         if (sent >= buf_len) {
1947                 xref_unlock(&socket->xref, peer);
1948                 return 1; /* Implicitly return the length sent. */
1949         }
1950
1951         /* Check if the buffer is avalaible because HAProxy doesn't allocate
1952          * the request buffer if its not required.
1953          */
1954         if (s->req.buf->size == 0) {
1955                 appctx = hlua->task->context;
1956                 if (!channel_alloc_buffer(&s->req, &appctx->buffer_wait))
1957                         goto hlua_socket_write_yield_return;
1958         }
1959
1960         /* Check for avalaible space. */
1961         len = buffer_total_space(s->req.buf);
1962         if (len <= 0) {
1963                 appctx = objt_appctx(s->si[0].end);
1964                 if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task)) {
1965                         xref_unlock(&socket->xref, peer);
1966                         WILL_LJMP(luaL_error(L, "out of memory"));
1967                 }
1968                 goto hlua_socket_write_yield_return;
1969         }
1970
1971         /* send data */
1972         if (len < send_len)
1973                 send_len = len;
1974         len = ci_putblk(&s->req, buf+sent, send_len);
1975
1976         /* "Not enough space" (-1), "Buffer too little to contain
1977          * the data" (-2) are not expected because the available length
1978          * is tested.
1979          * Other unknown error are also not expected.
1980          */
1981         if (len <= 0) {
1982                 if (len == -1)
1983                         s->req.flags |= CF_WAKE_WRITE;
1984
1985                 MAY_LJMP(hlua_socket_close(L));
1986                 lua_pop(L, 1);
1987                 lua_pushinteger(L, -1);
1988                 xref_unlock(&socket->xref, peer);
1989                 return 1;
1990         }
1991
1992         /* update buffers. */
1993         stream_int_notify(&s->si[0]);
1994         stream_int_update_applet(&s->si[0]);
1995
1996         s->req.rex = TICK_ETERNITY;
1997         s->res.wex = TICK_ETERNITY;
1998
1999         /* Update length sent. */
2000         lua_pop(L, 1);
2001         lua_pushinteger(L, sent + len);
2002
2003         /* All the data buffer is sent ? */
2004         if (sent + len >= buf_len) {
2005                 xref_unlock(&socket->xref, peer);
2006                 return 1;
2007         }
2008
2009 hlua_socket_write_yield_return:
2010         xref_unlock(&socket->xref, peer);
2011         WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_write_yield, TICK_ETERNITY, 0));
2012         return 0;
2013 }
2014
2015 /* This function initiate the send of data. It just check the input
2016  * parameters and push an integer in the Lua stack that contain the
2017  * amount of data writed in the buffer. This is used by the function
2018  * "hlua_socket_write_yield" that can yield.
2019  *
2020  * The Lua function gets between 3 and 4 parameters. The first one is
2021  * the associated object. The second is a string buffer. The third is
2022  * a facultative integer that represents where is the buffer position
2023  * of the start of the data that can send. The first byte is the
2024  * position "1". The default value is "1". The fourth argument is a
2025  * facultative integer that represents where is the buffer position
2026  * of the end of the data that can send. The default is the last byte.
2027  */
2028 static int hlua_socket_send(struct lua_State *L)
2029 {
2030         int i;
2031         int j;
2032         const char *buf;
2033         size_t buf_len;
2034
2035         /* Check number of arguments. */
2036         if (lua_gettop(L) < 2 || lua_gettop(L) > 4)
2037                 WILL_LJMP(luaL_error(L, "'send' needs between 2 and 4 arguments"));
2038
2039         /* Get the string. */
2040         buf = MAY_LJMP(luaL_checklstring(L, 2, &buf_len));
2041
2042         /* Get and check j. */
2043         if (lua_gettop(L) == 4) {
2044                 j = MAY_LJMP(luaL_checkinteger(L, 4));
2045                 if (j < 0)
2046                         j = buf_len + j + 1;
2047                 if (j > buf_len)
2048                         j = buf_len + 1;
2049                 lua_pop(L, 1);
2050         }
2051         else
2052                 j = buf_len;
2053
2054         /* Get and check i. */
2055         if (lua_gettop(L) == 3) {
2056                 i = MAY_LJMP(luaL_checkinteger(L, 3));
2057                 if (i < 0)
2058                         i = buf_len + i + 1;
2059                 if (i > buf_len)
2060                         i = buf_len + 1;
2061                 lua_pop(L, 1);
2062         } else
2063                 i = 1;
2064
2065         /* Check bth i and j. */
2066         if (i > j) {
2067                 lua_pushinteger(L, 0);
2068                 return 1;
2069         }
2070         if (i == 0 && j == 0) {
2071                 lua_pushinteger(L, 0);
2072                 return 1;
2073         }
2074         if (i == 0)
2075                 i = 1;
2076         if (j == 0)
2077                 j = 1;
2078
2079         /* Pop the string. */
2080         lua_pop(L, 1);
2081
2082         /* Update the buffer length. */
2083         buf += i - 1;
2084         buf_len = j - i + 1;
2085         lua_pushlstring(L, buf, buf_len);
2086
2087         /* This unsigned is used to remember the amount of sent data. */
2088         lua_pushinteger(L, 0);
2089
2090         return MAY_LJMP(hlua_socket_write_yield(L, 0, 0));
2091 }
2092
2093 #define SOCKET_INFO_MAX_LEN sizeof("[0000:0000:0000:0000:0000:0000:0000:0000]:12345")
2094 __LJMP static inline int hlua_socket_info(struct lua_State *L, struct sockaddr_storage *addr)
2095 {
2096         static char buffer[SOCKET_INFO_MAX_LEN];
2097         int ret;
2098         int len;
2099         char *p;
2100
2101         ret = addr_to_str(addr, buffer+1, SOCKET_INFO_MAX_LEN-1);
2102         if (ret <= 0) {
2103                 lua_pushnil(L);
2104                 return 1;
2105         }
2106
2107         if (ret == AF_UNIX) {
2108                 lua_pushstring(L, buffer+1);
2109                 return 1;
2110         }
2111         else if (ret == AF_INET6) {
2112                 buffer[0] = '[';
2113                 len = strlen(buffer);
2114                 buffer[len] = ']';
2115                 len++;
2116                 buffer[len] = ':';
2117                 len++;
2118                 p = buffer;
2119         }
2120         else if (ret == AF_INET) {
2121                 p = buffer + 1;
2122                 len = strlen(p);
2123                 p[len] = ':';
2124                 len++;
2125         }
2126         else {
2127                 lua_pushnil(L);
2128                 return 1;
2129         }
2130
2131         if (port_to_str(addr, p + len, SOCKET_INFO_MAX_LEN-1 - len) <= 0) {
2132                 lua_pushnil(L);
2133                 return 1;
2134         }
2135
2136         lua_pushstring(L, p);
2137         return 1;
2138 }
2139
2140 /* Returns information about the peer of the connection. */
2141 __LJMP static int hlua_socket_getpeername(struct lua_State *L)
2142 {
2143         struct hlua_socket *socket;
2144         struct connection *conn;
2145         struct xref *peer;
2146         struct appctx *appctx;
2147         struct stream_interface *si;
2148         struct stream *s;
2149         int ret;
2150
2151         MAY_LJMP(check_args(L, 1, "getpeername"));
2152
2153         socket = MAY_LJMP(hlua_checksocket(L, 1));
2154
2155         /* Check if we run on the same thread than the xreator thread.
2156          * We cannot access to the socket if the thread is different.
2157          */
2158         if (socket->tid != tid)
2159                 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2160
2161         /* check for connection break. If some data where read, return it. */
2162         peer = xref_get_peer_and_lock(&socket->xref);
2163         if (!peer) {
2164                 lua_pushnil(L);
2165                 return 1;
2166         }
2167         appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2168         si = appctx->owner;
2169         s = si_strm(si);
2170
2171         conn = cs_conn(objt_cs(s->si[1].end));
2172         if (!conn) {
2173                 xref_unlock(&socket->xref, peer);
2174                 lua_pushnil(L);
2175                 return 1;
2176         }
2177
2178         conn_get_to_addr(conn);
2179         if (!(conn->flags & CO_FL_ADDR_TO_SET)) {
2180                 xref_unlock(&socket->xref, peer);
2181                 lua_pushnil(L);
2182                 return 1;
2183         }
2184
2185         ret = MAY_LJMP(hlua_socket_info(L, &conn->addr.to));
2186         xref_unlock(&socket->xref, peer);
2187         return ret;
2188 }
2189
2190 /* Returns information about my connection side. */
2191 static int hlua_socket_getsockname(struct lua_State *L)
2192 {
2193         struct hlua_socket *socket;
2194         struct connection *conn;
2195         struct appctx *appctx;
2196         struct xref *peer;
2197         struct stream_interface *si;
2198         struct stream *s;
2199         int ret;
2200
2201         MAY_LJMP(check_args(L, 1, "getsockname"));
2202
2203         socket = MAY_LJMP(hlua_checksocket(L, 1));
2204
2205         /* Check if we run on the same thread than the xreator thread.
2206          * We cannot access to the socket if the thread is different.
2207          */
2208         if (socket->tid != tid)
2209                 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2210
2211         /* check for connection break. If some data where read, return it. */
2212         peer = xref_get_peer_and_lock(&socket->xref);
2213         if (!peer) {
2214                 lua_pushnil(L);
2215                 return 1;
2216         }
2217         appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2218         si = appctx->owner;
2219         s = si_strm(si);
2220
2221         conn = cs_conn(objt_cs(s->si[1].end));
2222         if (!conn) {
2223                 xref_unlock(&socket->xref, peer);
2224                 lua_pushnil(L);
2225                 return 1;
2226         }
2227
2228         conn_get_from_addr(conn);
2229         if (!(conn->flags & CO_FL_ADDR_FROM_SET)) {
2230                 xref_unlock(&socket->xref, peer);
2231                 lua_pushnil(L);
2232                 return 1;
2233         }
2234
2235         ret = hlua_socket_info(L, &conn->addr.from);
2236         xref_unlock(&socket->xref, peer);
2237         return ret;
2238 }
2239
2240 /* This struct define the applet. */
2241 static struct applet update_applet = {
2242         .obj_type = OBJ_TYPE_APPLET,
2243         .name = "<LUA_TCP>",
2244         .fct = hlua_socket_handler,
2245         .release = hlua_socket_release,
2246 };
2247
2248 __LJMP static int hlua_socket_connect_yield(struct lua_State *L, int status, lua_KContext ctx)
2249 {
2250         struct hlua_socket *socket = MAY_LJMP(hlua_checksocket(L, 1));
2251         struct hlua *hlua = hlua_gethlua(L);
2252         struct xref *peer;
2253         struct appctx *appctx;
2254         struct stream_interface *si;
2255         struct stream *s;
2256
2257         /* Check if we run on the same thread than the xreator thread.
2258          * We cannot access to the socket if the thread is different.
2259          */
2260         if (socket->tid != tid)
2261                 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2262
2263         /* check for connection break. If some data where read, return it. */
2264         peer = xref_get_peer_and_lock(&socket->xref);
2265         if (!peer) {
2266                 lua_pushnil(L);
2267                 lua_pushstring(L, "Can't connect");
2268                 return 2;
2269         }
2270         appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2271         si = appctx->owner;
2272         s = si_strm(si);
2273
2274         /* Check if we run on the same thread than the xreator thread.
2275          * We cannot access to the socket if the thread is different.
2276          */
2277         if (socket->tid != tid) {
2278                 xref_unlock(&socket->xref, peer);
2279                 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2280         }
2281
2282         /* Check for connection close. */
2283         if (!hlua || channel_output_closed(&s->req)) {
2284                 xref_unlock(&socket->xref, peer);
2285                 lua_pushnil(L);
2286                 lua_pushstring(L, "Can't connect");
2287                 return 2;
2288         }
2289
2290         appctx = objt_appctx(s->si[0].end);
2291
2292         /* Check for connection established. */
2293         if (appctx->ctx.hlua_cosocket.connected) {
2294                 xref_unlock(&socket->xref, peer);
2295                 lua_pushinteger(L, 1);
2296                 return 1;
2297         }
2298
2299         if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task)) {
2300                 xref_unlock(&socket->xref, peer);
2301                 WILL_LJMP(luaL_error(L, "out of memory error"));
2302         }
2303         xref_unlock(&socket->xref, peer);
2304         WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_connect_yield, TICK_ETERNITY, 0));
2305         return 0;
2306 }
2307
2308 /* This function fail or initite the connection. */
2309 __LJMP static int hlua_socket_connect(struct lua_State *L)
2310 {
2311         struct hlua_socket *socket;
2312         int port = -1;
2313         const char *ip;
2314         struct connection *conn;
2315         struct hlua *hlua;
2316         struct appctx *appctx;
2317         int low, high;
2318         struct sockaddr_storage *addr;
2319         struct xref *peer;
2320         struct stream_interface *si;
2321         struct stream *s;
2322
2323         if (lua_gettop(L) < 2)
2324                 WILL_LJMP(luaL_error(L, "connect: need at least 2 arguments"));
2325
2326         /* Get args. */
2327         socket  = MAY_LJMP(hlua_checksocket(L, 1));
2328
2329         /* Check if we run on the same thread than the xreator thread.
2330          * We cannot access to the socket if the thread is different.
2331          */
2332         if (socket->tid != tid)
2333                 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2334
2335         ip      = MAY_LJMP(luaL_checkstring(L, 2));
2336         if (lua_gettop(L) >= 3) {
2337                 luaL_Buffer b;
2338                 port = MAY_LJMP(luaL_checkinteger(L, 3));
2339
2340                 /* Force the ip to end with a colon, to support IPv6 addresses
2341                  * that are not enclosed within square brackets.
2342                  */
2343                 if (port > 0) {
2344                         luaL_buffinit(L, &b);
2345                         luaL_addstring(&b, ip);
2346                         luaL_addchar(&b, ':');
2347                         luaL_pushresult(&b);
2348                         ip = lua_tolstring(L, lua_gettop(L), NULL);
2349                 }
2350         }
2351
2352         /* check for connection break. If some data where read, return it. */
2353         peer = xref_get_peer_and_lock(&socket->xref);
2354         if (!peer) {
2355                 lua_pushnil(L);
2356                 return 1;
2357         }
2358         appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2359         si = appctx->owner;
2360         s = si_strm(si);
2361
2362         /* Initialise connection. */
2363         conn = cs_conn(si_alloc_cs(&s->si[1], NULL));
2364         if (!conn) {
2365                 xref_unlock(&socket->xref, peer);
2366                 WILL_LJMP(luaL_error(L, "connect: internal error"));
2367         }
2368
2369         /* needed for the connection not to be closed */
2370         conn->target = s->target;
2371
2372         /* Parse ip address. */
2373         addr = str2sa_range(ip, NULL, &low, &high, NULL, NULL, NULL, 0);
2374         if (!addr) {
2375                 xref_unlock(&socket->xref, peer);
2376                 WILL_LJMP(luaL_error(L, "connect: cannot parse destination address '%s'", ip));
2377         }
2378         if (low != high) {
2379                 xref_unlock(&socket->xref, peer);
2380                 WILL_LJMP(luaL_error(L, "connect: port ranges not supported : address '%s'", ip));
2381         }
2382         memcpy(&conn->addr.to, addr, sizeof(struct sockaddr_storage));
2383
2384         /* Set port. */
2385         if (low == 0) {
2386                 if (conn->addr.to.ss_family == AF_INET) {
2387                         if (port == -1) {
2388                                 xref_unlock(&socket->xref, peer);
2389                                 WILL_LJMP(luaL_error(L, "connect: port missing"));
2390                         }
2391                         ((struct sockaddr_in *)&conn->addr.to)->sin_port = htons(port);
2392                 } else if (conn->addr.to.ss_family == AF_INET6) {
2393                         if (port == -1) {
2394                                 xref_unlock(&socket->xref, peer);
2395                                 WILL_LJMP(luaL_error(L, "connect: port missing"));
2396                         }
2397                         ((struct sockaddr_in6 *)&conn->addr.to)->sin6_port = htons(port);
2398                 }
2399         }
2400
2401         hlua = hlua_gethlua(L);
2402         appctx = objt_appctx(s->si[0].end);
2403
2404         /* inform the stream that we want to be notified whenever the
2405          * connection completes.
2406          */
2407         si_applet_cant_get(&s->si[0]);
2408         si_applet_cant_put(&s->si[0]);
2409         appctx_wakeup(appctx);
2410
2411         hlua->flags |= HLUA_MUST_GC;
2412
2413         if (!notification_new(&hlua->com, &appctx->ctx.hlua_cosocket.wake_on_write, hlua->task)) {
2414                 xref_unlock(&socket->xref, peer);
2415                 WILL_LJMP(luaL_error(L, "out of memory"));
2416         }
2417         xref_unlock(&socket->xref, peer);
2418         WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_socket_connect_yield, TICK_ETERNITY, 0));
2419
2420         return 0;
2421 }
2422
2423 #ifdef USE_OPENSSL
2424 __LJMP static int hlua_socket_connect_ssl(struct lua_State *L)
2425 {
2426         struct hlua_socket *socket;
2427         struct xref *peer;
2428         struct appctx *appctx;
2429         struct stream_interface *si;
2430         struct stream *s;
2431
2432         MAY_LJMP(check_args(L, 3, "connect_ssl"));
2433         socket  = MAY_LJMP(hlua_checksocket(L, 1));
2434
2435         /* check for connection break. If some data where read, return it. */
2436         peer = xref_get_peer_and_lock(&socket->xref);
2437         if (!peer) {
2438                 lua_pushnil(L);
2439                 return 1;
2440         }
2441         appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2442         si = appctx->owner;
2443         s = si_strm(si);
2444
2445         s->target = &socket_ssl.obj_type;
2446         xref_unlock(&socket->xref, peer);
2447         return MAY_LJMP(hlua_socket_connect(L));
2448 }
2449 #endif
2450
2451 __LJMP static int hlua_socket_setoption(struct lua_State *L)
2452 {
2453         return 0;
2454 }
2455
2456 __LJMP static int hlua_socket_settimeout(struct lua_State *L)
2457 {
2458         struct hlua_socket *socket;
2459         int tmout;
2460         struct xref *peer;
2461         struct appctx *appctx;
2462         struct stream_interface *si;
2463         struct stream *s;
2464
2465         MAY_LJMP(check_args(L, 2, "settimeout"));
2466
2467         socket = MAY_LJMP(hlua_checksocket(L, 1));
2468         tmout = MAY_LJMP(luaL_checkinteger(L, 2)) * 1000;
2469
2470         /* Check if we run on the same thread than the xreator thread.
2471          * We cannot access to the socket if the thread is different.
2472          */
2473         if (socket->tid != tid)
2474                 WILL_LJMP(luaL_error(L, "connect: cannot use socket on other thread"));
2475
2476         /* check for connection break. If some data where read, return it. */
2477         peer = xref_get_peer_and_lock(&socket->xref);
2478         if (!peer) {
2479                 hlua_pusherror(L, "socket: not yet initialised, you can't set timeouts.");
2480                 WILL_LJMP(lua_error(L));
2481                 return 0;
2482         }
2483         appctx = container_of(peer, struct appctx, ctx.hlua_cosocket.xref);
2484         si = appctx->owner;
2485         s = si_strm(si);
2486
2487         s->req.rto = tmout;
2488         s->req.wto = tmout;
2489         s->res.rto = tmout;
2490         s->res.wto = tmout;
2491         xref_unlock(&socket->xref, peer);
2492
2493         return 1;
2494 }
2495
2496 __LJMP static int hlua_socket_new(lua_State *L)
2497 {
2498         struct hlua_socket *socket;
2499         struct appctx *appctx;
2500         struct session *sess;
2501         struct stream *strm;
2502
2503         /* Check stack size. */
2504         if (!lua_checkstack(L, 3)) {
2505                 hlua_pusherror(L, "socket: full stack");
2506                 goto out_fail_conf;
2507         }
2508
2509         /* Create the object: obj[0] = userdata. */
2510         lua_newtable(L);
2511         socket = MAY_LJMP(lua_newuserdata(L, sizeof(*socket)));
2512         lua_rawseti(L, -2, 0);
2513         memset(socket, 0, sizeof(*socket));
2514         socket->tid = tid;
2515
2516         /* Check if the various memory pools are intialized. */
2517         if (!pool_head_stream || !pool_head_buffer) {
2518                 hlua_pusherror(L, "socket: uninitialized pools.");
2519                 goto out_fail_conf;
2520         }
2521
2522         /* Pop a class stream metatable and affect it to the userdata. */
2523         lua_rawgeti(L, LUA_REGISTRYINDEX, class_socket_ref);
2524         lua_setmetatable(L, -2);
2525
2526         /* Create the applet context */
2527         appctx = appctx_new(&update_applet, tid_bit);
2528         if (!appctx) {
2529                 hlua_pusherror(L, "socket: out of memory");
2530                 goto out_fail_conf;
2531         }
2532
2533         appctx->ctx.hlua_cosocket.connected = 0;
2534         appctx->ctx.hlua_cosocket.die = 0;
2535         LIST_INIT(&appctx->ctx.hlua_cosocket.wake_on_write);
2536         LIST_INIT(&appctx->ctx.hlua_cosocket.wake_on_read);
2537
2538         /* Now create a session, task and stream for this applet */
2539         sess = session_new(&socket_proxy, NULL, &appctx->obj_type);
2540         if (!sess) {
2541                 hlua_pusherror(L, "socket: out of memory");
2542                 goto out_fail_sess;
2543         }
2544
2545         strm = stream_new(sess, &appctx->obj_type);
2546         if (!strm) {
2547                 hlua_pusherror(L, "socket: out of memory");
2548                 goto out_fail_stream;
2549         }
2550
2551         /* Initialise cross reference between stream and Lua socket object. */
2552         xref_create(&socket->xref, &appctx->ctx.hlua_cosocket.xref);
2553
2554         /* Configure "right" stream interface. this "si" is used to connect
2555          * and retrieve data from the server. The connection is initialized
2556          * with the "struct server".
2557          */
2558         si_set_state(&strm->si[1], SI_ST_ASS);
2559
2560         /* Force destination server. */
2561         strm->flags |= SF_DIRECT | SF_ASSIGNED | SF_ADDR_SET | SF_BE_ASSIGNED;
2562         strm->target = &socket_tcp.obj_type;
2563
2564         task_wakeup(strm->task, TASK_WOKEN_INIT);
2565         /* Return yield waiting for connection. */
2566         return 1;
2567
2568  out_fail_stream:
2569         session_free(sess);
2570  out_fail_sess:
2571         appctx_free(appctx);
2572  out_fail_conf:
2573         WILL_LJMP(lua_error(L));
2574         return 0;
2575 }
2576
2577 /*
2578  *
2579  *
2580  * Class Channel
2581  *
2582  *
2583  */
2584
2585 /* The state between the channel data and the HTTP parser state can be
2586  * unconsistent, so reset the parser and call it again. Warning, this
2587  * action not revalidate the request and not send a 400 if the modified
2588  * resuest is not valid.
2589  *
2590  * This function never fails. The direction is set using dir, which equals
2591  * either SMP_OPT_DIR_REQ or SMP_OPT_DIR_RES.
2592  */
2593 static void hlua_resynchonize_proto(struct stream *stream, int dir)
2594 {
2595         /* Protocol HTTP. */
2596         if (stream->be->mode == PR_MODE_HTTP) {
2597
2598                 if (dir == SMP_OPT_DIR_REQ)
2599                         http_txn_reset_req(stream->txn);
2600                 else if (dir == SMP_OPT_DIR_RES)
2601                         http_txn_reset_res(stream->txn);
2602
2603                 if (stream->txn->hdr_idx.v)
2604                         hdr_idx_init(&stream->txn->hdr_idx);
2605
2606                 if (dir == SMP_OPT_DIR_REQ)
2607                         http_msg_analyzer(&stream->txn->req, &stream->txn->hdr_idx);
2608                 else if (dir == SMP_OPT_DIR_RES)
2609                         http_msg_analyzer(&stream->txn->rsp, &stream->txn->hdr_idx);
2610         }
2611 }
2612
2613 /* This function is called before the Lua execution. It stores
2614  * the differents parsers state before executing some Lua code.
2615  */
2616 static inline void consistency_set(struct stream *stream, int opt, struct hlua_consistency *c)
2617 {
2618         c->mode = stream->be->mode;
2619         switch (c->mode) {
2620         case PR_MODE_HTTP:
2621                 c->data.http.dir = opt & SMP_OPT_DIR;
2622                 if (c->data.http.dir == SMP_OPT_DIR_REQ)
2623                         c->data.http.state = stream->txn->req.msg_state;
2624                 else
2625                         c->data.http.state = stream->txn->rsp.msg_state;
2626                 break;
2627         default:
2628                 break;
2629         }
2630 }
2631
2632 /* This function is called after the Lua execution. it
2633  * returns true if the parser state is consistent, otherwise,
2634  * it return false.
2635  *
2636  * In HTTP mode, the parser state must be in the same state
2637  * or greater when we exit the function. Even if we do a
2638  * control yield. This prevent to break the HTTP message
2639  * from the Lua code.
2640  */
2641 static inline int consistency_check(struct stream *stream, int opt, struct hlua_consistency *c)
2642 {
2643         if (c->mode != stream->be->mode)
2644                 return 0;
2645
2646         switch (c->mode) {
2647         case PR_MODE_HTTP:
2648                 if (c->data.http.dir != (opt & SMP_OPT_DIR))
2649                         return 0;
2650                 if (c->data.http.dir == SMP_OPT_DIR_REQ)
2651                         return stream->txn->req.msg_state >= c->data.http.state;
2652                 else
2653                         return stream->txn->rsp.msg_state >= c->data.http.state;
2654         default:
2655                 return 1;
2656         }
2657         return 1;
2658 }
2659
2660 /* Returns the struct hlua_channel join to the class channel in the
2661  * stack entry "ud" or throws an argument error.
2662  */
2663 __LJMP static struct channel *hlua_checkchannel(lua_State *L, int ud)
2664 {
2665         return MAY_LJMP(hlua_checkudata(L, ud, class_channel_ref));
2666 }
2667
2668 /* Pushes the channel onto the top of the stack. If the stask does not have a
2669  * free slots, the function fails and returns 0;
2670  */
2671 static int hlua_channel_new(lua_State *L, struct channel *channel)
2672 {
2673         /* Check stack size. */
2674         if (!lua_checkstack(L, 3))
2675                 return 0;
2676
2677         lua_newtable(L);
2678         lua_pushlightuserdata(L, channel);
2679         lua_rawseti(L, -2, 0);
2680
2681         /* Pop a class sesison metatable and affect it to the userdata. */
2682         lua_rawgeti(L, LUA_REGISTRYINDEX, class_channel_ref);
2683         lua_setmetatable(L, -2);
2684         return 1;
2685 }
2686
2687 /* Duplicate all the data present in the input channel and put it
2688  * in a string LUA variables. Returns -1 and push a nil value in
2689  * the stack if the channel is closed and all the data are consumed,
2690  * returns 0 if no data are available, otherwise it returns the length
2691  * of the builded string.
2692  */
2693 static inline int _hlua_channel_dup(struct channel *chn, lua_State *L)
2694 {
2695         char *blk1;
2696         char *blk2;
2697         int len1;
2698         int len2;
2699         int ret;
2700         luaL_Buffer b;
2701
2702         ret = ci_getblk_nc(chn, &blk1, &len1, &blk2, &len2);
2703         if (unlikely(ret == 0))
2704                 return 0;
2705
2706         if (unlikely(ret < 0)) {
2707                 lua_pushnil(L);
2708                 return -1;
2709         }
2710
2711         luaL_buffinit(L, &b);
2712         luaL_addlstring(&b, blk1, len1);
2713         if (unlikely(ret == 2))
2714                 luaL_addlstring(&b, blk2, len2);
2715         luaL_pushresult(&b);
2716
2717         if (unlikely(ret == 2))
2718                 return len1 + len2;
2719         return len1;
2720 }
2721
2722 /* "_hlua_channel_dup" wrapper. If no data are available, it returns
2723  * a yield. This function keep the data in the buffer.
2724  */
2725 __LJMP static int hlua_channel_dup_yield(lua_State *L, int status, lua_KContext ctx)
2726 {
2727         struct channel *chn;
2728
2729         chn = MAY_LJMP(hlua_checkchannel(L, 1));
2730
2731         if (_hlua_channel_dup(chn, L) == 0)
2732                 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_dup_yield, TICK_ETERNITY, 0));
2733         return 1;
2734 }
2735
2736 /* Check arguments for the function "hlua_channel_dup_yield". */
2737 __LJMP static int hlua_channel_dup(lua_State *L)
2738 {
2739         MAY_LJMP(check_args(L, 1, "dup"));
2740         MAY_LJMP(hlua_checkchannel(L, 1));
2741         return MAY_LJMP(hlua_channel_dup_yield(L, 0, 0));
2742 }
2743
2744 /* "_hlua_channel_dup" wrapper. If no data are available, it returns
2745  * a yield. This function consumes the data in the buffer. It returns
2746  * a string containing the data or a nil pointer if no data are available
2747  * and the channel is closed.
2748  */
2749 __LJMP static int hlua_channel_get_yield(lua_State *L, int status, lua_KContext ctx)
2750 {
2751         struct channel *chn;
2752         int ret;
2753
2754         chn = MAY_LJMP(hlua_checkchannel(L, 1));
2755
2756         ret = _hlua_channel_dup(chn, L);
2757         if (unlikely(ret == 0))
2758                 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_get_yield, TICK_ETERNITY, 0));
2759
2760         if (unlikely(ret == -1))
2761                 return 1;
2762
2763         chn->buf->i -= ret;
2764         hlua_resynchonize_proto(chn_strm(chn), !!(chn->flags & CF_ISRESP));
2765         return 1;
2766 }
2767
2768 /* Check arguments for the fucntion "hlua_channel_get_yield". */
2769 __LJMP static int hlua_channel_get(lua_State *L)
2770 {
2771         MAY_LJMP(check_args(L, 1, "get"));
2772         MAY_LJMP(hlua_checkchannel(L, 1));
2773         return MAY_LJMP(hlua_channel_get_yield(L, 0, 0));
2774 }
2775
2776 /* This functions consumes and returns one line. If the channel is closed,
2777  * and the last data does not contains a final '\n', the data are returned
2778  * without the final '\n'. When no more data are avalaible, it returns nil
2779  * value.
2780  */
2781 __LJMP static int hlua_channel_getline_yield(lua_State *L, int status, lua_KContext ctx)
2782 {
2783         char *blk1;
2784         char *blk2;
2785         int len1;
2786         int len2;
2787         int len;
2788         struct channel *chn;
2789         int ret;
2790         luaL_Buffer b;
2791
2792         chn = MAY_LJMP(hlua_checkchannel(L, 1));
2793
2794         ret = ci_getline_nc(chn, &blk1, &len1, &blk2, &len2);
2795         if (ret == 0)
2796                 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_getline_yield, TICK_ETERNITY, 0));
2797
2798         if (ret == -1) {
2799                 lua_pushnil(L);
2800                 return 1;
2801         }
2802
2803         luaL_buffinit(L, &b);
2804         luaL_addlstring(&b, blk1, len1);
2805         len = len1;
2806         if (unlikely(ret == 2)) {
2807                 luaL_addlstring(&b, blk2, len2);
2808                 len += len2;
2809         }
2810         luaL_pushresult(&b);
2811         buffer_replace2(chn->buf, chn->buf->p, chn->buf->p + len,  NULL, 0);
2812         hlua_resynchonize_proto(chn_strm(chn), !!(chn->flags & CF_ISRESP));
2813         return 1;
2814 }
2815
2816 /* Check arguments for the fucntion "hlua_channel_getline_yield". */
2817 __LJMP static int hlua_channel_getline(lua_State *L)
2818 {
2819         MAY_LJMP(check_args(L, 1, "getline"));
2820         MAY_LJMP(hlua_checkchannel(L, 1));
2821         return MAY_LJMP(hlua_channel_getline_yield(L, 0, 0));
2822 }
2823
2824 /* This function takes a string as input, and append it at the
2825  * input side of channel. If the data is too big, but a space
2826  * is probably available after sending some data, the function
2827  * yield. If the data is bigger than the buffer, or if the
2828  * channel is closed, it returns -1. otherwise, it returns the
2829  * amount of data writed.
2830  */
2831 __LJMP static int hlua_channel_append_yield(lua_State *L, int status, lua_KContext ctx)
2832 {
2833         struct channel *chn = MAY_LJMP(hlua_checkchannel(L, 1));
2834         size_t len;
2835         const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
2836         int l = MAY_LJMP(luaL_checkinteger(L, 3));
2837         int ret;
2838         int max;
2839
2840         /* Check if the buffer is avalaible because HAProxy doesn't allocate
2841          * the request buffer if its not required.
2842          */
2843         if (chn->buf->size == 0) {
2844                 si_applet_cant_put(chn_prod(chn));
2845                 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
2846         }
2847
2848         max = channel_recv_limit(chn) - buffer_len(chn->buf);
2849         if (max > len - l)
2850                 max = len - l;
2851
2852         ret = ci_putblk(chn, str + l, max);
2853         if (ret == -2 || ret == -3) {
2854                 lua_pushinteger(L, -1);
2855                 return 1;
2856         }
2857         if (ret == -1) {
2858                 chn->flags |= CF_WAKE_WRITE;
2859                 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
2860         }
2861         l += ret;
2862         lua_pop(L, 1);
2863         lua_pushinteger(L, l);
2864         hlua_resynchonize_proto(chn_strm(chn), !!(chn->flags & CF_ISRESP));
2865
2866         max = channel_recv_limit(chn) - buffer_len(chn->buf);
2867         if (max == 0 && chn->buf->o == 0) {
2868                 /* There are no space avalaible, and the output buffer is empty.
2869                  * in this case, we cannot add more data, so we cannot yield,
2870                  * we return the amount of copyied data.
2871                  */
2872                 return 1;
2873         }
2874         if (l < len)
2875                 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_append_yield, TICK_ETERNITY, 0));
2876         return 1;
2877 }
2878
2879 /* just a wrapper of "hlua_channel_append_yield". It returns the length
2880  * of the writed string, or -1 if the channel is closed or if the
2881  * buffer size is too little for the data.
2882  */
2883 __LJMP static int hlua_channel_append(lua_State *L)
2884 {
2885         size_t len;
2886
2887         MAY_LJMP(check_args(L, 2, "append"));
2888         MAY_LJMP(hlua_checkchannel(L, 1));
2889         MAY_LJMP(luaL_checklstring(L, 2, &len));
2890         MAY_LJMP(luaL_checkinteger(L, 3));
2891         lua_pushinteger(L, 0);
2892
2893         return MAY_LJMP(hlua_channel_append_yield(L, 0, 0));
2894 }
2895
2896 /* just a wrapper of "hlua_channel_append_yield". This wrapper starts
2897  * his process by cleaning the buffer. The result is a replacement
2898  * of the current data. It returns the length of the writed string,
2899  * or -1 if the channel is closed or if the buffer size is too
2900  * little for the data.
2901  */
2902 __LJMP static int hlua_channel_set(lua_State *L)
2903 {
2904         struct channel *chn;
2905
2906         MAY_LJMP(check_args(L, 2, "set"));
2907         chn = MAY_LJMP(hlua_checkchannel(L, 1));
2908         lua_pushinteger(L, 0);
2909
2910         chn->buf->i = 0;
2911
2912         return MAY_LJMP(hlua_channel_append_yield(L, 0, 0));
2913 }
2914
2915 /* Append data in the output side of the buffer. This data is immediatly
2916  * sent. The fcuntion returns the ammount of data writed. If the buffer
2917  * cannot contains the data, the function yield. The function returns -1
2918  * if the channel is closed.
2919  */
2920 __LJMP static int hlua_channel_send_yield(lua_State *L, int status, lua_KContext ctx)
2921 {
2922         struct channel *chn = MAY_LJMP(hlua_checkchannel(L, 1));
2923         size_t len;
2924         const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
2925         int l = MAY_LJMP(luaL_checkinteger(L, 3));
2926         int max;
2927         struct hlua *hlua = hlua_gethlua(L);
2928
2929         if (unlikely(channel_output_closed(chn))) {
2930                 lua_pushinteger(L, -1);
2931                 return 1;
2932         }
2933
2934         /* Check if the buffer is avalaible because HAProxy doesn't allocate
2935          * the request buffer if its not required.
2936          */
2937         if (chn->buf->size == 0) {
2938                 si_applet_cant_put(chn_prod(chn));
2939                 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_send_yield, TICK_ETERNITY, 0));
2940         }
2941
2942         /* the writed data will be immediatly sent, so we can check
2943          * the avalaible space without taking in account the reserve.
2944          * The reserve is guaranted for the processing of incoming
2945          * data, because the buffer will be flushed.
2946          */
2947         max = chn->buf->size - buffer_len(chn->buf);
2948
2949         /* If there are no space avalaible, and the output buffer is empty.
2950          * in this case, we cannot add more data, so we cannot yield,
2951          * we return the amount of copyied data.
2952          */
2953         if (max == 0 && chn->buf->o == 0)
2954                 return 1;
2955
2956         /* Adjust the real required length. */
2957         if (max > len - l)
2958                 max = len - l;
2959
2960         /* The buffer avalaible size may be not contiguous. This test
2961          * detects a non contiguous buffer and realign it.
2962          */
2963         if (bi_space_for_replace(chn->buf) < max)
2964                 buffer_slow_realign(chn->buf);
2965
2966         /* Copy input data in the buffer. */
2967         max = buffer_replace2(chn->buf, chn->buf->p, chn->buf->p, str + l, max);
2968
2969         /* buffer replace considers that the input part is filled.
2970          * so, I must forward these new data in the output part.
2971          */
2972         b_adv(chn->buf, max);
2973
2974         l += max;
2975         lua_pop(L, 1);
2976         lua_pushinteger(L, l);
2977
2978         /* If there are no space avalaible, and the output buffer is empty.
2979          * in this case, we cannot add more data, so we cannot yield,
2980          * we return the amount of copyied data.
2981          */
2982         max = chn->buf->size - buffer_len(chn->buf);
2983         if (max == 0 && chn->buf->o == 0)
2984                 return 1;
2985
2986         if (l < len) {
2987                 /* If we are waiting for space in the response buffer, we
2988                  * must set the flag WAKERESWR. This flag required the task
2989                  * wake up if any activity is detected on the response buffer.
2990                  */
2991                 if (chn->flags & CF_ISRESP)
2992                         HLUA_SET_WAKERESWR(hlua);
2993                 else
2994                         HLUA_SET_WAKEREQWR(hlua);
2995                 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_send_yield, TICK_ETERNITY, 0));
2996         }
2997
2998         return 1;
2999 }
3000
3001 /* Just a wraper of "_hlua_channel_send". This wrapper permits
3002  * yield the LUA process, and resume it without checking the
3003  * input arguments.
3004  */
3005 __LJMP static int hlua_channel_send(lua_State *L)
3006 {
3007         MAY_LJMP(check_args(L, 2, "send"));
3008         lua_pushinteger(L, 0);
3009
3010         return MAY_LJMP(hlua_channel_send_yield(L, 0, 0));
3011 }
3012
3013 /* This function forward and amount of butes. The data pass from
3014  * the input side of the buffer to the output side, and can be
3015  * forwarded. This function never fails.
3016  *
3017  * The Lua function takes an amount of bytes to be forwarded in
3018  * imput. It returns the number of bytes forwarded.
3019  */
3020 __LJMP static int hlua_channel_forward_yield(lua_State *L, int status, lua_KContext ctx)
3021 {
3022         struct channel *chn;
3023         int len;
3024         int l;
3025         int max;
3026         struct hlua *hlua = hlua_gethlua(L);
3027
3028         chn = MAY_LJMP(hlua_checkchannel(L, 1));
3029         len = MAY_LJMP(luaL_checkinteger(L, 2));
3030         l = MAY_LJMP(luaL_checkinteger(L, -1));
3031
3032         max = len - l;
3033         if (max > chn->buf->i)
3034                 max = chn->buf->i;
3035         channel_forward(chn, max);
3036         l += max;
3037
3038         lua_pop(L, 1);
3039         lua_pushinteger(L, l);
3040
3041         /* Check if it miss bytes to forward. */
3042         if (l < len) {
3043                 /* The the input channel or the output channel are closed, we
3044                  * must return the amount of data forwarded.
3045                  */
3046                 if (channel_input_closed(chn) || channel_output_closed(chn))
3047                         return 1;
3048
3049                 /* If we are waiting for space data in the response buffer, we
3050                  * must set the flag WAKERESWR. This flag required the task
3051                  * wake up if any activity is detected on the response buffer.
3052                  */
3053                 if (chn->flags & CF_ISRESP)
3054                         HLUA_SET_WAKERESWR(hlua);
3055                 else
3056                         HLUA_SET_WAKEREQWR(hlua);
3057
3058                 /* Otherwise, we can yield waiting for new data in the inpout side. */
3059                 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_channel_forward_yield, TICK_ETERNITY, 0));
3060         }
3061
3062         return 1;
3063 }
3064
3065 /* Just check the input and prepare the stack for the previous
3066  * function "hlua_channel_forward_yield"
3067  */
3068 __LJMP static int hlua_channel_forward(lua_State *L)
3069 {
3070         MAY_LJMP(check_args(L, 2, "forward"));
3071         MAY_LJMP(hlua_checkchannel(L, 1));
3072         MAY_LJMP(luaL_checkinteger(L, 2));
3073
3074         lua_pushinteger(L, 0);
3075         return MAY_LJMP(hlua_channel_forward_yield(L, 0, 0));
3076 }
3077
3078 /* Just returns the number of bytes available in the input
3079  * side of the buffer. This function never fails.
3080  */
3081 __LJMP static int hlua_channel_get_in_len(lua_State *L)
3082 {
3083         struct channel *chn;
3084
3085         MAY_LJMP(check_args(L, 1, "get_in_len"));
3086         chn = MAY_LJMP(hlua_checkchannel(L, 1));
3087         lua_pushinteger(L, chn->buf->i);
3088         return 1;
3089 }
3090
3091 /* Returns true if the channel is full. */
3092 __LJMP static int hlua_channel_is_full(lua_State *L)
3093 {
3094         struct channel *chn;
3095         int rem;
3096
3097         MAY_LJMP(check_args(L, 1, "is_full"));
3098         chn = MAY_LJMP(hlua_checkchannel(L, 1));
3099
3100         rem = chn->buf->size;
3101         rem -= chn->buf->o; /* Output size */
3102         rem -= chn->buf->i; /* Input size */
3103         rem -= global.tune.maxrewrite; /* Rewrite reserved size */
3104
3105         lua_pushboolean(L, rem <= 0);
3106         return 1;
3107 }
3108
3109 /* Just returns the number of bytes available in the output
3110  * side of the buffer. This function never fails.
3111  */
3112 __LJMP static int hlua_channel_get_out_len(lua_State *L)
3113 {
3114         struct channel *chn;
3115
3116         MAY_LJMP(check_args(L, 1, "get_out_len"));
3117         chn = MAY_LJMP(hlua_checkchannel(L, 1));
3118         lua_pushinteger(L, chn->buf->o);
3119         return 1;
3120 }
3121
3122 /*
3123  *
3124  *
3125  * Class Fetches
3126  *
3127  *
3128  */
3129
3130 /* Returns a struct hlua_session if the stack entry "ud" is
3131  * a class stream, otherwise it throws an error.
3132  */
3133 __LJMP static struct hlua_smp *hlua_checkfetches(lua_State *L, int ud)
3134 {
3135         return MAY_LJMP(hlua_checkudata(L, ud, class_fetches_ref));
3136 }
3137
3138 /* This function creates and push in the stack a fetch object according
3139  * with a current TXN.
3140  */
3141 static int hlua_fetches_new(lua_State *L, struct hlua_txn *txn, unsigned int flags)
3142 {
3143         struct hlua_smp *hsmp;
3144
3145         /* Check stack size. */
3146         if (!lua_checkstack(L, 3))
3147                 return 0;
3148
3149         /* Create the object: obj[0] = userdata.
3150          * Note that the base of the Fetches object is the
3151          * transaction object.
3152          */
3153         lua_newtable(L);
3154         hsmp = lua_newuserdata(L, sizeof(*hsmp));
3155         lua_rawseti(L, -2, 0);
3156
3157         hsmp->s = txn->s;
3158         hsmp->p = txn->p;
3159         hsmp->dir = txn->dir;
3160         hsmp->flags = flags;
3161
3162         /* Pop a class sesison metatable and affect it to the userdata. */
3163         lua_rawgeti(L, LUA_REGISTRYINDEX, class_fetches_ref);
3164         lua_setmetatable(L, -2);
3165
3166         return 1;
3167 }
3168
3169 /* This function is an LUA binding. It is called with each sample-fetch.
3170  * It uses closure argument to store the associated sample-fetch. It
3171  * returns only one argument or throws an error. An error is thrown
3172  * only if an error is encountered during the argument parsing. If
3173  * the "sample-fetch" function fails, nil is returned.
3174  */
3175 __LJMP static int hlua_run_sample_fetch(lua_State *L)
3176 {
3177         struct hlua_smp *hsmp;
3178         struct sample_fetch *f;
3179         struct arg args[ARGM_NBARGS + 1];
3180         int i;
3181         struct sample smp;
3182
3183         /* Get closure arguments. */
3184         f = lua_touserdata(L, lua_upvalueindex(1));
3185
3186         /* Get traditionnal arguments. */
3187         hsmp = MAY_LJMP(hlua_checkfetches(L, 1));
3188
3189         /* Check execution authorization. */
3190         if (f->use & SMP_USE_HTTP_ANY &&
3191             !(hsmp->flags & HLUA_F_MAY_USE_HTTP)) {
3192                 lua_pushfstring(L, "the sample-fetch '%s' needs an HTTP parser which "
3193                                    "is not available in Lua services", f->kw);
3194                 WILL_LJMP(lua_error(L));
3195         }
3196
3197         /* Get extra arguments. */
3198         for (i = 0; i < lua_gettop(L) - 1; i++) {
3199                 if (i >= ARGM_NBARGS)
3200                         break;
3201                 hlua_lua2arg(L, i + 2, &args[i]);
3202         }
3203         args[i].type = ARGT_STOP;
3204         args[i].data.str.str = NULL;
3205
3206         /* Check arguments. */
3207         MAY_LJMP(hlua_lua2arg_check(L, 2, args, f->arg_mask, hsmp->p));
3208
3209         /* Run the special args checker. */
3210         if (f->val_args && !f->val_args(args, NULL)) {
3211                 lua_pushfstring(L, "error in arguments");
3212                 WILL_LJMP(lua_error(L));
3213         }
3214
3215         /* Initialise the sample. */
3216         memset(&smp, 0, sizeof(smp));
3217
3218         /* Run the sample fetch process. */
3219         smp_set_owner(&smp, hsmp->p, hsmp->s->sess, hsmp->s, hsmp->dir & SMP_OPT_DIR);
3220         if (!f->process(args, &smp, f->kw, f->private)) {
3221                 if (hsmp->flags & HLUA_F_AS_STRING)
3222                         lua_pushstring(L, "");
3223                 else
3224                         lua_pushnil(L);
3225                 return 1;
3226         }
3227
3228         /* Convert the returned sample in lua value. */
3229         if (hsmp->flags & HLUA_F_AS_STRING)
3230                 hlua_smp2lua_str(L, &smp);
3231         else
3232                 hlua_smp2lua(L, &smp);
3233         return 1;
3234 }
3235
3236 /*
3237  *
3238  *
3239  * Class Converters
3240  *
3241  *
3242  */
3243
3244 /* Returns a struct hlua_session if the stack entry "ud" is
3245  * a class stream, otherwise it throws an error.
3246  */
3247 __LJMP static struct hlua_smp *hlua_checkconverters(lua_State *L, int ud)
3248 {
3249         return MAY_LJMP(hlua_checkudata(L, ud, class_converters_ref));
3250 }
3251
3252 /* This function creates and push in the stack a Converters object
3253  * according with a current TXN.
3254  */
3255 static int hlua_converters_new(lua_State *L, struct hlua_txn *txn, unsigned int flags)
3256 {
3257         struct hlua_smp *hsmp;
3258
3259         /* Check stack size. */
3260         if (!lua_checkstack(L, 3))
3261                 return 0;
3262
3263         /* Create the object: obj[0] = userdata.
3264          * Note that the base of the Converters object is the
3265          * same than the TXN object.
3266          */
3267         lua_newtable(L);
3268         hsmp = lua_newuserdata(L, sizeof(*hsmp));
3269         lua_rawseti(L, -2, 0);
3270
3271         hsmp->s = txn->s;
3272         hsmp->p = txn->p;
3273         hsmp->dir = txn->dir;
3274         hsmp->flags = flags;
3275
3276         /* Pop a class stream metatable and affect it to the table. */
3277         lua_rawgeti(L, LUA_REGISTRYINDEX, class_converters_ref);
3278         lua_setmetatable(L, -2);
3279
3280         return 1;
3281 }
3282
3283 /* This function is an LUA binding. It is called with each converter.
3284  * It uses closure argument to store the associated converter. It
3285  * returns only one argument or throws an error. An error is thrown
3286  * only if an error is encountered during the argument parsing. If
3287  * the converter function function fails, nil is returned.
3288  */
3289 __LJMP static int hlua_run_sample_conv(lua_State *L)
3290 {
3291         struct hlua_smp *hsmp;
3292         struct sample_conv *conv;
3293         struct arg args[ARGM_NBARGS + 1];
3294         int i;
3295         struct sample smp;
3296
3297         /* Get closure arguments. */
3298         conv = lua_touserdata(L, lua_upvalueindex(1));
3299
3300         /* Get traditionnal arguments. */
3301         hsmp = MAY_LJMP(hlua_checkconverters(L, 1));
3302
3303         /* Get extra arguments. */
3304         for (i = 0; i < lua_gettop(L) - 2; i++) {
3305                 if (i >= ARGM_NBARGS)
3306                         break;
3307                 hlua_lua2arg(L, i + 3, &args[i]);
3308         }
3309         args[i].type = ARGT_STOP;
3310         args[i].data.str.str = NULL;
3311
3312         /* Check arguments. */
3313         MAY_LJMP(hlua_lua2arg_check(L, 3, args, conv->arg_mask, hsmp->p));
3314
3315         /* Run the special args checker. */
3316         if (conv->val_args && !conv->val_args(args, conv, "", 0, NULL)) {
3317                 hlua_pusherror(L, "error in arguments");
3318                 WILL_LJMP(lua_error(L));
3319         }
3320
3321         /* Initialise the sample. */
3322         if (!hlua_lua2smp(L, 2, &smp)) {
3323                 hlua_pusherror(L, "error in the input argument");
3324                 WILL_LJMP(lua_error(L));
3325         }
3326
3327         smp_set_owner(&smp, hsmp->p, hsmp->s->sess, hsmp->s, hsmp->dir & SMP_OPT_DIR);
3328
3329         /* Apply expected cast. */
3330         if (!sample_casts[smp.data.type][conv->in_type]) {
3331                 hlua_pusherror(L, "invalid input argument: cannot cast '%s' to '%s'",
3332                                smp_to_type[smp.data.type], smp_to_type[conv->in_type]);
3333                 WILL_LJMP(lua_error(L));
3334         }
3335         if (sample_casts[smp.data.type][conv->in_type] != c_none &&
3336             !sample_casts[smp.data.type][conv->in_type](&smp)) {
3337                 hlua_pusherror(L, "error during the input argument casting");
3338                 WILL_LJMP(lua_error(L));
3339         }
3340
3341         /* Run the sample conversion process. */
3342         if (!conv->process(args, &smp, conv->private)) {
3343                 if (hsmp->flags & HLUA_F_AS_STRING)
3344                         lua_pushstring(L, "");
3345                 else
3346                         lua_pushnil(L);
3347                 return 1;
3348         }
3349
3350         /* Convert the returned sample in lua value. */
3351         if (hsmp->flags & HLUA_F_AS_STRING)
3352                 hlua_smp2lua_str(L, &smp);
3353         else
3354                 hlua_smp2lua(L, &smp);
3355         return 1;
3356 }
3357
3358 /*
3359  *
3360  *
3361  * Class AppletTCP
3362  *
3363  *
3364  */
3365
3366 /* Returns a struct hlua_txn if the stack entry "ud" is
3367  * a class stream, otherwise it throws an error.
3368  */
3369 __LJMP static struct hlua_appctx *hlua_checkapplet_tcp(lua_State *L, int ud)
3370 {
3371         return MAY_LJMP(hlua_checkudata(L, ud, class_applet_tcp_ref));
3372 }
3373
3374 /* This function creates and push in the stack an Applet object
3375  * according with a current TXN.
3376  */
3377 static int hlua_applet_tcp_new(lua_State *L, struct appctx *ctx)
3378 {
3379         struct hlua_appctx *appctx;
3380         struct stream_interface *si = ctx->owner;
3381         struct stream *s = si_strm(si);
3382         struct proxy *p = s->be;
3383
3384         /* Check stack size. */
3385         if (!lua_checkstack(L, 3))
3386                 return 0;
3387
3388         /* Create the object: obj[0] = userdata.
3389          * Note that the base of the Converters object is the
3390          * same than the TXN object.
3391          */
3392         lua_newtable(L);
3393         appctx = lua_newuserdata(L, sizeof(*appctx));
3394         lua_rawseti(L, -2, 0);
3395         appctx->appctx = ctx;
3396         appctx->htxn.s = s;
3397         appctx->htxn.p = p;
3398
3399         /* Create the "f" field that contains a list of fetches. */
3400         lua_pushstring(L, "f");
3401         if (!hlua_fetches_new(L, &appctx->htxn, 0))
3402                 return 0;
3403         lua_settable(L, -3);
3404
3405         /* Create the "sf" field that contains a list of stringsafe fetches. */
3406         lua_pushstring(L, "sf");
3407         if (!hlua_fetches_new(L, &appctx->htxn, HLUA_F_AS_STRING))
3408                 return 0;
3409         lua_settable(L, -3);
3410
3411         /* Create the "c" field that contains a list of converters. */
3412         lua_pushstring(L, "c");
3413         if (!hlua_converters_new(L, &appctx->htxn, 0))
3414                 return 0;
3415         lua_settable(L, -3);
3416
3417         /* Create the "sc" field that contains a list of stringsafe converters. */
3418         lua_pushstring(L, "sc");
3419         if (!hlua_converters_new(L, &appctx->htxn, HLUA_F_AS_STRING))
3420                 return 0;
3421         lua_settable(L, -3);
3422
3423         /* Pop a class stream metatable and affect it to the table. */
3424         lua_rawgeti(L, LUA_REGISTRYINDEX, class_applet_tcp_ref);
3425         lua_setmetatable(L, -2);
3426
3427         return 1;
3428 }
3429
3430 __LJMP static int hlua_applet_tcp_set_var(lua_State *L)
3431 {
3432         struct hlua_appctx *appctx;
3433         struct stream *s;
3434         const char *name;
3435         size_t len;
3436         struct sample smp;
3437
3438         MAY_LJMP(check_args(L, 3, "set_var"));
3439
3440         /* It is useles to retrieve the stream, but this function
3441          * runs only in a stream context.
3442          */
3443         appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3444         name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3445         s = appctx->htxn.s;
3446
3447         /* Converts the third argument in a sample. */
3448         hlua_lua2smp(L, 3, &smp);
3449
3450         /* Store the sample in a variable. */
3451         smp_set_owner(&smp, s->be, s->sess, s, 0);
3452         vars_set_by_name(name, len, &smp);
3453         return 0;
3454 }
3455
3456 __LJMP static int hlua_applet_tcp_unset_var(lua_State *L)
3457 {
3458         struct hlua_appctx *appctx;
3459         struct stream *s;
3460         const char *name;
3461         size_t len;
3462         struct sample smp;
3463
3464         MAY_LJMP(check_args(L, 2, "unset_var"));
3465
3466         /* It is useles to retrieve the stream, but this function
3467          * runs only in a stream context.
3468          */
3469         appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3470         name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3471         s = appctx->htxn.s;
3472
3473         /* Unset the variable. */
3474         smp_set_owner(&smp, s->be, s->sess, s, 0);
3475         vars_unset_by_name(name, len, &smp);
3476         return 0;
3477 }
3478
3479 __LJMP static int hlua_applet_tcp_get_var(lua_State *L)
3480 {
3481         struct hlua_appctx *appctx;
3482         struct stream *s;
3483         const char *name;
3484         size_t len;
3485         struct sample smp;
3486
3487         MAY_LJMP(check_args(L, 2, "get_var"));
3488
3489         /* It is useles to retrieve the stream, but this function
3490          * runs only in a stream context.
3491          */
3492         appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3493         name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3494         s = appctx->htxn.s;
3495
3496         smp_set_owner(&smp, s->be, s->sess, s, 0);
3497         if (!vars_get_by_name(name, len, &smp)) {
3498                 lua_pushnil(L);
3499                 return 1;
3500         }
3501
3502         return hlua_smp2lua(L, &smp);
3503 }
3504
3505 __LJMP static int hlua_applet_tcp_set_priv(lua_State *L)
3506 {
3507         struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3508         struct stream *s = appctx->htxn.s;
3509         struct hlua *hlua;
3510
3511         /* Note that this hlua struct is from the session and not from the applet. */
3512         if (!s->hlua)
3513                 return 0;
3514         hlua = s->hlua;
3515
3516         MAY_LJMP(check_args(L, 2, "set_priv"));
3517
3518         /* Remove previous value. */
3519         luaL_unref(L, LUA_REGISTRYINDEX, hlua->Mref);
3520
3521         /* Get and store new value. */
3522         lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
3523         hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
3524
3525         return 0;
3526 }
3527
3528 __LJMP static int hlua_applet_tcp_get_priv(lua_State *L)
3529 {
3530         struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3531         struct stream *s = appctx->htxn.s;
3532         struct hlua *hlua;
3533
3534         /* Note that this hlua struct is from the session and not from the applet. */
3535         if (!s->hlua) {
3536                 lua_pushnil(L);
3537                 return 1;
3538         }
3539         hlua = s->hlua;
3540
3541         /* Push configuration index in the stack. */
3542         lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
3543
3544         return 1;
3545 }
3546
3547 /* If expected data not yet available, it returns a yield. This function
3548  * consumes the data in the buffer. It returns a string containing the
3549  * data. This string can be empty.
3550  */
3551 __LJMP static int hlua_applet_tcp_getline_yield(lua_State *L, int status, lua_KContext ctx)
3552 {
3553         struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3554         struct stream_interface *si = appctx->appctx->owner;
3555         int ret;
3556         char *blk1;
3557         int len1;
3558         char *blk2;
3559         int len2;
3560
3561         /* Read the maximum amount of data avalaible. */
3562         ret = co_getline_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
3563
3564         /* Data not yet avalaible. return yield. */
3565         if (ret == 0) {
3566                 si_applet_cant_get(si);
3567                 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_getline_yield, TICK_ETERNITY, 0));
3568         }
3569
3570         /* End of data: commit the total strings and return. */
3571         if (ret < 0) {
3572                 luaL_pushresult(&appctx->b);
3573                 return 1;
3574         }
3575
3576         /* Ensure that the block 2 length is usable. */
3577         if (ret == 1)
3578                 len2 = 0;
3579
3580         /* dont check the max length read and dont check. */
3581         luaL_addlstring(&appctx->b, blk1, len1);
3582         luaL_addlstring(&appctx->b, blk2, len2);
3583
3584         /* Consume input channel output buffer data. */
3585         co_skip(si_oc(si), len1 + len2);
3586         luaL_pushresult(&appctx->b);
3587         return 1;
3588 }
3589
3590 /* Check arguments for the fucntion "hlua_channel_get_yield". */
3591 __LJMP static int hlua_applet_tcp_getline(lua_State *L)
3592 {
3593         struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3594
3595         /* Initialise the string catenation. */
3596         luaL_buffinit(L, &appctx->b);
3597
3598         return MAY_LJMP(hlua_applet_tcp_getline_yield(L, 0, 0));
3599 }
3600
3601 /* If expected data not yet available, it returns a yield. This function
3602  * consumes the data in the buffer. It returns a string containing the
3603  * data. This string can be empty.
3604  */
3605 __LJMP static int hlua_applet_tcp_recv_yield(lua_State *L, int status, lua_KContext ctx)
3606 {
3607         struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3608         struct stream_interface *si = appctx->appctx->owner;
3609         int len = MAY_LJMP(luaL_checkinteger(L, 2));
3610         int ret;
3611         char *blk1;
3612         int len1;
3613         char *blk2;
3614         int len2;
3615
3616         /* Read the maximum amount of data avalaible. */
3617         ret = co_getblk_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
3618
3619         /* Data not yet avalaible. return yield. */
3620         if (ret == 0) {
3621                 si_applet_cant_get(si);
3622                 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
3623         }
3624
3625         /* End of data: commit the total strings and return. */
3626         if (ret < 0) {
3627                 luaL_pushresult(&appctx->b);
3628                 return 1;
3629         }
3630
3631         /* Ensure that the block 2 length is usable. */
3632         if (ret == 1)
3633                 len2 = 0;
3634
3635         if (len == -1) {
3636
3637                 /* If len == -1, catenate all the data avalaile and
3638                  * yield because we want to get all the data until
3639                  * the end of data stream.
3640                  */
3641                 luaL_addlstring(&appctx->b, blk1, len1);
3642                 luaL_addlstring(&appctx->b, blk2, len2);
3643                 co_skip(si_oc(si), len1 + len2);
3644                 si_applet_cant_get(si);
3645                 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
3646
3647         } else {
3648
3649                 /* Copy the fisrt block caping to the length required. */
3650                 if (len1 > len)
3651                         len1 = len;
3652                 luaL_addlstring(&appctx->b, blk1, len1);
3653                 len -= len1;
3654
3655                 /* Copy the second block. */
3656                 if (len2 > len)
3657                         len2 = len;
3658                 luaL_addlstring(&appctx->b, blk2, len2);
3659                 len -= len2;
3660
3661                 /* Consume input channel output buffer data. */
3662                 co_skip(si_oc(si), len1 + len2);
3663
3664                 /* If we are no other data avalaible, yield waiting for new data. */
3665                 if (len > 0) {
3666                         lua_pushinteger(L, len);
3667                         lua_replace(L, 2);
3668                         si_applet_cant_get(si);
3669                         WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_recv_yield, TICK_ETERNITY, 0));
3670                 }
3671
3672                 /* return the result. */
3673                 luaL_pushresult(&appctx->b);
3674                 return 1;
3675         }
3676
3677         /* we never executes this */
3678         hlua_pusherror(L, "Lua: internal error");
3679         WILL_LJMP(lua_error(L));
3680         return 0;
3681 }
3682
3683 /* Check arguments for the fucntion "hlua_channel_get_yield". */
3684 __LJMP static int hlua_applet_tcp_recv(lua_State *L)
3685 {
3686         struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3687         int len = -1;
3688
3689         if (lua_gettop(L) > 2)
3690                 WILL_LJMP(luaL_error(L, "The 'recv' function requires between 1 and 2 arguments."));
3691         if (lua_gettop(L) >= 2) {
3692                 len = MAY_LJMP(luaL_checkinteger(L, 2));
3693                 lua_pop(L, 1);
3694         }
3695
3696         /* Confirm or set the required length */
3697         lua_pushinteger(L, len);
3698
3699         /* Initialise the string catenation. */
3700         luaL_buffinit(L, &appctx->b);
3701
3702         return MAY_LJMP(hlua_applet_tcp_recv_yield(L, 0, 0));
3703 }
3704
3705 /* Append data in the output side of the buffer. This data is immediatly
3706  * sent. The fcuntion returns the ammount of data writed. If the buffer
3707  * cannot contains the data, the function yield. The function returns -1
3708  * if the channel is closed.
3709  */
3710 __LJMP static int hlua_applet_tcp_send_yield(lua_State *L, int status, lua_KContext ctx)
3711 {
3712         size_t len;
3713         struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_tcp(L, 1));
3714         const char *str = MAY_LJMP(luaL_checklstring(L, 2, &len));
3715         int l = MAY_LJMP(luaL_checkinteger(L, 3));
3716         struct stream_interface *si = appctx->appctx->owner;
3717         struct channel *chn = si_ic(si);
3718         int max;
3719
3720         /* Get the max amount of data which can write as input in the channel. */
3721         max = channel_recv_max(chn);
3722         if (max > (len - l))
3723                 max = len - l;
3724
3725         /* Copy data. */
3726         ci_putblk(chn, str + l, max);
3727
3728         /* update counters. */
3729         l += max;
3730         lua_pop(L, 1);
3731         lua_pushinteger(L, l);
3732
3733         /* If some data is not send, declares the situation to the
3734          * applet, and returns a yield.
3735          */
3736         if (l < len) {
3737                 si_applet_cant_put(si);
3738                 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_tcp_send_yield, TICK_ETERNITY, 0));
3739         }
3740
3741         return 1;
3742 }
3743
3744 /* Just a wraper of "hlua_applet_tcp_send_yield". This wrapper permits
3745  * yield the LUA process, and resume it without checking the
3746  * input arguments.
3747  */
3748 __LJMP static int hlua_applet_tcp_send(lua_State *L)
3749 {
3750         MAY_LJMP(check_args(L, 2, "send"));
3751         lua_pushinteger(L, 0);
3752
3753         return MAY_LJMP(hlua_applet_tcp_send_yield(L, 0, 0));
3754 }
3755
3756 /*
3757  *
3758  *
3759  * Class AppletHTTP
3760  *
3761  *
3762  */
3763
3764 /* Returns a struct hlua_txn if the stack entry "ud" is
3765  * a class stream, otherwise it throws an error.
3766  */
3767 __LJMP static struct hlua_appctx *hlua_checkapplet_http(lua_State *L, int ud)
3768 {
3769         return MAY_LJMP(hlua_checkudata(L, ud, class_applet_http_ref));
3770 }
3771
3772 /* This function creates and push in the stack an Applet object
3773  * according with a current TXN.
3774  */
3775 static int hlua_applet_http_new(lua_State *L, struct appctx *ctx)
3776 {
3777         struct hlua_appctx *appctx;
3778         struct hlua_txn htxn;
3779         struct stream_interface *si = ctx->owner;
3780         struct stream *s = si_strm(si);
3781         struct proxy *px = s->be;
3782         struct http_txn *txn = s->txn;
3783         const char *path;
3784         const char *end;
3785         const char *p;
3786
3787         /* Check stack size. */
3788         if (!lua_checkstack(L, 3))
3789                 return 0;
3790
3791         /* Create the object: obj[0] = userdata.
3792          * Note that the base of the Converters object is the
3793          * same than the TXN object.
3794          */
3795         lua_newtable(L);
3796         appctx = lua_newuserdata(L, sizeof(*appctx));
3797         lua_rawseti(L, -2, 0);
3798         appctx->appctx = ctx;
3799         appctx->appctx->ctx.hlua_apphttp.status = 200; /* Default status code returned. */
3800         appctx->appctx->ctx.hlua_apphttp.reason = NULL; /* Use default reason based on status */
3801         appctx->htxn.s = s;
3802         appctx->htxn.p = px;
3803
3804         /* Create the "f" field that contains a list of fetches. */
3805         lua_pushstring(L, "f");
3806         if (!hlua_fetches_new(L, &appctx->htxn, 0))
3807                 return 0;
3808         lua_settable(L, -3);
3809
3810         /* Create the "sf" field that contains a list of stringsafe fetches. */
3811         lua_pushstring(L, "sf");
3812         if (!hlua_fetches_new(L, &appctx->htxn, HLUA_F_AS_STRING))
3813                 return 0;
3814         lua_settable(L, -3);
3815
3816         /* Create the "c" field that contains a list of converters. */
3817         lua_pushstring(L, "c");
3818         if (!hlua_converters_new(L, &appctx->htxn, 0))
3819                 return 0;
3820         lua_settable(L, -3);
3821
3822         /* Create the "sc" field that contains a list of stringsafe converters. */
3823         lua_pushstring(L, "sc");
3824         if (!hlua_converters_new(L, &appctx->htxn, HLUA_F_AS_STRING))
3825                 return 0;
3826         lua_settable(L, -3);
3827
3828         /* Stores the request method. */
3829         lua_pushstring(L, "method");
3830         lua_pushlstring(L, txn->req.chn->buf->p, txn->req.sl.rq.m_l);
3831         lua_settable(L, -3);
3832
3833         /* Stores the http version. */
3834         lua_pushstring(L, "version");
3835         lua_pushlstring(L, txn->req.chn->buf->p + txn->req.sl.rq.v, txn->req.sl.rq.v_l);
3836         lua_settable(L, -3);
3837
3838         /* creates an array of headers. hlua_http_get_headers() crates and push
3839          * the array on the top of the stack.
3840          */
3841         lua_pushstring(L, "headers");
3842         htxn.s = s;
3843         htxn.p = px;
3844         htxn.dir = SMP_OPT_DIR_REQ;
3845         if (!hlua_http_get_headers(L, &htxn, &htxn.s->txn->req))
3846                 return 0;
3847         lua_settable(L, -3);
3848
3849         /* Get path and qs */
3850         path = http_get_path(txn);
3851         if (path) {
3852                 end = txn->req.chn->buf->p + txn->req.sl.rq.u + txn->req.sl.rq.u_l;
3853                 p = path;
3854                 while (p < end && *p != '?')
3855                         p++;
3856
3857                 /* Stores the request path. */
3858                 lua_pushstring(L, "path");
3859                 lua_pushlstring(L, path, p - path);
3860                 lua_settable(L, -3);
3861
3862                 /* Stores the query string. */
3863                 lua_pushstring(L, "qs");
3864                 if (*p == '?')
3865                         p++;
3866                 lua_pushlstring(L, p, end - p);
3867                 lua_settable(L, -3);
3868         }
3869
3870         /* Stores the request path. */
3871         lua_pushstring(L, "length");
3872         lua_pushinteger(L, txn->req.body_len);
3873         lua_settable(L, -3);
3874
3875         /* Create an array of HTTP request headers. */
3876         lua_pushstring(L, "headers");
3877         MAY_LJMP(hlua_http_get_headers(L, &appctx->htxn, &appctx->htxn.s->txn->req));
3878         lua_settable(L, -3);
3879
3880         /* Create an empty array of HTTP request headers. */
3881         lua_pushstring(L, "response");
3882         lua_newtable(L);
3883         lua_settable(L, -3);
3884
3885         /* Pop a class stream metatable and affect it to the table. */
3886         lua_rawgeti(L, LUA_REGISTRYINDEX, class_applet_http_ref);
3887         lua_setmetatable(L, -2);
3888
3889         return 1;
3890 }
3891
3892 __LJMP static int hlua_applet_http_set_var(lua_State *L)
3893 {
3894         struct hlua_appctx *appctx;
3895         struct stream *s;
3896         const char *name;
3897         size_t len;
3898         struct sample smp;
3899
3900         MAY_LJMP(check_args(L, 3, "set_var"));
3901
3902         /* It is useles to retrieve the stream, but this function
3903          * runs only in a stream context.
3904          */
3905         appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3906         name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3907         s = appctx->htxn.s;
3908
3909         /* Converts the third argument in a sample. */
3910         hlua_lua2smp(L, 3, &smp);
3911
3912         /* Store the sample in a variable. */
3913         smp_set_owner(&smp, s->be, s->sess, s, 0);
3914         vars_set_by_name(name, len, &smp);
3915         return 0;
3916 }
3917
3918 __LJMP static int hlua_applet_http_unset_var(lua_State *L)
3919 {
3920         struct hlua_appctx *appctx;
3921         struct stream *s;
3922         const char *name;
3923         size_t len;
3924         struct sample smp;
3925
3926         MAY_LJMP(check_args(L, 2, "unset_var"));
3927
3928         /* It is useles to retrieve the stream, but this function
3929          * runs only in a stream context.
3930          */
3931         appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3932         name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3933         s = appctx->htxn.s;
3934
3935         /* Unset the variable. */
3936         smp_set_owner(&smp, s->be, s->sess, s, 0);
3937         vars_unset_by_name(name, len, &smp);
3938         return 0;
3939 }
3940
3941 __LJMP static int hlua_applet_http_get_var(lua_State *L)
3942 {
3943         struct hlua_appctx *appctx;
3944         struct stream *s;
3945         const char *name;
3946         size_t len;
3947         struct sample smp;
3948
3949         MAY_LJMP(check_args(L, 2, "get_var"));
3950
3951         /* It is useles to retrieve the stream, but this function
3952          * runs only in a stream context.
3953          */
3954         appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3955         name = MAY_LJMP(luaL_checklstring(L, 2, &len));
3956         s = appctx->htxn.s;
3957
3958         smp_set_owner(&smp, s->be, s->sess, s, 0);
3959         if (!vars_get_by_name(name, len, &smp)) {
3960                 lua_pushnil(L);
3961                 return 1;
3962         }
3963
3964         return hlua_smp2lua(L, &smp);
3965 }
3966
3967 __LJMP static int hlua_applet_http_set_priv(lua_State *L)
3968 {
3969         struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3970         struct stream *s = appctx->htxn.s;
3971         struct hlua *hlua;
3972
3973         /* Note that this hlua struct is from the session and not from the applet. */
3974         if (!s->hlua)
3975                 return 0;
3976         hlua = s->hlua;
3977
3978         MAY_LJMP(check_args(L, 2, "set_priv"));
3979
3980         /* Remove previous value. */
3981         luaL_unref(L, LUA_REGISTRYINDEX, hlua->Mref);
3982
3983         /* Get and store new value. */
3984         lua_pushvalue(L, 2); /* Copy the element 2 at the top of the stack. */
3985         hlua->Mref = luaL_ref(L, LUA_REGISTRYINDEX); /* pop the previously pushed value. */
3986
3987         return 0;
3988 }
3989
3990 __LJMP static int hlua_applet_http_get_priv(lua_State *L)
3991 {
3992         struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
3993         struct stream *s = appctx->htxn.s;
3994         struct hlua *hlua;
3995
3996         /* Note that this hlua struct is from the session and not from the applet. */
3997         if (!s->hlua) {
3998                 lua_pushnil(L);
3999                 return 1;
4000         }
4001         hlua = s->hlua;
4002
4003         /* Push configuration index in the stack. */
4004         lua_rawgeti(L, LUA_REGISTRYINDEX, hlua->Mref);
4005
4006         return 1;
4007 }
4008
4009 /* If expected data not yet available, it returns a yield. This function
4010  * consumes the data in the buffer. It returns a string containing the
4011  * data. This string can be empty.
4012  */
4013 __LJMP static int hlua_applet_http_getline_yield(lua_State *L, int status, lua_KContext ctx)
4014 {
4015         struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4016         struct stream_interface *si = appctx->appctx->owner;
4017         struct channel *chn = si_ic(si);
4018         int ret;
4019         char *blk1;
4020         int len1;
4021         char *blk2;
4022         int len2;
4023
4024         /* Maybe we cant send a 100-continue ? */
4025         if (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_100C) {
4026                 ret = ci_putblk(chn, HTTP_100C, strlen(HTTP_100C));
4027                 /* if ret == -2 or -3 the channel closed or the message si too
4028                  * big for the buffers. We cant send anything. So, we ignoring
4029                  * the error, considers that the 100-continue is sent, and try
4030                  * to receive.
4031                  * If ret is -1, we dont have room in the buffer, so we yield.
4032                  */
4033                 if (ret == -1) {
4034                         si_applet_cant_put(si);
4035                         WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_getline_yield, TICK_ETERNITY, 0));
4036                 }
4037                 appctx->appctx->ctx.hlua_apphttp.flags &= ~APPLET_100C;
4038         }
4039
4040         /* Check for the end of the data. */
4041         if (appctx->appctx->ctx.hlua_apphttp.left_bytes <= 0) {
4042                 luaL_pushresult(&appctx->b);
4043                 return 1;
4044         }
4045
4046         /* Read the maximum amount of data avalaible. */
4047         ret = co_getline_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
4048
4049         /* Data not yet avalaible. return yield. */
4050         if (ret == 0) {
4051                 si_applet_cant_get(si);
4052                 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_getline_yield, TICK_ETERNITY, 0));
4053         }
4054
4055         /* End of data: commit the total strings and return. */
4056         if (ret < 0) {
4057                 luaL_pushresult(&appctx->b);
4058                 return 1;
4059         }
4060
4061         /* Ensure that the block 2 length is usable. */
4062         if (ret == 1)
4063                 len2 = 0;
4064
4065         /* Copy the fisrt block caping to the length required. */
4066         if (len1 > appctx->appctx->ctx.hlua_apphttp.left_bytes)
4067                 len1 = appctx->appctx->ctx.hlua_apphttp.left_bytes;
4068         luaL_addlstring(&appctx->b, blk1, len1);
4069         appctx->appctx->ctx.hlua_apphttp.left_bytes -= len1;
4070
4071         /* Copy the second block. */
4072         if (len2 > appctx->appctx->ctx.hlua_apphttp.left_bytes)
4073                 len2 = appctx->appctx->ctx.hlua_apphttp.left_bytes;
4074         luaL_addlstring(&appctx->b, blk2, len2);
4075         appctx->appctx->ctx.hlua_apphttp.left_bytes -= len2;
4076
4077         /* Consume input channel output buffer data. */
4078         co_skip(si_oc(si), len1 + len2);
4079         luaL_pushresult(&appctx->b);
4080         return 1;
4081 }
4082
4083 /* Check arguments for the fucntion "hlua_channel_get_yield". */
4084 __LJMP static int hlua_applet_http_getline(lua_State *L)
4085 {
4086         struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4087
4088         /* Initialise the string catenation. */
4089         luaL_buffinit(L, &appctx->b);
4090
4091         return MAY_LJMP(hlua_applet_http_getline_yield(L, 0, 0));
4092 }
4093
4094 /* If expected data not yet available, it returns a yield. This function
4095  * consumes the data in the buffer. It returns a string containing the
4096  * data. This string can be empty.
4097  */
4098 __LJMP static int hlua_applet_http_recv_yield(lua_State *L, int status, lua_KContext ctx)
4099 {
4100         struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
4101         struct stream_interface *si = appctx->appctx->owner;
4102         int len = MAY_LJMP(luaL_checkinteger(L, 2));
4103         struct channel *chn = si_ic(si);
4104         int ret;
4105         char *blk1;
4106         int len1;
4107         char *blk2;
4108         int len2;
4109
4110         /* Maybe we cant send a 100-continue ? */
4111         if (appctx->appctx->ctx.hlua_apphttp.flags & APPLET_100C) {
4112                 ret = ci_putblk(chn, HTTP_100C, strlen(HTTP_100C));
4113                 /* if ret == -2 or -3 the channel closed or the message si too
4114                  * big for the buffers. We cant send anything. So, we ignoring
4115                  * the error, considers that the 100-continue is sent, and try
4116                  * to receive.
4117                  * If ret is -1, we dont have room in the buffer, so we yield.
4118                  */
4119                 if (ret == -1) {
4120                         si_applet_cant_put(si);
4121                         WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_recv_yield, TICK_ETERNITY, 0));
4122                 }
4123                 appctx->appctx->ctx.hlua_apphttp.flags &= ~APPLET_100C;
4124         }
4125
4126         /* Read the maximum amount of data avalaible. */
4127         ret = co_getblk_nc(si_oc(si), &blk1, &len1, &blk2, &len2);
4128
4129         /* Data not yet avalaible. return yield. */
4130         if (ret == 0) {
4131                 si_applet_cant_get(si);
4132                 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_recv_yield, TICK_ETERNITY, 0));
4133         }
4134
4135         /* End of data: commit the total strings and return. */
4136         if (ret < 0) {
4137                 luaL_pushresult(&appctx->b);
4138                 return 1;
4139         }
4140
4141         /* Ensure that the block 2 length is usable. */
4142         if (ret == 1)
4143                 len2 = 0;
4144
4145         /* Copy the fisrt block caping to the length required. */
4146         if (len1 > len)
4147                 len1 = len;
4148         luaL_addlstring(&appctx->b, blk1, len1);
4149         len -= len1;
4150
4151         /* Copy the second block. */
4152         if (len2 > len)
4153                 len2 = len;
4154         luaL_addlstring(&appctx->b, blk2, len2);
4155         len -= len2;
4156
4157         /* Consume input channel output buffer data. */
4158         co_skip(si_oc(si), len1 + len2);
4159         if (appctx->appctx->ctx.hlua_apphttp.left_bytes != -1)
4160                 appctx->appctx->ctx.hlua_apphttp.left_bytes -= len;
4161
4162         /* If we are no other data avalaible, yield waiting for new data. */
4163         if (len > 0) {
4164                 lua_pushinteger(L, len);
4165                 lua_replace(L, 2);
4166                 si_applet_cant_get(si);
4167                 WILL_LJMP(hlua_yieldk(L, 0, 0, hlua_applet_http_recv_yield, TICK_ETERNITY, 0));
4168         }
4169
4170         /* return the result. */
4171         luaL_pushresult(&appctx->b);
4172         return 1;
4173 }
4174
4175 /* Check arguments for the fucntion "hlua_channel_get_yield". */
4176 __LJMP static int hlua_applet_http_recv(lua_State *L)
4177 {