/*
 * include/haproxy/stream-t.h
 * This file defines everything related to streams.
 *
 * Copyright (C) 2000-2020 Willy Tarreau - w@1wt.eu
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation, version 2.1
 * exclusively.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef _HAPROXY_STREAM_T_H
#define _HAPROXY_STREAM_T_H

#include <sys/time.h>

#include <haproxy/api-t.h>
#include <haproxy/channel-t.h>
#include <haproxy/stconn-t.h>
#include <haproxy/dynbuf-t.h>
#include <haproxy/filters-t.h>
#include <haproxy/obj_type-t.h>
#include <haproxy/log-t.h>
#include <haproxy/show_flags-t.h>
#include <haproxy/stick_table-t.h>
#include <haproxy/vars-t.h>


/* Various Stream Flags, bits values 0x01 to 0x100 (shift 0).
 * Please also update the txn_show_flags() function below in case of changes.
 */
#define SF_DIRECT	0x00000001	/* connection made on the server matching the client cookie */
#define SF_ASSIGNED	0x00000002	/* no need to assign a server to this stream */
#define SF_MAYALLOC     0x00000004      /* we were notified that a work buffer might be available now */
#define SF_BE_ASSIGNED	0x00000008	/* a backend was assigned. Conns are accounted. */

#define SF_FORCE_PRST	0x00000010	/* force persistence here, even if server is down */
#define SF_MONITOR	0x00000020	/* this stream comes from a monitoring system */
#define SF_CURR_SESS	0x00000040	/* a connection is currently being counted on the server */
#define SF_CONN_EXP     0x00000080      /* timeout has expired */
#define SF_REDISP	0x00000100	/* set if this stream was redispatched from one server to another */
#define SF_IGNORE	0x00000200      /* The stream lead to a mux upgrade, and should be ignored */
#define SF_REDIRECTABLE	0x00000400	/* set if this stream is redirectable (GET or HEAD) */
#define SF_HTX          0x00000800      /* set if this stream is an htx stream */

/* stream termination conditions, bits values 0x1000 to 0x7000 (0-9 shift 12) */
#define SF_ERR_NONE     0x00000000	/* normal end of request */
#define SF_ERR_LOCAL    0x00001000	/* the proxy locally processed this request => not an error */
#define SF_ERR_CLITO    0x00002000	/* client time-out */
#define SF_ERR_CLICL    0x00003000	/* client closed (read/write error) */
#define SF_ERR_SRVTO    0x00004000	/* server time-out, connect time-out */
#define SF_ERR_SRVCL    0x00005000	/* server closed (connect/read/write error) */
#define SF_ERR_PRXCOND  0x00006000	/* the proxy decided to close (deny...) */
#define SF_ERR_RESOURCE 0x00007000	/* the proxy encountered a lack of a local resources (fd, mem, ...) */
#define SF_ERR_INTERNAL 0x00008000	/* the proxy encountered an internal error */
#define SF_ERR_DOWN     0x00009000	/* the proxy killed a stream because the backend became unavailable */
#define SF_ERR_KILLED   0x0000a000	/* the proxy killed a stream because it was asked to do so */
#define SF_ERR_UP       0x0000b000	/* the proxy killed a stream because a preferred backend became available */
#define SF_ERR_CHK_PORT 0x0000c000	/* no port could be found for a health check. TODO: check SF_ERR_SHIFT */
#define SF_ERR_MASK     0x0000f000	/* mask to get only stream error flags */
#define SF_ERR_SHIFT    12		/* bit shift */

/* stream state at termination, bits values 0x10000 to 0x70000 (0-7 shift 16) */
#define SF_FINST_R	0x00010000	/* stream ended during client request */
#define SF_FINST_C	0x00020000	/* stream ended during server connect */
#define SF_FINST_H	0x00030000	/* stream ended during server headers */
#define SF_FINST_D	0x00040000	/* stream ended during data phase */
#define SF_FINST_L	0x00050000	/* stream ended while pushing last data to client */
#define SF_FINST_Q	0x00060000	/* stream ended while waiting in queue for a server slot */
#define SF_FINST_T	0x00070000	/* stream ended tarpitted */
#define SF_FINST_MASK	0x00070000	/* mask to get only final stream state flags */
#define	SF_FINST_SHIFT	16		/* bit shift */

#define SF_IGNORE_PRST	0x00080000	/* ignore persistence */

#define SF_SRV_REUSED   0x00100000	/* the server-side connection was reused */
#define SF_SRV_REUSED_ANTICIPATED  0x00200000  /* the connection was reused but the mux is not ready yet */
#define SF_WEBSOCKET    0x00400000	/* websocket stream */ // TODO: must be removed
#define SF_SRC_ADDR     0x00800000	/* get the source ip/port with getsockname */
#define SF_BC_MARK      0x01000000	/* need to set specific mark on backend/srv conn upon connect */
#define SF_BC_TOS       0x02000000	/* need to set specific tos on backend/srv conn upon connect */
#define SF_RULE_FYIELD  0x04000000      /* s->current_rule set because of forced yield */

