1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
/*
* include/haproxy/mux_fcgi-t.h
* Definitions for basic FCGI mux internal types, constants and flags.
*
* Copyright 2022 Christopher Faulet <cfaulet@haproxy.com>
*
* 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_MUX_FCGI_T_H
#define _HAPROXY_MUX_FCGI_T_H
#include <haproxy/api-t.h>
#include <haproxy/show_flags-t.h>
/**** FCGI connection flags (32 bit), in fcgi_conn->flags ****/
#define FCGI_CF_NONE 0x00000000
/* Flags indicating why writing to the mux is blocked */
#define FCGI_CF_MUX_MALLOC 0x00000001 /* mux is blocked on lack connection's mux buffer */
#define FCGI_CF_MUX_MFULL 0x00000002 /* mux is blocked on connection's mux buffer full */
#define FCGI_CF_MUX_BLOCK_ANY 0x00000003 /* mux is blocked on connection's mux buffer full */
/* Flags indicating why writing to the demux is blocked.
* The first two ones directly affect the ability for the mux to receive data
* from the connection. The other ones affect the mux's ability to demux
* received data.
*/
#define FCGI_CF_DEM_DALLOC 0x00000004 /* demux blocked on lack of connection's demux buffer */
#define FCGI_CF_DEM_DFULL 0x00000008 /* demux blocked on connection's demux buffer full */
#define FCGI_CF_DEM_MROOM 0x00000010 /* demux blocked on lack of room in mux buffer */
#define FCGI_CF_DEM_SALLOC 0x00000020 /* demux blocked on lack of stream's rx buffer */
#define FCGI_CF_DEM_SFULL 0x00000040 /* demux blocked on stream request buffer full */
#define FCGI_CF_DEM_TOOMANY 0x00000080 /* demux blocked waiting for some stream connectors to leave */
#define FCGI_CF_DEM_BLOCK_ANY 0x000000F0 /* aggregate of the demux flags above except DALLOC/DFULL */
/* Other flags */
#define FCGI_CF_MPXS_CONNS 0x00000100 /* connection multiplexing is supported */
#define FCGI_CF_ABRTS_SENT 0x00000200 /* a record ABORT was successfully sent to all active streams */
#define FCGI_CF_ABRTS_FAILED 0x00000400 /* failed to abort processing of all streams */
#define FCGI_CF_WAIT_FOR_HS 0x00000800 /* We did check that at least a stream was waiting for handshake */
#define FCGI_CF_KEEP_CONN 0x00001000 /* HAProxy is responsible to close the connection */
#define FCGI_CF_GET_VALUES 0x00002000 /* retrieve settings */
#define FCGI_CF_EOS 0x00004000 /* End-of-stream seen on the H1 connection (read0 detected) */
#define FCGI_CF_ERR_PENDING 0x00008000 /* A write error was detected (block sends but not reads) */
#define FCGI_CF_ERROR 0x00010000 /* A read error was detected (handled has an abort) */
/* 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 *fconn_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 */
_(FCGI_CF_MUX_MALLOC, _(FCGI_CF_MUX_MFULL,
_(FCGI_CF_DEM_DALLOC, _(FCGI_CF_DEM_DFULL, _(FCGI_CF_DEM_MROOM,
_(FCGI_CF_DEM_SALLOC, _(FCGI_CF_DEM_SFULL, _(FCGI_CF_DEM_TOOMANY,
_(FCGI_CF_MPXS_CONNS, _(FCGI_CF_ABRTS_SENT, _(FCGI_CF_ABRTS_FAILED,
_(FCGI_CF_WAIT_FOR_HS, _(FCGI_CF_KEEP_CONN, _(FCGI_CF_GET_VALUES,
_(FCGI_CF_EOS, _(FCGI_CF_ERR_PENDING, _(FCGI_CF_ERROR)))))))))))))))));
/* epilogue */
_(~0U);
return buf;
#undef _
}
/**** FCGI stream flags (32 bit), in fcgi_strm->flags ****/
#define FCGI_SF_NONE 0x00000000
#define FCGI_SF_ES_RCVD 0x00000001 /* end-of-stream received (empty STDOUT or EDN_REQUEST record) */
#define FCGI_SF_ES_SENT 0x00000002 /* end-of-stream sent (empty STDIN record) */
#define FCGI_SF_EP_SENT 0x00000004 /* end-of-param sent (empty PARAMS record) */
#define FCGI_SF_ABRT_SENT 0x00000008 /* abort sent (ABORT_REQUEST record) */
/* Stream flags indicating the reason the stream is blocked */
#define FCGI_SF_BLK_MBUSY 0x00000010 /* blocked waiting for mux access (transient) */
#define FCGI_SF_BLK_MROOM 0x00000020 /* blocked waiting for room in the mux */
#define FCGI_SF_BLK_ANY 0x00000030 /* any of the reasons above */
#define FCGI_SF_BEGIN_SENT 0x00000100 /* a BEGIN_REQUEST record was sent for this stream */
#define FCGI_SF_OUTGOING_DATA 0x00000200 /* set whenever we've seen outgoing data */
#define FCGI_SF_NOTIFIED 0x00000400 /* a paused stream was notified to try to send again */
#define FCGI_SF_WANT_SHUTR 0x00001000 /* a stream couldn't shutr() (mux full/busy) */
#define FCGI_SF_WANT_SHUTW 0x00002000 /* a stream couldn't shutw() (mux full/busy) */
/* 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 *fstrm_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 */
_(FCGI_SF_ES_RCVD, _(FCGI_SF_ES_SENT, _(FCGI_SF_EP_SENT, _(FCGI_SF_ABRT_SENT,
_(FCGI_SF_BLK_MBUSY, _(FCGI_SF_BLK_MROOM,
_(FCGI_SF_BEGIN_SENT, _(FCGI_SF_OUTGOING_DATA, _(FCGI_SF_NOTIFIED,
_(FCGI_SF_WANT_SHUTR, _(FCGI_SF_WANT_SHUTW)))))))))));
/* epilogue */
_(~0U);
return buf;
#undef _
}
/* FCGI connection state (fcgi_conn->state) */
enum fcgi_conn_st {
FCGI_CS_INIT = 0, /* init done, waiting for sending GET_VALUES record */
FCGI_CS_SETTINGS, /* GET_VALUES sent, waiting for the GET_VALUES_RESULT record */
FCGI_CS_RECORD_H, /* GET_VALUES_RESULT received, waiting for a record header */
FCGI_CS_RECORD_D, /* Record header OK, waiting for a record data */
FCGI_CS_RECORD_P, /* Record processed, remains the padding */
FCGI_CS_CLOSED, /* abort requests if necessary and close the connection ASAP */
FCGI_CS_ENTRIES
} __attribute__((packed));
/* returns a fconn state as an abbreviated 3-letter string, or "???" if unknown */
static inline const char *fconn_st_to_str(enum fcgi_conn_st st)
{
switch (st) {
case FCGI_CS_INIT : return "INI";
case FCGI_CS_SETTINGS : return "STG";
case FCGI_CS_RECORD_H : return "RDH";
case FCGI_CS_RECORD_D : return "RDD";
case FCGI_CS_RECORD_P : return "RDP";
case FCGI_CS_CLOSED : return "CLO";
default : return "???";
}
}
/* FCGI stream state, in fcgi_strm->state */
enum fcgi_strm_st {
FCGI_SS_IDLE = 0,
FCGI_SS_OPEN,
FCGI_SS_HREM, // half-closed(remote)
FCGI_SS_HLOC, // half-closed(local)
FCGI_SS_ERROR,
FCGI_SS_CLOSED,
FCGI_SS_ENTRIES
} __attribute__((packed));
/* returns a fstrm state as an abbreviated 3-letter string, or "???" if unknown */
static inline const char *fstrm_st_to_str(enum fcgi_strm_st st)
{
switch (st) {
case FCGI_SS_IDLE : return "IDL";
case FCGI_SS_OPEN : return "OPN";
case FCGI_SS_HREM : return "RCL";
case FCGI_SS_HLOC : return "HCL";
case FCGI_SS_ERROR : return "ERR";
case FCGI_SS_CLOSED : return "CLO";
default : return "???";
}
}
#endif /* _HAPROXY_MUX_FCGI_T_H */
|
