ec7c44fb40227e59162d03327f2d93c2250f7a2f
[sip-router] / tcp_conn.h
1 /*
2  * $Id$
3  *
4  * Copyright (C) 2001-2003 FhG Fokus
5  *
6  * This file is part of ser, a free SIP server.
7  *
8  * ser is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version
12  *
13  * For a license to use the ser software under conditions
14  * other than those described here, or to purchase support for this
15  * software, please contact iptel.org by e-mail at the following addresses:
16  *    info@iptel.org
17  *
18  * ser is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
26  *
27  *
28  * History:
29  * --------
30  *  2003-01-29  tcp buffer size ++-ed to allow for 0-terminator
31  *  2003-06-30  added tcp_connection flags & state (andrei) 
32  *  2003-10-27  tcp port aliases support added (andrei)
33  *  2006-10-13  added tcp_req_states for STUN (vlada)
34  *  2007-07-26  improved tcp connection hash function; increased aliases
35  *               hash size (andrei)
36  *  2007-11-26  switched to local_timer (andrei)
37  *  2007-11-30  buffered write support (andrei)
38  */
39
40
41
42 #ifndef _tcp_conn_h
43 #define _tcp_conn_h
44
45 #include "tcp_init.h"
46 #include "tcp_options.h"
47
48 #include "ip_addr.h"
49 #include "locking.h"
50 #include "atomic_ops.h"
51 #include "timer_ticks.h"
52 #include "timer.h"
53
54 /* maximum number of port aliases x search wildcard possibilities */
55 #define TCP_CON_MAX_ALIASES (4*3) 
56
57 #define TCP_CHILD_TIMEOUT 5 /* after 5 seconds, the child "returns" 
58                                                          the connection to the tcp master process */
59 #define TCP_MAIN_SELECT_TIMEOUT 5 /* how often "tcp main" checks for timeout*/
60 #define TCP_CHILD_SELECT_TIMEOUT 2 /* the same as above but for children */
61
62
63 /* tcp connection flags */
64 #define F_CONN_READ_W       2 /* watched for READ ev. in main */
65 #define F_CONN_WRITE_W      4 /* watched for WRITE (main) */
66 #define F_CONN_READER       8 /* handled by a tcp reader */
67 #define F_CONN_HASHED      16 /* in tcp_main hash */
68 #define F_CONN_FD_CLOSED   32 /* fd was already closed */
69 #define F_CONN_PENDING     64 /* pending connect  (fd not known yet in main) */
70 #define F_CONN_MAIN_TIMER 128 /* timer active in the tcp_main process */
71 #define F_CONN_EOF_SEEN   256 /* FIN or RST have been received */
72 #define F_CONN_FORCE_EOF  512 /* act as if an EOF was received */
73 #define F_CONN_OOB_DATA  1024 /* out of band data on the connection */
74 #define F_CONN_WR_ERROR  2048 /* write error on the fd */
75 #define F_CONN_WANTS_RD  4096  /* conn. should be watched for READ */
76 #define F_CONN_WANTS_WR  8192  /* conn. should be watched for WRITE */
77 #define F_CONN_PASSIVE  16384 /* conn. created via accept() and not connect()*/
78 #define F_CONN_WS       32768 /* conn. is a websocket */
79
80 #ifndef NO_READ_HTTP11
81 #define READ_HTTP11
82 #endif
83
84 #ifndef NO_READ_MSRP
85 #define READ_MSRP
86 #endif
87
88 #ifndef NO_READ_WS
89 #define READ_WS
90 #endif
91
92 enum tcp_req_errors {   TCP_REQ_INIT, TCP_REQ_OK, TCP_READ_ERROR,
93                                                 TCP_REQ_OVERRUN, TCP_REQ_BAD_LEN };
94 enum tcp_req_states {   H_SKIP_EMPTY, H_SKIP_EMPTY_CR_FOUND,
95                 H_SKIP_EMPTY_CRLF_FOUND, H_SKIP_EMPTY_CRLFCR_FOUND,
96                 H_SKIP, H_LF, H_LFCR,  H_BODY, H_STARTWS,
97                 H_CONT_LEN1, H_CONT_LEN2, H_CONT_LEN3, H_CONT_LEN4, H_CONT_LEN5,
98                 H_CONT_LEN6, H_CONT_LEN7, H_CONT_LEN8, H_CONT_LEN9, H_CONT_LEN10,
99                 H_CONT_LEN11, H_CONT_LEN12, H_CONT_LEN13, H_L_COLON, 
100                 H_CONT_LEN_BODY, H_CONT_LEN_BODY_PARSE,
101                 H_STUN_MSG, H_STUN_READ_BODY, H_STUN_FP, H_STUN_END, H_PING_CRLF
102 #ifdef READ_HTTP11
103                 , H_HTTP11_CHUNK_START, H_HTTP11_CHUNK_SIZE,
104                 H_HTTP11_CHUNK_BODY, H_HTTP11_CHUNK_END, H_HTTP11_CHUNK_FINISH
105 #endif
106 #ifdef READ_MSRP
107                 , H_MSRP_BODY, H_MSRP_BODY_LF, H_MSRP_BODY_END, H_MSRP_FINISH
108 #endif
109         };
110
111 enum tcp_conn_states { S_CONN_ERROR=-2, S_CONN_BAD=-1,
112                                                 S_CONN_OK=0, /* established (write or read) */
113                                                 S_CONN_INIT, /* initial state (invalid) */
114                                                 S_CONN_EOF,
115                                                 S_CONN_ACCEPT, S_CONN_CONNECT
116                                         };
117
118
119 /* fd communication commands */
120 enum conn_cmds {
121         CONN_DESTROY=-3 /* destroy connection & auto-dec. refcnt */,
122         CONN_ERROR=-2   /* error on connection & auto-dec. refcnt */,
123         CONN_EOF=-1     /* eof received or conn. closed & auto-dec refcnt */,
124         CONN_NOP=0      /* do-nothing (invalid for tcp_main) */,
125         CONN_RELEASE    /* release a connection from tcp_read back into tcp_main
126                                            & auto-dec refcnt */,
127         CONN_GET_FD     /* request a fd from tcp_main */,
128         CONN_NEW        /* update/set a fd int a new tcp connection; refcnts are
129                                           not touched */,
130         CONN_QUEUED_WRITE /* new write queue: start watching the fd for write &
131                                                  auto-dec refcnt */,
132         CONN_NEW_PENDING_WRITE /* like CONN_NEW+CONN_QUEUED_WRITE: set fd and
133                                                           start watching it for write (write queue
134                                                           non-empty); refcnts are not touced */,
135         CONN_NEW_COMPLETE  /* like CONN_NEW_PENDING_WRITE, but there is no
136                                                   pending write (the write queue might be empty) */
137 };
138 /* CONN_RELEASE, EOF, ERROR, DESTROY can be used by "reader" processes
139  * CONN_GET_FD, CONN_NEW*, CONN_QUEUED_WRITE only by writers */
140
141 struct tcp_req{
142         struct tcp_req* next;
143         /* sockaddr ? */
144         char* buf; /* bytes read so far (+0-terminator)*/
145         char* start; /* where the message starts, after all the empty lines are
146                                         skipped*/
147         char* pos; /* current position in buf */
148         char* parsed; /* last parsed position */
149         char* body; /* body position */
150         unsigned int b_size; /* buffer size-1 (extra space for 0-term)*/
151         int content_len;
152 #ifdef READ_HTTP11
153         int chunk_size;
154 #endif
155         unsigned short flags; /* F_TCP_REQ_HAS_CLEN | F_TCP_REQ_COMPLETE */
156         int bytes_to_go; /* how many bytes we have still to read from the body*/
157         enum tcp_req_errors error;
158         enum tcp_req_states state;
159 };
160
161 /* tcp_req flags */
162 #define F_TCP_REQ_HAS_CLEN 1
163 #define F_TCP_REQ_COMPLETE 2
164 #ifdef READ_HTTP11
165 #define F_TCP_REQ_BCHUNKED 4
166 #endif
167 #ifdef READ_MSRP
168 #define F_TCP_REQ_MSRP_NO     8
169 #define F_TCP_REQ_MSRP_FRAME  16
170 #define F_TCP_REQ_MSRP_BODY   32
171 #endif
172
173 #define TCP_REQ_HAS_CLEN(tr)  ((tr)->flags & F_TCP_REQ_HAS_CLEN)
174 #define TCP_REQ_COMPLETE(tr)  ((tr)->flags & F_TCP_REQ_COMPLETE)
175 #ifdef READ_HTTP11
176 #define TCP_REQ_BCHUNKED(tr)  ((tr)->flags & F_TCP_REQ_BCHUNKED)
177 #endif
178
179
180 struct tcp_connection;
181
182 /* tcp port alias structure */
183 struct tcp_conn_alias{
184         struct tcp_connection* parent;
185         struct tcp_conn_alias* next;
186         struct tcp_conn_alias* prev;
187         unsigned short port; /* alias port */
188         unsigned short hash; /* hash index in the address hash */
189 };
190
191
192 #ifdef TCP_ASYNC
193         struct tcp_wbuffer{
194                 struct tcp_wbuffer* next;
195                 unsigned int b_size;
196                 char buf[1];
197         };
198
199         struct tcp_wbuffer_queue{
200                 struct tcp_wbuffer* first;
201                 struct tcp_wbuffer* last;
202                 ticks_t wr_timeout; /* write timeout*/
203                 unsigned int queued; /* total size */
204                 unsigned int offset; /* offset in the first wbuffer were data
205                                                                 starts */
206                 unsigned int last_used; /* how much of the last buffer is used */
207         };
208 #endif
209
210
211 struct tcp_connection{
212         int s; /*socket, used by "tcp main" */
213         int fd; /* used only by "children", don't modify it! private data! */
214         gen_lock_t write_lock;
215         int id; /* id (unique!) used to retrieve a specific connection when
216                    reply-ing*/
217         int reader_pid; /* pid of the active reader process */
218         struct receive_info rcv; /* src & dst ip, ports, proto a.s.o*/
219         struct tcp_req req; /* request data */
220         atomic_t refcnt;
221         enum sip_protos type; /* PROTO_TCP or a protocol over it, e.g. TLS */
222         unsigned short flags; /* connection related flags */
223         snd_flags_t send_flags; /* special send flags */
224         enum tcp_conn_states state; /* connection state */
225         void* extra_data; /* extra data associated to the connection, 0 for tcp*/
226         struct timer_ln timer;
227         ticks_t timeout;/* connection timeout, after this it will be removed*/
228         unsigned id_hash; /* hash index in the id_hash */
229         struct tcp_connection* id_next; /* next, prev in id hash table */
230         struct tcp_connection* id_prev;
231         struct tcp_connection* c_next; /* child next prev (use locally) */
232         struct tcp_connection* c_prev;
233         struct tcp_conn_alias con_aliases[TCP_CON_MAX_ALIASES];
234         int aliases; /* aliases number, at least 1 */
235 #ifdef TCP_ASYNC
236         struct tcp_wbuffer_queue wbuf_q;
237 #endif
238 };
239
240
241 /* helper macros */
242
243 #define tcpconn_set_send_flags(c, snd_flags) \
244         SND_FLAGS_OR(&(c)->send_flags, &(c)->send_flags, &(snd_flags))
245
246 #define tcpconn_close_after_send(c)     ((c)->send_flags.f & SND_F_CON_CLOSE)
247
248 #define TCP_RCV_INFO(c) (&(c)->rcv)
249
250 #define TCP_RCV_LADDR(r) (&((r).dst_ip))
251 #define TCP_RCV_LPORT(r) ((r).dst_port)
252 #define TCP_RCV_PADDR(r)  (&((r).src_ip))
253 #define TCP_RCV_PPORT(r)  ((r).src_port)
254 #define TCP_RCV_PSU(r)   (&(r).src_su)
255 #define TCP_RCV_SOCK_INFO(r)  ((r).bind_address)
256 #define TCP_RCV_PROTO(r)      ((r).proto)
257 #ifdef USE_COMP
258 #define TCP_RCV_COMP(r)       ((r).comp)
259 #else
260 #define TCP_RCV_COMP(r)  0
261 #endif /* USE_COMP */
262
263 #define TCP_LADDR(c) TCP_RCV_LADDR(c->rcv)
264 #define TCP_LPORT(c) TCP_RCV_LPORT(c->rcv)
265 #define TCP_PADDR(c) TCP_RCV_PADDR(c->rcv)
266 #define TCP_PPORT(c) TCP_RCV_PPORT(c->rcv)
267 #define TCP_PSU(c)   TCP_RCV_PSU(c->rcv)
268 #define TCP_SOCK_INFO(c) TCP_RCV_SOCK_INFO(c->rcv)
269 #define TCP_PROTO(c) TCP_RCV_PROTO(c->rcv)
270 #define TCP_COMP(c) TCP_RCV_COMP(c->rcv)
271
272
273
274 #define tcpconn_ref(c) atomic_inc(&((c)->refcnt))
275 #define tcpconn_put(c) atomic_dec_and_test(&((c)->refcnt))
276
277
278 #define init_tcp_req( r, rd_buf, rd_buf_size) \
279         do{ \
280                 memset( (r), 0, sizeof(struct tcp_req)); \
281                 (r)->buf=(rd_buf) ;\
282                 (r)->b_size=(rd_buf_size)-1; /* space for 0 term. */ \
283                 (r)->parsed=(r)->pos=(r)->start=(r)->buf; \
284                 (r)->error=TCP_REQ_OK;\
285                 (r)->state=H_SKIP_EMPTY; \
286         }while(0)
287
288
289 /* add a tcpconn to a list*/
290 /* list head, new element, next member, prev member */
291 #define tcpconn_listadd(head, c, next, prev) \
292         do{ \
293                 /* add it at the begining of the list*/ \
294                 (c)->next=(head); \
295                 (c)->prev=0; \
296                 if ((head)) (head)->prev=(c); \
297                 (head)=(c); \
298         } while(0)
299
300
301 /* remove a tcpconn from a list*/
302 #define tcpconn_listrm(head, c, next, prev) \
303         do{ \
304                 if ((head)==(c)) (head)=(c)->next; \
305                 if ((c)->next) (c)->next->prev=(c)->prev; \
306                 if ((c)->prev) (c)->prev->next=(c)->next; \
307         }while(0)
308
309
310 #define TCPCONN_LOCK lock_get(tcpconn_lock);
311 #define TCPCONN_UNLOCK lock_release(tcpconn_lock);
312
313 #define TCP_ALIAS_HASH_SIZE 4096
314 #define TCP_ID_HASH_SIZE 1024
315
316 /* hash (dst_ip, dst_port, local_ip, local_port) */
317 static inline unsigned tcp_addr_hash(   struct ip_addr* ip, 
318                                                                                 unsigned short port,
319                                                                                 struct ip_addr* l_ip,
320                                                                                 unsigned short l_port)
321 {
322         unsigned h;
323
324         if(ip->len==4)
325                 h=(ip->u.addr32[0]^port)^(l_ip->u.addr32[0]^l_port);
326         else if (ip->len==16) 
327                 h= (ip->u.addr32[0]^ip->u.addr32[1]^ip->u.addr32[2]^
328                                 ip->u.addr32[3]^port) ^
329                         (l_ip->u.addr32[0]^l_ip->u.addr32[1]^l_ip->u.addr32[2]^
330                                 l_ip->u.addr32[3]^l_port);
331         else{
332                 LOG(L_CRIT, "tcp_addr_hash: BUG: bad len %d for an ip address\n",
333                                 ip->len);
334                 return 0;
335         }
336         /* make sure the first bits are influenced by all 32
337          * (the first log2(TCP_ALIAS_HASH_SIZE) bits should be a mix of all
338          *  32)*/
339         h ^= h>>17;
340         h ^= h>>7;
341         return h & (TCP_ALIAS_HASH_SIZE-1);
342 }
343
344 #define tcp_id_hash(id) (id&(TCP_ID_HASH_SIZE-1))
345
346 struct tcp_connection* tcpconn_get(int id, struct ip_addr* ip, int port,
347                                                                         union sockaddr_union* local_addr,
348                                                                         ticks_t timeout);
349
350 typedef struct tcp_event_info {
351         int type;
352         char *buf;
353         unsigned int len;
354         struct receive_info *rcv;
355         struct tcp_connection *con;
356 } tcp_event_info_t;
357
358 typedef struct ws_event_info {
359         int type;
360         char *buf;
361         unsigned int len;
362         int id;
363 } ws_event_info_t;
364
365 #endif
366
367