/* This function is used to report flags in debugging tools. Please reflect
 * below any single-bit flag addition above in the same order via the
 * __APPEND_FLAG and __APPEND_ENUM macros. The new end of the buffer is
 * returned.
 */
static forceinline char *strm_show_flags(char *buf, size_t len, const char *delim, uint flg)
{
#define _(f, ...)     __APPEND_FLAG(buf, len, delim, flg, f, #f, __VA_ARGS__)
#define _e(m, e, ...) __APPEND_ENUM(buf, len, delim, flg, m, e, #e, __VA_ARGS__)
	/* prologue */
	_(0);
	/* flags & enums */
	_(SF_IGNORE_PRST, _(SF_SRV_REUSED, _(SF_SRV_REUSED_ANTICIPATED,
	_(SF_WEBSOCKET, _(SF_SRC_ADDR, _(SF_BC_MARK, _(SF_BC_TOS,
	_(SF_RULE_FYIELD))))))));

	_e(SF_FINST_MASK, SF_FINST_R,    _e(SF_FINST_MASK, SF_FINST_C,
	_e(SF_FINST_MASK, SF_FINST_H,    _e(SF_FINST_MASK, SF_FINST_D,
	_e(SF_FINST_MASK, SF_FINST_L,    _e(SF_FINST_MASK, SF_FINST_Q,
	_e(SF_FINST_MASK, SF_FINST_T)))))));

	_e(SF_ERR_MASK, SF_ERR_LOCAL,    _e(SF_ERR_MASK, SF_ERR_CLITO,
	_e(SF_ERR_MASK, SF_ERR_CLICL,    _e(SF_ERR_MASK, SF_ERR_SRVTO,
	_e(SF_ERR_MASK, SF_ERR_SRVCL,    _e(SF_ERR_MASK, SF_ERR_PRXCOND,
	_e(SF_ERR_MASK, SF_ERR_RESOURCE, _e(SF_ERR_MASK, SF_ERR_INTERNAL,
	_e(SF_ERR_MASK, SF_ERR_DOWN,     _e(SF_ERR_MASK, SF_ERR_KILLED,
	_e(SF_ERR_MASK, SF_ERR_UP,       _e(SF_ERR_MASK, SF_ERR_CHK_PORT))))))))))));

	_(SF_DIRECT, _(SF_ASSIGNED, _(SF_MAYALLOC, _(SF_BE_ASSIGNED, _(SF_FORCE_PRST,
	_(SF_MONITOR, _(SF_CURR_SESS, _(SF_CONN_EXP, _(SF_REDISP,
	_(SF_IGNORE, _(SF_REDIRECTABLE, _(SF_HTX))))))))))));

	/* epilogue */
	_(~0U);
	return buf;
#undef _e
#undef _
}


/* flags for the proxy of the master CLI */
/* 0x0001.. to 0x4000 are reserved for ACCESS_* flags from cli-t.h */

#define PCLI_F_BIDIR    0x08000 /* communicate with worker in bidirectional mode (forward till close) */
#define PCLI_F_PROMPT   0x10000
#define PCLI_F_PAYLOAD  0x20000
#define PCLI_F_RELOAD   0x40000 /* this is the "reload" stream, quits after displaying reload status */
#define PCLI_F_TIMED    0x80000 /* the prompt shows the process' uptime */


/* error types reported on the streams for more accurate reporting.
 * Please also update the strm_et_show_flags() function below in case of changes.
 */
enum {
	STRM_ET_NONE       = 0x0000,  /* no error yet, leave it to zero */
	STRM_ET_QUEUE_TO   = 0x0001,  /* queue timeout */
	STRM_ET_QUEUE_ERR  = 0x0002,  /* queue error (eg: full) */
	STRM_ET_QUEUE_ABRT = 0x0004,  /* aborted in queue by external cause */
	STRM_ET_CONN_TO    = 0x0008,  /* connection timeout */
	STRM_ET_CONN_ERR   = 0x0010,  /* connection error (eg: no server available) */
	STRM_ET_CONN_ABRT  = 0x0020,  /* connection aborted by external cause (eg: abort) */
	STRM_ET_CONN_RES   = 0x0040,  /* connection aborted due to lack of resources */
	STRM_ET_CONN_OTHER = 0x0080,  /* connection aborted for other reason (eg: 500) */
	STRM_ET_DATA_TO    = 0x0100,  /* timeout during data phase */
	STRM_ET_DATA_ERR   = 0x0200,  /* error during data phase */
	STRM_ET_DATA_ABRT  = 0x0400,  /* data phase aborted by external cause */
};


