1 #include <linux/kernel.h>
3 #include <linux/sctp.h>
5 #include <net/ip6_checksum.h>
6 #include <linux/netfilter.h>
7 #include <linux/netfilter_ipv4.h>
8 #include <net/sctp/checksum.h>
12 static struct ip_vs_conn
*
13 sctp_conn_in_get(int af
,
14 const struct sk_buff
*skb
,
15 struct ip_vs_protocol
*pp
,
16 const struct ip_vs_iphdr
*iph
,
17 unsigned int proto_off
,
20 __be16 _ports
[2], *pptr
;
22 pptr
= skb_header_pointer(skb
, proto_off
, sizeof(_ports
), _ports
);
27 return ip_vs_conn_in_get(af
, iph
->protocol
,
29 &iph
->daddr
, pptr
[1]);
31 return ip_vs_conn_in_get(af
, iph
->protocol
,
33 &iph
->saddr
, pptr
[0]);
36 static struct ip_vs_conn
*
37 sctp_conn_out_get(int af
,
38 const struct sk_buff
*skb
,
39 struct ip_vs_protocol
*pp
,
40 const struct ip_vs_iphdr
*iph
,
41 unsigned int proto_off
,
44 __be16 _ports
[2], *pptr
;
46 pptr
= skb_header_pointer(skb
, proto_off
, sizeof(_ports
), _ports
);
51 return ip_vs_conn_out_get(af
, iph
->protocol
,
53 &iph
->daddr
, pptr
[1]);
55 return ip_vs_conn_out_get(af
, iph
->protocol
,
57 &iph
->saddr
, pptr
[0]);
61 sctp_conn_schedule(int af
, struct sk_buff
*skb
, struct ip_vs_protocol
*pp
,
62 int *verdict
, struct ip_vs_conn
**cpp
)
64 struct ip_vs_service
*svc
;
65 sctp_chunkhdr_t _schunkh
, *sch
;
66 sctp_sctphdr_t
*sh
, _sctph
;
67 struct ip_vs_iphdr iph
;
69 ip_vs_fill_iphdr(af
, skb_network_header(skb
), &iph
);
71 sh
= skb_header_pointer(skb
, iph
.len
, sizeof(_sctph
), &_sctph
);
75 sch
= skb_header_pointer(skb
, iph
.len
+ sizeof(sctp_sctphdr_t
),
76 sizeof(_schunkh
), &_schunkh
);
80 if ((sch
->type
== SCTP_CID_INIT
) &&
81 (svc
= ip_vs_service_get(af
, skb
->mark
, iph
.protocol
,
82 &iph
.daddr
, sh
->dest
))) {
85 * It seems that we are very loaded.
86 * We have to drop this packet :(
88 ip_vs_service_put(svc
);
93 * Let the virtual server select a real server for the
94 * incoming connection, and create a connection entry.
96 *cpp
= ip_vs_schedule(svc
, skb
);
98 *verdict
= ip_vs_leave(svc
, skb
, pp
);
101 ip_vs_service_put(svc
);
108 sctp_snat_handler(struct sk_buff
*skb
,
109 struct ip_vs_protocol
*pp
, struct ip_vs_conn
*cp
)
111 sctp_sctphdr_t
*sctph
;
112 unsigned int sctphoff
;
115 #ifdef CONFIG_IP_VS_IPV6
116 if (cp
->af
== AF_INET6
)
117 sctphoff
= sizeof(struct ipv6hdr
);
120 sctphoff
= ip_hdrlen(skb
);
122 /* csum_check requires unshared skb */
123 if (!skb_make_writable(skb
, sctphoff
+ sizeof(*sctph
)))
126 if (unlikely(cp
->app
!= NULL
)) {
127 /* Some checks before mangling */
128 if (pp
->csum_check
&& !pp
->csum_check(cp
->af
, skb
, pp
))
131 /* Call application helper if needed */
132 if (!ip_vs_app_pkt_out(cp
, skb
))
136 sctph
= (void *) skb_network_header(skb
) + sctphoff
;
137 sctph
->source
= cp
->vport
;
139 /* Calculate the checksum */
140 crc32
= sctp_start_cksum((u8
*) sctph
, skb_headlen(skb
) - sctphoff
);
141 for (skb
= skb_shinfo(skb
)->frag_list
; skb
; skb
= skb
->next
)
142 crc32
= sctp_update_cksum((u8
*) skb
->data
, skb_headlen(skb
),
144 crc32
= sctp_end_cksum(crc32
);
145 sctph
->checksum
= crc32
;
151 sctp_dnat_handler(struct sk_buff
*skb
,
152 struct ip_vs_protocol
*pp
, struct ip_vs_conn
*cp
)
155 sctp_sctphdr_t
*sctph
;
156 unsigned int sctphoff
;
159 #ifdef CONFIG_IP_VS_IPV6
160 if (cp
->af
== AF_INET6
)
161 sctphoff
= sizeof(struct ipv6hdr
);
164 sctphoff
= ip_hdrlen(skb
);
166 /* csum_check requires unshared skb */
167 if (!skb_make_writable(skb
, sctphoff
+ sizeof(*sctph
)))
170 if (unlikely(cp
->app
!= NULL
)) {
171 /* Some checks before mangling */
172 if (pp
->csum_check
&& !pp
->csum_check(cp
->af
, skb
, pp
))
175 /* Call application helper if needed */
176 if (!ip_vs_app_pkt_out(cp
, skb
))
180 sctph
= (void *) skb_network_header(skb
) + sctphoff
;
181 sctph
->dest
= cp
->dport
;
183 /* Calculate the checksum */
184 crc32
= sctp_start_cksum((u8
*) sctph
, skb_headlen(skb
) - sctphoff
);
185 for (skb
= skb_shinfo(skb
)->frag_list
; skb
; skb
= skb
->next
)
186 crc32
= sctp_update_cksum((u8
*) skb
->data
, skb_headlen(skb
),
188 crc32
= sctp_end_cksum(crc32
);
189 sctph
->checksum
= crc32
;
195 sctp_csum_check(int af
, struct sk_buff
*skb
, struct ip_vs_protocol
*pp
)
197 struct sk_buff
*list
= skb_shinfo(skb
)->frag_list
;
198 unsigned int sctphoff
;
199 struct sctphdr
*sh
, _sctph
;
204 #ifdef CONFIG_IP_VS_IPV6
206 sctphoff
= sizeof(struct ipv6hdr
);
209 sctphoff
= ip_hdrlen(skb
);
211 sh
= skb_header_pointer(skb
, sctphoff
, sizeof(_sctph
), &_sctph
);
217 tmp
= sctp_start_cksum((__u8
*) sh
, skb_headlen(skb
));
218 for (; list
; list
= list
->next
)
219 tmp
= sctp_update_cksum((__u8
*) list
->data
,
220 skb_headlen(list
), tmp
);
222 val
= sctp_end_cksum(tmp
);
225 /* CRC failure, dump it. */
226 IP_VS_DBG_RL_PKT(0, pp
, skb
, 0,
227 "Failed checksum for");
233 struct ipvs_sctp_nextstate
{
236 enum ipvs_sctp_event_t
{
237 IP_VS_SCTP_EVE_DATA_CLI
,
238 IP_VS_SCTP_EVE_DATA_SER
,
239 IP_VS_SCTP_EVE_INIT_CLI
,
240 IP_VS_SCTP_EVE_INIT_SER
,
241 IP_VS_SCTP_EVE_INIT_ACK_CLI
,
242 IP_VS_SCTP_EVE_INIT_ACK_SER
,
243 IP_VS_SCTP_EVE_COOKIE_ECHO_CLI
,
244 IP_VS_SCTP_EVE_COOKIE_ECHO_SER
,
245 IP_VS_SCTP_EVE_COOKIE_ACK_CLI
,
246 IP_VS_SCTP_EVE_COOKIE_ACK_SER
,
247 IP_VS_SCTP_EVE_ABORT_CLI
,
248 IP_VS_SCTP_EVE__ABORT_SER
,
249 IP_VS_SCTP_EVE_SHUT_CLI
,
250 IP_VS_SCTP_EVE_SHUT_SER
,
251 IP_VS_SCTP_EVE_SHUT_ACK_CLI
,
252 IP_VS_SCTP_EVE_SHUT_ACK_SER
,
253 IP_VS_SCTP_EVE_SHUT_COM_CLI
,
254 IP_VS_SCTP_EVE_SHUT_COM_SER
,
258 static enum ipvs_sctp_event_t sctp_events
[255] = {
259 IP_VS_SCTP_EVE_DATA_CLI
,
260 IP_VS_SCTP_EVE_INIT_CLI
,
261 IP_VS_SCTP_EVE_INIT_ACK_CLI
,
262 IP_VS_SCTP_EVE_DATA_CLI
,
263 IP_VS_SCTP_EVE_DATA_CLI
,
264 IP_VS_SCTP_EVE_DATA_CLI
,
265 IP_VS_SCTP_EVE_ABORT_CLI
,
266 IP_VS_SCTP_EVE_SHUT_CLI
,
267 IP_VS_SCTP_EVE_SHUT_ACK_CLI
,
268 IP_VS_SCTP_EVE_DATA_CLI
,
269 IP_VS_SCTP_EVE_COOKIE_ECHO_CLI
,
270 IP_VS_SCTP_EVE_COOKIE_ACK_CLI
,
271 IP_VS_SCTP_EVE_DATA_CLI
,
272 IP_VS_SCTP_EVE_DATA_CLI
,
273 IP_VS_SCTP_EVE_SHUT_COM_CLI
,
276 static struct ipvs_sctp_nextstate
277 sctp_states_table
[IP_VS_SCTP_S_LAST
][IP_VS_SCTP_EVE_LAST
] = {
279 * STATE : IP_VS_SCTP_S_NONE
281 /*next state *//*event */
282 {{IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_DATA_CLI */ },
283 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_DATA_SER */ },
284 {IP_VS_SCTP_S_INIT_CLI
/* IP_VS_SCTP_EVE_INIT_CLI */ },
285 {IP_VS_SCTP_S_INIT_SER
/* IP_VS_SCTP_EVE_INIT_SER */ },
286 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
287 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
288 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
289 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
290 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
291 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
292 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_CLI */ },
293 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_SER */ },
294 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_CLI */ },
295 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_SER */ },
296 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
297 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
298 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
299 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_SER */ },
302 * STATE : IP_VS_SCTP_S_INIT_CLI
303 * Cient sent INIT and is waiting for reply from server(In ECHO_WAIT)
305 {{IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_DATA_CLI */ },
306 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_DATA_SER */ },
307 {IP_VS_SCTP_S_INIT_CLI
/* IP_VS_SCTP_EVE_INIT_CLI */ },
308 {IP_VS_SCTP_S_INIT_SER
/* IP_VS_SCTP_EVE_INIT_SER */ },
309 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
310 {IP_VS_SCTP_S_INIT_ACK_SER
/* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
311 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ECHO_CLI */ },
312 {IP_VS_SCTP_S_INIT_CLI
/* IP_VS_SCTP_EVE_ECHO_SER */ },
313 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
314 {IP_VS_SCTP_S_INIT_CLI
/* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
315 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_CLI */ },
316 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_SER */ },
317 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_CLI */ },
318 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_SER */ },
319 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
320 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
321 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
322 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
325 * State : IP_VS_SCTP_S_INIT_SER
326 * Server sent INIT and waiting for INIT ACK from the client
328 {{IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_DATA_CLI */ },
329 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_DATA_SER */ },
330 {IP_VS_SCTP_S_INIT_CLI
/* IP_VS_SCTP_EVE_INIT_CLI */ },
331 {IP_VS_SCTP_S_INIT_SER
/* IP_VS_SCTP_EVE_INIT_SER */ },
332 {IP_VS_SCTP_S_INIT_ACK_CLI
/* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
333 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
334 {IP_VS_SCTP_S_INIT_SER
/* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
335 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
336 {IP_VS_SCTP_S_INIT_SER
/* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
337 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
338 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_CLI */ },
339 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_SER */ },
340 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_CLI */ },
341 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_SER */ },
342 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
343 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
344 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
345 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
348 * State : IP_VS_SCTP_S_INIT_ACK_CLI
349 * Client sent INIT ACK and waiting for ECHO from the server
351 {{IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_DATA_CLI */ },
352 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_DATA_SER */ },
354 * We have got an INIT from client. From the spec.“Upon receipt of
355 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
356 * an INIT ACK using the same parameters it sent in its original
357 * INIT chunk (including its Initiate Tag, unchanged”).
359 {IP_VS_SCTP_S_INIT_CLI
/* IP_VS_SCTP_EVE_INIT_CLI */ },
360 {IP_VS_SCTP_S_INIT_SER
/* IP_VS_SCTP_EVE_INIT_SER */ },
362 * INIT_ACK has been resent by the client, let us stay is in
365 {IP_VS_SCTP_S_INIT_ACK_CLI
/* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
367 * INIT_ACK sent by the server, close the connection
369 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
371 * ECHO by client, it should not happen, close the connection
373 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
375 * ECHO by server, this is what we are expecting, move to ECHO_SER
377 {IP_VS_SCTP_S_ECHO_SER
/* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
379 * COOKIE ACK from client, it should not happen, close the connection
381 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
383 * Unexpected COOKIE ACK from server, staty in the same state
385 {IP_VS_SCTP_S_INIT_ACK_CLI
/* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
386 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_CLI */ },
387 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_SER */ },
388 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_CLI */ },
389 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_SER */ },
390 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
391 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
392 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
393 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
396 * State : IP_VS_SCTP_S_INIT_ACK_SER
397 * Server sent INIT ACK and waiting for ECHO from the client
399 {{IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_DATA_CLI */ },
400 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_DATA_SER */ },
402 * We have got an INIT from client. From the spec.“Upon receipt of
403 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
404 * an INIT ACK using the same parameters it sent in its original
405 * INIT chunk (including its Initiate Tag, unchanged”).
407 {IP_VS_SCTP_S_INIT_CLI
/* IP_VS_SCTP_EVE_INIT_CLI */ },
408 {IP_VS_SCTP_S_INIT_SER
/* IP_VS_SCTP_EVE_INIT_SER */ },
410 * Unexpected INIT_ACK by the client, let us close the connection
412 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
414 * INIT_ACK resent by the server, let us move to same state
416 {IP_VS_SCTP_S_INIT_ACK_SER
/* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
418 * Client send the ECHO, this is what we are expecting,
421 {IP_VS_SCTP_S_ECHO_CLI
/* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
423 * ECHO received from the server, Not sure what to do,
426 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
428 * COOKIE ACK from client, let us stay in the same state
430 {IP_VS_SCTP_S_INIT_ACK_SER
/* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
432 * COOKIE ACK from server, hmm... this should not happen, lets close
435 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
436 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_CLI */ },
437 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_SER */ },
438 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_CLI */ },
439 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_SER */ },
440 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
441 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
442 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
443 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
446 * State : IP_VS_SCTP_S_ECHO_CLI
447 * Cient sent ECHO and waiting COOKEI ACK from the Server
449 {{IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_DATA_CLI */ },
450 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_DATA_SER */ },
452 * We have got an INIT from client. From the spec.“Upon receipt of
453 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
454 * an INIT ACK using the same parameters it sent in its original
455 * INIT chunk (including its Initiate Tag, unchanged”).
457 {IP_VS_SCTP_S_INIT_CLI
/* IP_VS_SCTP_EVE_INIT_CLI */ },
458 {IP_VS_SCTP_S_INIT_SER
/* IP_VS_SCTP_EVE_INIT_SER */ },
460 * INIT_ACK has been by the client, let us close the connection
462 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
464 * INIT_ACK sent by the server, Unexpected INIT ACK, spec says,
465 * “If an INIT ACK is received by an endpoint in any state other
466 * than the COOKIE-WAIT state, the endpoint should discard the
467 * INIT ACK chunk”. Stay in the same state
469 {IP_VS_SCTP_S_ECHO_CLI
/* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
471 * Client resent the ECHO, let us stay in the same state
473 {IP_VS_SCTP_S_ECHO_CLI
/* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
475 * ECHO received from the server, Not sure what to do,
478 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
480 * COOKIE ACK from client, this shoud not happen, let's close the
483 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
485 * COOKIE ACK from server, this is what we are awaiting,lets move to
488 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
489 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_CLI */ },
490 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_SER */ },
491 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_CLI */ },
492 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_SER */ },
493 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
494 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
495 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
496 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
499 * State : IP_VS_SCTP_S_ECHO_SER
500 * Server sent ECHO and waiting COOKEI ACK from the client
502 {{IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_DATA_CLI */ },
503 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_DATA_SER */ },
505 * We have got an INIT from client. From the spec.“Upon receipt of
506 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
507 * an INIT ACK using the same parameters it sent in its original
508 * INIT chunk (including its Initiate Tag, unchanged”).
510 {IP_VS_SCTP_S_INIT_CLI
/* IP_VS_SCTP_EVE_INIT_CLI */ },
511 {IP_VS_SCTP_S_INIT_SER
/* IP_VS_SCTP_EVE_INIT_SER */ },
513 * INIT_ACK sent by the server, Unexpected INIT ACK, spec says,
514 * “If an INIT ACK is received by an endpoint in any state other
515 * than the COOKIE-WAIT state, the endpoint should discard the
516 * INIT ACK chunk”. Stay in the same state
518 {IP_VS_SCTP_S_ECHO_SER
/* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
520 * INIT_ACK has been by the server, let us close the connection
522 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
524 * Client sent the ECHO, not sure what to do, let's close the
527 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
529 * ECHO resent by the server, stay in the same state
531 {IP_VS_SCTP_S_ECHO_SER
/* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
533 * COOKIE ACK from client, this is what we are expecting, let's move
536 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
538 * COOKIE ACK from server, this should not happen, lets close the
541 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
542 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_CLI */ },
543 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_SER */ },
544 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_CLI */ },
545 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_SER */ },
546 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
547 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
548 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
549 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
552 * State : IP_VS_SCTP_S_ESTABLISHED
553 * Association established
555 {{IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_DATA_CLI */ },
556 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_DATA_SER */ },
558 * We have got an INIT from client. From the spec.“Upon receipt of
559 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
560 * an INIT ACK using the same parameters it sent in its original
561 * INIT chunk (including its Initiate Tag, unchanged”).
563 {IP_VS_SCTP_S_INIT_CLI
/* IP_VS_SCTP_EVE_INIT_CLI */ },
564 {IP_VS_SCTP_S_INIT_SER
/* IP_VS_SCTP_EVE_INIT_SER */ },
566 * INIT_ACK sent by the server, Unexpected INIT ACK, spec says,
567 * “If an INIT ACK is received by an endpoint in any state other
568 * than the COOKIE-WAIT state, the endpoint should discard the
569 * INIT ACK chunk”. Stay in the same state
571 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
572 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
574 * Client sent ECHO, Spec(sec 5.2.4) says it may be handled by the
575 * peer and peer shall move to the ESTABISHED. if it doesn't handle
576 * it will send ERROR chunk. So, stay in the same state
578 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
579 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
581 * COOKIE ACK from client, not sure what to do stay in the same state
583 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
584 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
585 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_CLI */ },
586 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_SER */ },
588 * SHUTDOWN from the client, move to SHUDDOWN_CLI
590 {IP_VS_SCTP_S_SHUT_CLI
/* IP_VS_SCTP_EVE_SHUT_CLI */ },
592 * SHUTDOWN from the server, move to SHUTDOWN_SER
594 {IP_VS_SCTP_S_SHUT_SER
/* IP_VS_SCTP_EVE_SHUT_SER */ },
596 * client sent SHUDTDOWN_ACK, this should not happen, let's close
599 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
600 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
601 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
602 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
605 * State : IP_VS_SCTP_S_SHUT_CLI
606 * SHUTDOWN sent from the client, waitinf for SHUT ACK from the server
609 * We recieved the data chuck, keep the state unchanged. I assume
610 * that still data chuncks can be received by both the peers in
614 {{IP_VS_SCTP_S_SHUT_CLI
/* IP_VS_SCTP_EVE_DATA_CLI */ },
615 {IP_VS_SCTP_S_SHUT_CLI
/* IP_VS_SCTP_EVE_DATA_SER */ },
617 * We have got an INIT from client. From the spec.“Upon receipt of
618 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
619 * an INIT ACK using the same parameters it sent in its original
620 * INIT chunk (including its Initiate Tag, unchanged”).
622 {IP_VS_SCTP_S_INIT_CLI
/* IP_VS_SCTP_EVE_INIT_CLI */ },
623 {IP_VS_SCTP_S_INIT_SER
/* IP_VS_SCTP_EVE_INIT_SER */ },
625 * INIT_ACK sent by the server, Unexpected INIT ACK, spec says,
626 * “If an INIT ACK is received by an endpoint in any state other
627 * than the COOKIE-WAIT state, the endpoint should discard the
628 * INIT ACK chunk”. Stay in the same state
630 {IP_VS_SCTP_S_SHUT_CLI
/* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
631 {IP_VS_SCTP_S_SHUT_CLI
/* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
633 * Client sent ECHO, Spec(sec 5.2.4) says it may be handled by the
634 * peer and peer shall move to the ESTABISHED. if it doesn't handle
635 * it will send ERROR chunk. So, stay in the same state
637 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
638 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
640 * COOKIE ACK from client, not sure what to do stay in the same state
642 {IP_VS_SCTP_S_SHUT_CLI
/* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
643 {IP_VS_SCTP_S_SHUT_CLI
/* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
644 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_CLI */ },
645 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_SER */ },
647 * SHUTDOWN resent from the client, move to SHUDDOWN_CLI
649 {IP_VS_SCTP_S_SHUT_CLI
/* IP_VS_SCTP_EVE_SHUT_CLI */ },
651 * SHUTDOWN from the server, move to SHUTDOWN_SER
653 {IP_VS_SCTP_S_SHUT_SER
/* IP_VS_SCTP_EVE_SHUT_SER */ },
655 * client sent SHUDTDOWN_ACK, this should not happen, let's close
658 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
660 * Server sent SHUTDOWN ACK, this is what we are expecting, let's move
663 {IP_VS_SCTP_S_SHUT_ACK_SER
/* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
665 * SHUTDOWN COM from client, this should not happen, let's close the
668 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
669 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
672 * State : IP_VS_SCTP_S_SHUT_SER
673 * SHUTDOWN sent from the server, waitinf for SHUTDOWN ACK from client
676 * We recieved the data chuck, keep the state unchanged. I assume
677 * that still data chuncks can be received by both the peers in
681 {{IP_VS_SCTP_S_SHUT_SER
/* IP_VS_SCTP_EVE_DATA_CLI */ },
682 {IP_VS_SCTP_S_SHUT_SER
/* IP_VS_SCTP_EVE_DATA_SER */ },
684 * We have got an INIT from client. From the spec.“Upon receipt of
685 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
686 * an INIT ACK using the same parameters it sent in its original
687 * INIT chunk (including its Initiate Tag, unchanged”).
689 {IP_VS_SCTP_S_INIT_CLI
/* IP_VS_SCTP_EVE_INIT_CLI */ },
690 {IP_VS_SCTP_S_INIT_SER
/* IP_VS_SCTP_EVE_INIT_SER */ },
692 * INIT_ACK sent by the server, Unexpected INIT ACK, spec says,
693 * “If an INIT ACK is received by an endpoint in any state other
694 * than the COOKIE-WAIT state, the endpoint should discard the
695 * INIT ACK chunk”. Stay in the same state
697 {IP_VS_SCTP_S_SHUT_SER
/* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
698 {IP_VS_SCTP_S_SHUT_SER
/* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
700 * Client sent ECHO, Spec(sec 5.2.4) says it may be handled by the
701 * peer and peer shall move to the ESTABISHED. if it doesn't handle
702 * it will send ERROR chunk. So, stay in the same state
704 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
705 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
707 * COOKIE ACK from client, not sure what to do stay in the same state
709 {IP_VS_SCTP_S_SHUT_SER
/* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
710 {IP_VS_SCTP_S_SHUT_SER
/* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
711 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_CLI */ },
712 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_SER */ },
714 * SHUTDOWN resent from the client, move to SHUDDOWN_CLI
716 {IP_VS_SCTP_S_SHUT_CLI
/* IP_VS_SCTP_EVE_SHUT_CLI */ },
718 * SHUTDOWN resent from the server, move to SHUTDOWN_SER
720 {IP_VS_SCTP_S_SHUT_SER
/* IP_VS_SCTP_EVE_SHUT_SER */ },
722 * client sent SHUDTDOWN_ACK, this is what we are expecting, let's
723 * move to SHUT_ACK_CLI
725 {IP_VS_SCTP_S_SHUT_ACK_CLI
/* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
727 * Server sent SHUTDOWN ACK, this should not happen, let's close the
730 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
732 * SHUTDOWN COM from client, this should not happen, let's close the
735 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
736 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
740 * State : IP_VS_SCTP_S_SHUT_ACK_CLI
741 * SHUTDOWN ACK from the client, awaiting for SHUTDOWN COM from server
744 * We recieved the data chuck, keep the state unchanged. I assume
745 * that still data chuncks can be received by both the peers in
749 {{IP_VS_SCTP_S_SHUT_ACK_CLI
/* IP_VS_SCTP_EVE_DATA_CLI */ },
750 {IP_VS_SCTP_S_SHUT_ACK_CLI
/* IP_VS_SCTP_EVE_DATA_SER */ },
752 * We have got an INIT from client. From the spec.“Upon receipt of
753 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
754 * an INIT ACK using the same parameters it sent in its original
755 * INIT chunk (including its Initiate Tag, unchanged”).
757 {IP_VS_SCTP_S_INIT_CLI
/* IP_VS_SCTP_EVE_INIT_CLI */ },
758 {IP_VS_SCTP_S_INIT_SER
/* IP_VS_SCTP_EVE_INIT_SER */ },
760 * INIT_ACK sent by the server, Unexpected INIT ACK, spec says,
761 * “If an INIT ACK is received by an endpoint in any state other
762 * than the COOKIE-WAIT state, the endpoint should discard the
763 * INIT ACK chunk”. Stay in the same state
765 {IP_VS_SCTP_S_SHUT_ACK_CLI
/* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
766 {IP_VS_SCTP_S_SHUT_ACK_CLI
/* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
768 * Client sent ECHO, Spec(sec 5.2.4) says it may be handled by the
769 * peer and peer shall move to the ESTABISHED. if it doesn't handle
770 * it will send ERROR chunk. So, stay in the same state
772 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
773 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
775 * COOKIE ACK from client, not sure what to do stay in the same state
777 {IP_VS_SCTP_S_SHUT_ACK_CLI
/* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
778 {IP_VS_SCTP_S_SHUT_ACK_CLI
/* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
779 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_CLI */ },
780 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_SER */ },
782 * SHUTDOWN sent from the client, move to SHUDDOWN_CLI
784 {IP_VS_SCTP_S_SHUT_CLI
/* IP_VS_SCTP_EVE_SHUT_CLI */ },
786 * SHUTDOWN sent from the server, move to SHUTDOWN_SER
788 {IP_VS_SCTP_S_SHUT_SER
/* IP_VS_SCTP_EVE_SHUT_SER */ },
790 * client resent SHUDTDOWN_ACK, let's stay in the same state
792 {IP_VS_SCTP_S_SHUT_ACK_CLI
/* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
794 * Server sent SHUTDOWN ACK, this should not happen, let's close the
797 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
799 * SHUTDOWN COM from client, this should not happen, let's close the
802 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
804 * SHUTDOWN COMPLETE from server this is what we are expecting.
806 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
810 * State : IP_VS_SCTP_S_SHUT_ACK_SER
811 * SHUTDOWN ACK from the server, awaiting for SHUTDOWN COM from client
814 * We recieved the data chuck, keep the state unchanged. I assume
815 * that still data chuncks can be received by both the peers in
819 {{IP_VS_SCTP_S_SHUT_ACK_SER
/* IP_VS_SCTP_EVE_DATA_CLI */ },
820 {IP_VS_SCTP_S_SHUT_ACK_SER
/* IP_VS_SCTP_EVE_DATA_SER */ },
822 * We have got an INIT from client. From the spec.“Upon receipt of
823 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
824 * an INIT ACK using the same parameters it sent in its original
825 * INIT chunk (including its Initiate Tag, unchanged”).
827 {IP_VS_SCTP_S_INIT_CLI
/* IP_VS_SCTP_EVE_INIT_CLI */ },
828 {IP_VS_SCTP_S_INIT_SER
/* IP_VS_SCTP_EVE_INIT_SER */ },
830 * INIT_ACK sent by the server, Unexpected INIT ACK, spec says,
831 * “If an INIT ACK is received by an endpoint in any state other
832 * than the COOKIE-WAIT state, the endpoint should discard the
833 * INIT ACK chunk”. Stay in the same state
835 {IP_VS_SCTP_S_SHUT_ACK_SER
/* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
836 {IP_VS_SCTP_S_SHUT_ACK_SER
/* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
838 * Client sent ECHO, Spec(sec 5.2.4) says it may be handled by the
839 * peer and peer shall move to the ESTABISHED. if it doesn't handle
840 * it will send ERROR chunk. So, stay in the same state
842 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
843 {IP_VS_SCTP_S_ESTABLISHED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
845 * COOKIE ACK from client, not sure what to do stay in the same state
847 {IP_VS_SCTP_S_SHUT_ACK_SER
/* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
848 {IP_VS_SCTP_S_SHUT_ACK_SER
/* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
849 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_CLI */ },
850 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_SER */ },
852 * SHUTDOWN sent from the client, move to SHUDDOWN_CLI
854 {IP_VS_SCTP_S_SHUT_CLI
/* IP_VS_SCTP_EVE_SHUT_CLI */ },
856 * SHUTDOWN sent from the server, move to SHUTDOWN_SER
858 {IP_VS_SCTP_S_SHUT_SER
/* IP_VS_SCTP_EVE_SHUT_SER */ },
860 * client sent SHUDTDOWN_ACK, this should not happen let's close
863 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
865 * Server resent SHUTDOWN ACK, stay in the same state
867 {IP_VS_SCTP_S_SHUT_ACK_SER
/* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
869 * SHUTDOWN COM from client, this what we are expecting, let's close
872 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
874 * SHUTDOWN COMPLETE from server this should not happen.
876 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
879 * State : IP_VS_SCTP_S_CLOSED
881 {{IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_DATA_CLI */ },
882 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_DATA_SER */ },
883 {IP_VS_SCTP_S_INIT_CLI
/* IP_VS_SCTP_EVE_INIT_CLI */ },
884 {IP_VS_SCTP_S_INIT_SER
/* IP_VS_SCTP_EVE_INIT_SER */ },
885 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
886 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
887 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
888 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
889 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
890 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
891 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_CLI */ },
892 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_ABORT_SER */ },
893 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_CLI */ },
894 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_SER */ },
895 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
896 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
897 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
898 {IP_VS_SCTP_S_CLOSED
/* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
903 * Timeout table[state]
905 static int sctp_timeouts
[IP_VS_SCTP_S_LAST
+ 1] = {
906 [IP_VS_SCTP_S_NONE
] = 2 * HZ
,
907 [IP_VS_SCTP_S_INIT_CLI
] = 1 * 60 * HZ
,
908 [IP_VS_SCTP_S_INIT_SER
] = 1 * 60 * HZ
,
909 [IP_VS_SCTP_S_INIT_ACK_CLI
] = 1 * 60 * HZ
,
910 [IP_VS_SCTP_S_INIT_ACK_SER
] = 1 * 60 * HZ
,
911 [IP_VS_SCTP_S_ECHO_CLI
] = 1 * 60 * HZ
,
912 [IP_VS_SCTP_S_ECHO_SER
] = 1 * 60 * HZ
,
913 [IP_VS_SCTP_S_ESTABLISHED
] = 15 * 60 * HZ
,
914 [IP_VS_SCTP_S_SHUT_CLI
] = 1 * 60 * HZ
,
915 [IP_VS_SCTP_S_SHUT_SER
] = 1 * 60 * HZ
,
916 [IP_VS_SCTP_S_SHUT_ACK_CLI
] = 1 * 60 * HZ
,
917 [IP_VS_SCTP_S_SHUT_ACK_SER
] = 1 * 60 * HZ
,
918 [IP_VS_SCTP_S_CLOSED
] = 10 * HZ
,
919 [IP_VS_SCTP_S_LAST
] = 2 * HZ
,
922 static const char *sctp_state_name_table
[IP_VS_SCTP_S_LAST
+ 1] = {
923 [IP_VS_SCTP_S_NONE
] = "NONE",
924 [IP_VS_SCTP_S_INIT_CLI
] = "INIT_CLI",
925 [IP_VS_SCTP_S_INIT_SER
] = "INIT_SER",
926 [IP_VS_SCTP_S_INIT_ACK_CLI
] = "INIT_ACK_CLI",
927 [IP_VS_SCTP_S_INIT_ACK_SER
] = "INIT_ACK_SER",
928 [IP_VS_SCTP_S_ECHO_CLI
] = "COOKIE_ECHO_CLI",
929 [IP_VS_SCTP_S_ECHO_SER
] = "COOKIE_ECHO_SER",
930 [IP_VS_SCTP_S_ESTABLISHED
] = "ESTABISHED",
931 [IP_VS_SCTP_S_SHUT_CLI
] = "SHUTDOWN_CLI",
932 [IP_VS_SCTP_S_SHUT_SER
] = "SHUTDOWN_SER",
933 [IP_VS_SCTP_S_SHUT_ACK_CLI
] = "SHUTDOWN_ACK_CLI",
934 [IP_VS_SCTP_S_SHUT_ACK_SER
] = "SHUTDOWN_ACK_SER",
935 [IP_VS_SCTP_S_CLOSED
] = "CLOSED",
936 [IP_VS_SCTP_S_LAST
] = "BUG!"
940 static const char *sctp_state_name(int state
)
942 if (state
>= IP_VS_SCTP_S_LAST
)
944 if (sctp_state_name_table
[state
])
945 return sctp_state_name_table
[state
];
949 static void sctp_timeout_change(struct ip_vs_protocol
*pp
, int flags
)
954 sctp_set_state_timeout(struct ip_vs_protocol
*pp
, char *sname
, int to
)
957 return ip_vs_set_state_timeout(pp
->timeout_table
, IP_VS_SCTP_S_LAST
,
958 sctp_state_name_table
, sname
, to
);
962 set_sctp_state(struct ip_vs_protocol
*pp
, struct ip_vs_conn
*cp
,
963 int direction
, const struct sk_buff
*skb
)
965 sctp_chunkhdr_t _sctpch
, *sch
;
966 unsigned char chunk_type
;
967 int event
, next_state
;
970 #ifdef CONFIG_IP_VS_IPV6
971 ihl
= cp
->af
== AF_INET
? ip_hdrlen(skb
) : sizeof(struct ipv6hdr
);
973 ihl
= ip_hdrlen(skb
);
976 sch
= skb_header_pointer(skb
, ihl
+ sizeof(sctp_sctphdr_t
),
977 sizeof(_sctpch
), &_sctpch
);
981 chunk_type
= sch
->type
;
983 * Section 3: Multiple chunks can be bundled into one SCTP packet
984 * up to the MTU size, except for the INIT, INIT ACK, and
985 * SHUTDOWN COMPLETE chunks. These chunks MUST NOT be bundled with
986 * any other chunk in a packet.
988 * Section 3.3.7: DATA chunks MUST NOT be bundled with ABORT. Control
989 * chunks (except for INIT, INIT ACK, and SHUTDOWN COMPLETE) MAY be
990 * bundled with an ABORT, but they MUST be placed before the ABORT
991 * in the SCTP packet or they will be ignored by the receiver.
993 if ((sch
->type
== SCTP_CID_COOKIE_ECHO
) ||
994 (sch
->type
== SCTP_CID_COOKIE_ACK
)) {
995 sch
= skb_header_pointer(skb
, (ihl
+ sizeof(sctp_sctphdr_t
) +
996 sch
->length
), sizeof(_sctpch
), &_sctpch
);
998 if (sch
->type
== SCTP_CID_ABORT
)
999 chunk_type
= sch
->type
;
1003 event
= sctp_events
[chunk_type
];
1006 * If the direction is IP_VS_DIR_OUTPUT, this event is from server
1008 if (direction
== IP_VS_DIR_OUTPUT
)
1013 next_state
= sctp_states_table
[cp
->state
][event
].next_state
;
1015 if (next_state
!= cp
->state
) {
1016 struct ip_vs_dest
*dest
= cp
->dest
;
1018 IP_VS_DBG_BUF(8, "%s %s %s:%d->"
1019 "%s:%d state: %s->%s conn->refcnt:%d\n",
1021 ((direction
== IP_VS_DIR_OUTPUT
) ?
1022 "output " : "input "),
1023 IP_VS_DBG_ADDR(cp
->af
, &cp
->daddr
),
1025 IP_VS_DBG_ADDR(cp
->af
, &cp
->caddr
),
1027 sctp_state_name(cp
->state
),
1028 sctp_state_name(next_state
),
1029 atomic_read(&cp
->refcnt
));
1031 if (!(cp
->flags
& IP_VS_CONN_F_INACTIVE
) &&
1032 (next_state
!= IP_VS_SCTP_S_ESTABLISHED
)) {
1033 atomic_dec(&dest
->activeconns
);
1034 atomic_inc(&dest
->inactconns
);
1035 cp
->flags
|= IP_VS_CONN_F_INACTIVE
;
1036 } else if ((cp
->flags
& IP_VS_CONN_F_INACTIVE
) &&
1037 (next_state
== IP_VS_SCTP_S_ESTABLISHED
)) {
1038 atomic_inc(&dest
->activeconns
);
1039 atomic_dec(&dest
->inactconns
);
1040 cp
->flags
&= ~IP_VS_CONN_F_INACTIVE
;
1045 cp
->timeout
= pp
->timeout_table
[cp
->state
= next_state
];
1051 sctp_state_transition(struct ip_vs_conn
*cp
, int direction
,
1052 const struct sk_buff
*skb
, struct ip_vs_protocol
*pp
)
1056 spin_lock(&cp
->lock
);
1057 ret
= set_sctp_state(pp
, cp
, direction
, skb
);
1058 spin_unlock(&cp
->lock
);
1064 * Hash table for SCTP application incarnations
1066 #define SCTP_APP_TAB_BITS 4
1067 #define SCTP_APP_TAB_SIZE (1 << SCTP_APP_TAB_BITS)
1068 #define SCTP_APP_TAB_MASK (SCTP_APP_TAB_SIZE - 1)
1070 static struct list_head sctp_apps
[SCTP_APP_TAB_SIZE
];
1071 static DEFINE_SPINLOCK(sctp_app_lock
);
1073 static inline __u16
sctp_app_hashkey(__be16 port
)
1075 return (((__force u16
)port
>> SCTP_APP_TAB_BITS
) ^ (__force u16
)port
)
1076 & SCTP_APP_TAB_MASK
;
1079 static int sctp_register_app(struct ip_vs_app
*inc
)
1081 struct ip_vs_app
*i
;
1083 __be16 port
= inc
->port
;
1086 hash
= sctp_app_hashkey(port
);
1088 spin_lock_bh(&sctp_app_lock
);
1089 list_for_each_entry(i
, &sctp_apps
[hash
], p_list
) {
1090 if (i
->port
== port
) {
1095 list_add(&inc
->p_list
, &sctp_apps
[hash
]);
1096 atomic_inc(&ip_vs_protocol_sctp
.appcnt
);
1098 spin_unlock_bh(&sctp_app_lock
);
1103 static void sctp_unregister_app(struct ip_vs_app
*inc
)
1105 spin_lock_bh(&sctp_app_lock
);
1106 atomic_dec(&ip_vs_protocol_sctp
.appcnt
);
1107 list_del(&inc
->p_list
);
1108 spin_unlock_bh(&sctp_app_lock
);
1111 static int sctp_app_conn_bind(struct ip_vs_conn
*cp
)
1114 struct ip_vs_app
*inc
;
1117 /* Default binding: bind app only for NAT */
1118 if (IP_VS_FWD_METHOD(cp
) != IP_VS_CONN_F_MASQ
)
1120 /* Lookup application incarnations and bind the right one */
1121 hash
= sctp_app_hashkey(cp
->vport
);
1123 spin_lock(&sctp_app_lock
);
1124 list_for_each_entry(inc
, &sctp_apps
[hash
], p_list
) {
1125 if (inc
->port
== cp
->vport
) {
1126 if (unlikely(!ip_vs_app_inc_get(inc
)))
1128 spin_unlock(&sctp_app_lock
);
1130 IP_VS_DBG_BUF(9, "%s: Binding conn %s:%u->"
1131 "%s:%u to app %s on port %u\n",
1133 IP_VS_DBG_ADDR(cp
->af
, &cp
->caddr
),
1135 IP_VS_DBG_ADDR(cp
->af
, &cp
->vaddr
),
1137 inc
->name
, ntohs(inc
->port
));
1140 result
= inc
->init_conn(inc
, cp
);
1144 spin_unlock(&sctp_app_lock
);
1149 static void ip_vs_sctp_init(struct ip_vs_protocol
*pp
)
1151 IP_VS_INIT_HASH_TABLE(sctp_apps
);
1152 pp
->timeout_table
= sctp_timeouts
;
1156 static void ip_vs_sctp_exit(struct ip_vs_protocol
*pp
)
1161 struct ip_vs_protocol ip_vs_protocol_sctp
= {
1163 .protocol
= IPPROTO_SCTP
,
1164 .num_states
= IP_VS_SCTP_S_LAST
,
1166 .appcnt
= ATOMIC_INIT(0),
1167 .init
= ip_vs_sctp_init
,
1168 .exit
= ip_vs_sctp_exit
,
1169 .register_app
= sctp_register_app
,
1170 .unregister_app
= sctp_unregister_app
,
1171 .conn_schedule
= sctp_conn_schedule
,
1172 .conn_in_get
= sctp_conn_in_get
,
1173 .conn_out_get
= sctp_conn_out_get
,
1174 .snat_handler
= sctp_snat_handler
,
1175 .dnat_handler
= sctp_dnat_handler
,
1176 .csum_check
= sctp_csum_check
,
1177 .state_name
= sctp_state_name
,
1178 .state_transition
= sctp_state_transition
,
1179 .app_conn_bind
= sctp_app_conn_bind
,
1180 .debug_packet
= ip_vs_tcpudp_debug_packet
,
1181 .timeout_change
= sctp_timeout_change
,
1182 .set_state_timeout
= sctp_set_state_timeout
,