/* Types of entities that may interrupt a processing, teomporarily or not
 * depending on the context;
 */
enum {
	STRM_ENTITY_NONE      = 0x0000,
	STRM_ENTITY_RULE      = 0x0001,
	STRM_ENTITY_FILTER    = 0x0002,
	STRM_ENTITY_WREQ_BODY = 0x0003,
};

/* All possible stream events handled by process_stream(). First ones are mapped
 * from TASK_WOKEN_*.
 */
enum {
	STRM_EVT_NONE          = 0x00000000, /* No events */
	STRM_EVT_TIMER         = 0x00000001, /* A timer has expired */
	STRM_EVT_MSG           = 0x00000002, /* A message event was triggered  */
	STRM_EVT_SHUT_SRV_DOWN = 0x00000004, /* Must be shut because the selected server became available */
	STRM_EVT_SHUT_SRV_UP   = 0x00000008, /* Must be shut because a preferred server became available */
	STRM_EVT_KILLED        = 0x00000010, /* Must be shut for external reason */
	STRM_EVT_RES           = 0x00000020, /* A requested resource is available (a buffer, a conn_slot...) */
};

/* This function is used to report flags in debugging tools. Please reflect
 * below any single-bit flag addition above in the same order via the
 * __APPEND_FLAG macro. The new end of the buffer is returned.
 */
static forceinline char *strm_et_show_flags(char *buf, size_t len, const char *delim, uint flg)
{
#define _(f, ...) __APPEND_FLAG(buf, len, delim, flg, f, #f, __VA_ARGS__)
	/* prologue */
	_(0);
	/* flags */
	_(STRM_ET_QUEUE_TO, _(STRM_ET_QUEUE_ERR, _(STRM_ET_QUEUE_ABRT,
	_(STRM_ET_CONN_TO, _(STRM_ET_CONN_ERR, _(STRM_ET_CONN_ABRT,
	_(STRM_ET_CONN_RES, _(STRM_ET_CONN_OTHER, _(STRM_ET_DATA_TO,
	_(STRM_ET_DATA_ERR, _(STRM_ET_DATA_ABRT)))))))))));
	/* epilogue */
	_(~0U);
	return buf;
#undef _
}

struct hlua;
struct proxy;
struct pendconn;
struct session;
struct server;
struct task;
struct sockaddr_storage;

/* some external definitions */
struct strm_logs {
	int logwait;                    /* log fields waiting to be collected : LW_* */
	int level;                      /* log level to force + 1 if > 0, -1 = no log */
	struct timeval accept_date;     /* date of the stream's accept() in user date */
	ullong accept_ts;               /* date of the session's accept() in internal date (monotonic) */
	long t_handshake;               /* handshake duration, -1 if never occurs */
	long t_idle;                    /* idle duration, -1 if never occurs */
	ullong request_ts;              /* date when the request arrives in internal date */
	long  t_queue;                  /* delay before the stream gets out of the connect queue, -1 if never occurs */
	long  t_connect;                /* delay before the connect() to the server succeeds, -1 if never occurs */
	long  t_data;                   /* delay before the first data byte from the server ... */
	unsigned long t_close;          /* total stream duration */
	unsigned long srv_queue_pos;    /* number of streams de-queued while waiting for a connection slot on this server */
	unsigned long prx_queue_pos;    /* number of streams de-qeuued while waiting for a connection slot on this instance */
	long long req_in;               /* number of bytes received from the client */
	long long req_out;              /* number of bytes sent to the server */
	long long res_in;               /* number of bytes received from the server */
	long long res_out;              /* number of bytes sent to the client */
};

struct stream {
	enum obj_type obj_type;         /* object type == OBJ_TYPE_STREAM */
	enum sc_state prev_conn_state;  /* CS_ST*, copy of previous state of the server stream connector */

	int16_t priority_class;         /* priority class of the stream for the pending queue */
	int32_t priority_offset;        /* priority offset of the stream for the pending queue */

	int flags;                      /* some flags describing the stream */
	unsigned int uniq_id;           /* unique ID used for the traces */
	uint32_t bc_mark;               /* set mark on back conn if SF_BC_MARK is set */
	uint8_t bc_tos;                 /* set tos on back conn if SF_BC_TOS is set */
	/* 3 unused bytes here */
	enum obj_type *target;          /* target to use for this stream */

	struct session *sess;           /* the session this stream is attached to */

	struct channel req;             /* request channel */
	struct channel res;             /* response channel */

	struct proxy *be;               /* the proxy this stream depends on for the server side */

	struct server *srv_conn;        /* stream already has a slot on a server and is not in queue */
	struct pendconn *pend_pos;      /* if not NULL, points to the pending position in the pending queue */

	struct http_txn *txn;           /* current HTTP transaction being processed. Should become a list. */

	struct task *task;              /* the task associated with this stream */
	unsigned int pending_events;	/* the pending events not yet processed by the stream but handled by process_stream() */
	unsigned int new_events;        /* the new events added since the previous wakeup (never seen by process_stream()). It is atomic field */
	int conn_retries;               /* number of connect retries performed */
	unsigned int conn_exp;          /* wake up time for connect, queue, turn-around, ... */
	unsigned int conn_err_type;     /* first error detected, one of STRM_ET_* */

	uint32_t rules_bcount;          /* number of rules evaluated since last yield */

	struct stream *parent;          /* Pointer to the parent stream, if any. NULL most of time */

	struct list list;               /* position in the thread's streams list */
	struct mt_list by_srv;          /* position in server stream list */
	struct list back_refs;          /* list of users tracking this stream */
	struct buffer_wait buffer_wait; /* position in the list of objects waiting for a buffer */

	uint64_t lat_time;		/* total latency time experienced */
	uint64_t cpu_time;              /* total CPU time consumed */
	struct freq_ctr call_rate;      /* stream task call rate without making progress */
	uint32_t passes_connect;        /* number of passes on the connect processing loop */
	uint32_t passes_stconn;         /* number of passes on the stconn evaluation code */
	uint32_t passes_reqana;         /* number of passes on the req analysers block */
	uint32_t passes_resana;         /* number of passes on the res analysers block */
	uint32_t passes_propag;         /* number of passes on the shut/err propag code */
	/* 4 unused bytes here */

	unsigned short max_retries;     /* Maximum number of connection retried (=0 is backend is not set) */
	short store_count;

	struct {
		struct stksess *ts;
		struct stktable *table;
	} store[8];                     /* tracked stickiness values to store */

	struct stkctr *stkctr;                  /* content-aware stick counters */

	struct strm_flt strm_flt;               /* current state of filters active on this stream */

	char **req_cap;                         /* array of captures from the request (may be NULL) */
	char **res_cap;                         /* array of captures from the response (may be NULL) */
	struct vars vars_txn;                   /* list of variables for the txn scope. */
	struct vars vars_reqres;                /* list of variables for the request and resp scope. */

	struct stconn *scf;                     /* frontend stream connector */
	struct stconn *scb;                     /* backend stream connector */

	struct strm_logs logs;                  /* logs for this stream */

	void (*do_log)(struct stream *s,        /* the function to call in order to log (or NULL) */
	               struct log_orig origin);
	void (*srv_error)(struct stream *s,     /* the function to call upon unrecoverable server errors (or NULL) */
			  struct stconn *sc);

	int pcli_next_pid;                      /* next target PID to use for the CLI proxy */
	int pcli_flags;                         /* flags for CLI proxy */
	char pcli_payload_pat[8];               /* payload pattern for the CLI proxy */

	struct ist unique_id;                   /* custom unique ID */

	/* These two pointers are used to resume the execution of the rule lists. */
	struct list *current_rule_list;         /* this is used to store the current executed rule list. */
	void *current_rule;                     /* this is used to store the current rule to be resumed. */
	int rules_exp;                          /* expiration date for current rules execution */
	int tunnel_timeout;

	struct {
		void *ptr;                      /* Pointer on the entity  (def: NULL) */
		int type;                       /* entity type (STRM_ENTITY_*) */
	} last_entity;                          /* last evaluated entity that interrupted processing */

	struct {
		void *ptr;                      /* Pointer on the entity  (def: NULL) */
		int type;                       /* entity type (STRM_ENTITY_*) */
	} waiting_entity;                       /* The entity waiting to continue its processing and interrupted by an error/timeout */

	unsigned int stream_epoch;              /* copy of stream_epoch when the stream was created */
	uint32_t term_evts_log;                 /* termination events log */
	struct hlua *hlua[2];                   /* lua runtime context (0: global, 1: per-thread) */

	/* Context */
	struct {
		struct resolv_requester *requester; /* owner of the resolution */
		struct act_rule *parent;        /* rule which requested this resolution */
		char *hostname_dn;              /* hostname being resolve, in domain name format */
		int hostname_dn_len;            /* size of hostname_dn */
		/* 4 unused bytes here, recoverable via packing if needed */
	} resolv_ctx;                           /* context information for DNS resolution */
	struct be_counters_shared_tg *be_tgcounters; /* pointer to current thread group shared backend counters */
	struct be_counters_shared_tg *sv_tgcounters; /* pointer to current thread group shared server counters */
};

#endif /* _HAPROXY_STREAM_T_H */

/*
 * Local variables:
 *  c-indent-level: 8
 *  c-basic-offset: 8
 * End:
 */
