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 sctp_conn_schedule(int af, struct sk_buff *skb, struct ip_vs_proto_data *pd,
13 int *verdict, struct ip_vs_conn **cpp,
14 struct ip_vs_iphdr *iph)
17 struct ip_vs_service *svc;
18 sctp_chunkhdr_t _schunkh, *sch;
19 sctp_sctphdr_t *sh, _sctph;
21 sh = skb_header_pointer(skb, iph->len, sizeof(_sctph), &_sctph);
25 sch = skb_header_pointer(skb, iph->len + sizeof(sctp_sctphdr_t),
26 sizeof(_schunkh), &_schunkh);
30 if ((sch->type == SCTP_CID_INIT) &&
31 (svc = ip_vs_service_get(net, af, skb->mark, iph->protocol,
32 &iph->daddr, sh->dest))) {
35 if (ip_vs_todrop(net_ipvs(net))) {
37 * It seems that we are very loaded.
38 * We have to drop this packet :(
40 ip_vs_service_put(svc);
45 * Let the virtual server select a real server for the
46 * incoming connection, and create a connection entry.
48 *cpp = ip_vs_schedule(svc, skb, pd, &ignored, iph);
49 if (!*cpp && ignored <= 0) {
51 *verdict = ip_vs_leave(svc, skb, pd, iph);
53 ip_vs_service_put(svc);
58 ip_vs_service_put(svc);
65 sctp_snat_handler(struct sk_buff *skb, struct ip_vs_protocol *pp,
66 struct ip_vs_conn *cp, struct ip_vs_iphdr *iph)
68 sctp_sctphdr_t *sctph;
69 unsigned int sctphoff = iph->len;
73 #ifdef CONFIG_IP_VS_IPV6
74 if (cp->af == AF_INET6 && iph->fragoffs)
78 /* csum_check requires unshared skb */
79 if (!skb_make_writable(skb, sctphoff + sizeof(*sctph)))
82 if (unlikely(cp->app != NULL)) {
83 /* Some checks before mangling */
84 if (pp->csum_check && !pp->csum_check(cp->af, skb, pp))
87 /* Call application helper if needed */
88 if (!ip_vs_app_pkt_out(cp, skb))
92 sctph = (void *) skb_network_header(skb) + sctphoff;
93 sctph->source = cp->vport;
95 /* Calculate the checksum */
96 crc32 = sctp_start_cksum((u8 *) sctph, skb_headlen(skb) - sctphoff);
97 skb_walk_frags(skb, iter)
98 crc32 = sctp_update_cksum((u8 *) iter->data, skb_headlen(iter),
100 crc32 = sctp_end_cksum(crc32);
101 sctph->checksum = crc32;
107 sctp_dnat_handler(struct sk_buff *skb, struct ip_vs_protocol *pp,
108 struct ip_vs_conn *cp, struct ip_vs_iphdr *iph)
110 sctp_sctphdr_t *sctph;
111 unsigned int sctphoff = iph->len;
112 struct sk_buff *iter;
115 #ifdef CONFIG_IP_VS_IPV6
116 if (cp->af == AF_INET6 && iph->fragoffs)
120 /* csum_check requires unshared skb */
121 if (!skb_make_writable(skb, sctphoff + sizeof(*sctph)))
124 if (unlikely(cp->app != NULL)) {
125 /* Some checks before mangling */
126 if (pp->csum_check && !pp->csum_check(cp->af, skb, pp))
129 /* Call application helper if needed */
130 if (!ip_vs_app_pkt_in(cp, skb))
134 sctph = (void *) skb_network_header(skb) + sctphoff;
135 sctph->dest = cp->dport;
137 /* Calculate the checksum */
138 crc32 = sctp_start_cksum((u8 *) sctph, skb_headlen(skb) - sctphoff);
139 skb_walk_frags(skb, iter)
140 crc32 = sctp_update_cksum((u8 *) iter->data, skb_headlen(iter),
142 crc32 = sctp_end_cksum(crc32);
143 sctph->checksum = crc32;
149 sctp_csum_check(int af, struct sk_buff *skb, struct ip_vs_protocol *pp)
151 unsigned int sctphoff;
152 struct sctphdr *sh, _sctph;
153 struct sk_buff *iter;
158 #ifdef CONFIG_IP_VS_IPV6
160 sctphoff = sizeof(struct ipv6hdr);
163 sctphoff = ip_hdrlen(skb);
165 sh = skb_header_pointer(skb, sctphoff, sizeof(_sctph), &_sctph);
171 tmp = sctp_start_cksum((__u8 *) sh, skb_headlen(skb));
172 skb_walk_frags(skb, iter)
173 tmp = sctp_update_cksum((__u8 *) iter->data,
174 skb_headlen(iter), tmp);
176 val = sctp_end_cksum(tmp);
179 /* CRC failure, dump it. */
180 IP_VS_DBG_RL_PKT(0, af, pp, skb, 0,
181 "Failed checksum for");
187 struct ipvs_sctp_nextstate {
190 enum ipvs_sctp_event_t {
191 IP_VS_SCTP_EVE_DATA_CLI,
192 IP_VS_SCTP_EVE_DATA_SER,
193 IP_VS_SCTP_EVE_INIT_CLI,
194 IP_VS_SCTP_EVE_INIT_SER,
195 IP_VS_SCTP_EVE_INIT_ACK_CLI,
196 IP_VS_SCTP_EVE_INIT_ACK_SER,
197 IP_VS_SCTP_EVE_COOKIE_ECHO_CLI,
198 IP_VS_SCTP_EVE_COOKIE_ECHO_SER,
199 IP_VS_SCTP_EVE_COOKIE_ACK_CLI,
200 IP_VS_SCTP_EVE_COOKIE_ACK_SER,
201 IP_VS_SCTP_EVE_ABORT_CLI,
202 IP_VS_SCTP_EVE__ABORT_SER,
203 IP_VS_SCTP_EVE_SHUT_CLI,
204 IP_VS_SCTP_EVE_SHUT_SER,
205 IP_VS_SCTP_EVE_SHUT_ACK_CLI,
206 IP_VS_SCTP_EVE_SHUT_ACK_SER,
207 IP_VS_SCTP_EVE_SHUT_COM_CLI,
208 IP_VS_SCTP_EVE_SHUT_COM_SER,
212 static enum ipvs_sctp_event_t sctp_events[255] = {
213 IP_VS_SCTP_EVE_DATA_CLI,
214 IP_VS_SCTP_EVE_INIT_CLI,
215 IP_VS_SCTP_EVE_INIT_ACK_CLI,
216 IP_VS_SCTP_EVE_DATA_CLI,
217 IP_VS_SCTP_EVE_DATA_CLI,
218 IP_VS_SCTP_EVE_DATA_CLI,
219 IP_VS_SCTP_EVE_ABORT_CLI,
220 IP_VS_SCTP_EVE_SHUT_CLI,
221 IP_VS_SCTP_EVE_SHUT_ACK_CLI,
222 IP_VS_SCTP_EVE_DATA_CLI,
223 IP_VS_SCTP_EVE_COOKIE_ECHO_CLI,
224 IP_VS_SCTP_EVE_COOKIE_ACK_CLI,
225 IP_VS_SCTP_EVE_DATA_CLI,
226 IP_VS_SCTP_EVE_DATA_CLI,
227 IP_VS_SCTP_EVE_SHUT_COM_CLI,
230 static struct ipvs_sctp_nextstate
231 sctp_states_table[IP_VS_SCTP_S_LAST][IP_VS_SCTP_EVE_LAST] = {
233 * STATE : IP_VS_SCTP_S_NONE
235 /*next state *//*event */
236 {{IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_CLI */ },
237 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_SER */ },
238 {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ },
239 {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ },
240 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
241 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
242 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
243 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
244 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
245 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
246 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ },
247 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ },
248 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_CLI */ },
249 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_SER */ },
250 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
251 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
252 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
253 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ },
256 * STATE : IP_VS_SCTP_S_INIT_CLI
257 * Cient sent INIT and is waiting for reply from server(In ECHO_WAIT)
259 {{IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_CLI */ },
260 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_SER */ },
261 {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ },
262 {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ },
263 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
264 {IP_VS_SCTP_S_INIT_ACK_SER /* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
265 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ECHO_CLI */ },
266 {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_ECHO_SER */ },
267 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
268 {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
269 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ },
270 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ },
271 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_CLI */ },
272 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_SER */ },
273 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
274 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
275 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
276 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
279 * State : IP_VS_SCTP_S_INIT_SER
280 * Server sent INIT and waiting for INIT ACK from the client
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_INIT_ACK_CLI /* 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_INIT_SER /* 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_INIT_SER /* 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_ACK_CLI
303 * Client sent INIT ACK and waiting for ECHO from the server
305 {{IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_CLI */ },
306 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_SER */ },
308 * We have got an INIT from client. From the spec.“Upon receipt of
309 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
310 * an INIT ACK using the same parameters it sent in its original
311 * INIT chunk (including its Initiate Tag, unchanged”).
313 {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ },
314 {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ },
316 * INIT_ACK has been resent by the client, let us stay is in
319 {IP_VS_SCTP_S_INIT_ACK_CLI /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
321 * INIT_ACK sent by the server, close the connection
323 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
325 * ECHO by client, it should not happen, close the connection
327 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
329 * ECHO by server, this is what we are expecting, move to ECHO_SER
331 {IP_VS_SCTP_S_ECHO_SER /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
333 * COOKIE ACK from client, it should not happen, close the connection
335 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
337 * Unexpected COOKIE ACK from server, staty in the same state
339 {IP_VS_SCTP_S_INIT_ACK_CLI /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
340 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ },
341 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ },
342 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_CLI */ },
343 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_SER */ },
344 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
345 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
346 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
347 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
350 * State : IP_VS_SCTP_S_INIT_ACK_SER
351 * Server sent INIT ACK and waiting for ECHO from the client
353 {{IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_CLI */ },
354 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_SER */ },
356 * We have got an INIT from client. From the spec.“Upon receipt of
357 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
358 * an INIT ACK using the same parameters it sent in its original
359 * INIT chunk (including its Initiate Tag, unchanged”).
361 {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ },
362 {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ },
364 * Unexpected INIT_ACK by the client, let us close the connection
366 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
368 * INIT_ACK resent by the server, let us move to same state
370 {IP_VS_SCTP_S_INIT_ACK_SER /* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
372 * Client send the ECHO, this is what we are expecting,
375 {IP_VS_SCTP_S_ECHO_CLI /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
377 * ECHO received from the server, Not sure what to do,
380 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
382 * COOKIE ACK from client, let us stay in the same state
384 {IP_VS_SCTP_S_INIT_ACK_SER /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
386 * COOKIE ACK from server, hmm... this should not happen, lets close
389 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
390 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ },
391 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ },
392 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_CLI */ },
393 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_SER */ },
394 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
395 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
396 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
397 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
400 * State : IP_VS_SCTP_S_ECHO_CLI
401 * Cient sent ECHO and waiting COOKEI ACK from the Server
403 {{IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_CLI */ },
404 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_SER */ },
406 * We have got an INIT from client. From the spec.“Upon receipt of
407 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
408 * an INIT ACK using the same parameters it sent in its original
409 * INIT chunk (including its Initiate Tag, unchanged”).
411 {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ },
412 {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ },
414 * INIT_ACK has been by the client, let us close the connection
416 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
418 * INIT_ACK sent by the server, Unexpected INIT ACK, spec says,
419 * “If an INIT ACK is received by an endpoint in any state other
420 * than the COOKIE-WAIT state, the endpoint should discard the
421 * INIT ACK chunk”. Stay in the same state
423 {IP_VS_SCTP_S_ECHO_CLI /* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
425 * Client resent the ECHO, let us stay in the same state
427 {IP_VS_SCTP_S_ECHO_CLI /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
429 * ECHO received from the server, Not sure what to do,
432 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
434 * COOKIE ACK from client, this shoud not happen, let's close the
437 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
439 * COOKIE ACK from server, this is what we are awaiting,lets move to
442 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
443 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ },
444 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ },
445 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_CLI */ },
446 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_SER */ },
447 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
448 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
449 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
450 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
453 * State : IP_VS_SCTP_S_ECHO_SER
454 * Server sent ECHO and waiting COOKEI ACK from the client
456 {{IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_CLI */ },
457 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_SER */ },
459 * We have got an INIT from client. From the spec.“Upon receipt of
460 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
461 * an INIT ACK using the same parameters it sent in its original
462 * INIT chunk (including its Initiate Tag, unchanged”).
464 {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ },
465 {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ },
467 * INIT_ACK sent by the server, Unexpected INIT ACK, spec says,
468 * “If an INIT ACK is received by an endpoint in any state other
469 * than the COOKIE-WAIT state, the endpoint should discard the
470 * INIT ACK chunk”. Stay in the same state
472 {IP_VS_SCTP_S_ECHO_SER /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
474 * INIT_ACK has been by the server, let us close the connection
476 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
478 * Client sent the ECHO, not sure what to do, let's close the
481 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
483 * ECHO resent by the server, stay in the same state
485 {IP_VS_SCTP_S_ECHO_SER /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
487 * COOKIE ACK from client, this is what we are expecting, let's move
490 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
492 * COOKIE ACK from server, this should not happen, lets close the
495 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
496 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ },
497 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ },
498 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_CLI */ },
499 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_SER */ },
500 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
501 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
502 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
503 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
506 * State : IP_VS_SCTP_S_ESTABLISHED
507 * Association established
509 {{IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_DATA_CLI */ },
510 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_DATA_SER */ },
512 * We have got an INIT from client. From the spec.“Upon receipt of
513 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
514 * an INIT ACK using the same parameters it sent in its original
515 * INIT chunk (including its Initiate Tag, unchanged”).
517 {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ },
518 {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ },
520 * INIT_ACK sent by the server, Unexpected INIT ACK, spec says,
521 * “If an INIT ACK is received by an endpoint in any state other
522 * than the COOKIE-WAIT state, the endpoint should discard the
523 * INIT ACK chunk”. Stay in the same state
525 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
526 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
528 * Client sent ECHO, Spec(sec 5.2.4) says it may be handled by the
529 * peer and peer shall move to the ESTABISHED. if it doesn't handle
530 * it will send ERROR chunk. So, stay in the same state
532 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
533 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
535 * COOKIE ACK from client, not sure what to do stay in the same state
537 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
538 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
539 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ },
540 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ },
542 * SHUTDOWN from the client, move to SHUDDOWN_CLI
544 {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_SHUT_CLI */ },
546 * SHUTDOWN from the server, move to SHUTDOWN_SER
548 {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_SHUT_SER */ },
550 * client sent SHUDTDOWN_ACK, this should not happen, let's close
553 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
554 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
555 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
556 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
559 * State : IP_VS_SCTP_S_SHUT_CLI
560 * SHUTDOWN sent from the client, waitinf for SHUT ACK from the server
563 * We received the data chuck, keep the state unchanged. I assume
564 * that still data chuncks can be received by both the peers in
568 {{IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_DATA_CLI */ },
569 {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_DATA_SER */ },
571 * We have got an INIT from client. From the spec.“Upon receipt of
572 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
573 * an INIT ACK using the same parameters it sent in its original
574 * INIT chunk (including its Initiate Tag, unchanged”).
576 {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ },
577 {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ },
579 * INIT_ACK sent by the server, Unexpected INIT ACK, spec says,
580 * “If an INIT ACK is received by an endpoint in any state other
581 * than the COOKIE-WAIT state, the endpoint should discard the
582 * INIT ACK chunk”. Stay in the same state
584 {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
585 {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
587 * Client sent ECHO, Spec(sec 5.2.4) says it may be handled by the
588 * peer and peer shall move to the ESTABISHED. if it doesn't handle
589 * it will send ERROR chunk. So, stay in the same state
591 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
592 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
594 * COOKIE ACK from client, not sure what to do stay in the same state
596 {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
597 {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
598 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ },
599 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ },
601 * SHUTDOWN resent from the client, move to SHUDDOWN_CLI
603 {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_SHUT_CLI */ },
605 * SHUTDOWN from the server, move to SHUTDOWN_SER
607 {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_SHUT_SER */ },
609 * client sent SHUDTDOWN_ACK, this should not happen, let's close
612 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
614 * Server sent SHUTDOWN ACK, this is what we are expecting, let's move
617 {IP_VS_SCTP_S_SHUT_ACK_SER /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
619 * SHUTDOWN COM from client, this should not happen, let's close the
622 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
623 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
626 * State : IP_VS_SCTP_S_SHUT_SER
627 * SHUTDOWN sent from the server, waitinf for SHUTDOWN ACK from client
630 * We received the data chuck, keep the state unchanged. I assume
631 * that still data chuncks can be received by both the peers in
635 {{IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_DATA_CLI */ },
636 {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_DATA_SER */ },
638 * We have got an INIT from client. From the spec.“Upon receipt of
639 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
640 * an INIT ACK using the same parameters it sent in its original
641 * INIT chunk (including its Initiate Tag, unchanged”).
643 {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ },
644 {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ },
646 * INIT_ACK sent by the server, Unexpected INIT ACK, spec says,
647 * “If an INIT ACK is received by an endpoint in any state other
648 * than the COOKIE-WAIT state, the endpoint should discard the
649 * INIT ACK chunk”. Stay in the same state
651 {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
652 {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
654 * Client sent ECHO, Spec(sec 5.2.4) says it may be handled by the
655 * peer and peer shall move to the ESTABISHED. if it doesn't handle
656 * it will send ERROR chunk. So, stay in the same state
658 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
659 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
661 * COOKIE ACK from client, not sure what to do stay in the same state
663 {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
664 {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
665 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ },
666 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ },
668 * SHUTDOWN resent from the client, move to SHUDDOWN_CLI
670 {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_SHUT_CLI */ },
672 * SHUTDOWN resent from the server, move to SHUTDOWN_SER
674 {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_SHUT_SER */ },
676 * client sent SHUDTDOWN_ACK, this is what we are expecting, let's
677 * move to SHUT_ACK_CLI
679 {IP_VS_SCTP_S_SHUT_ACK_CLI /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
681 * Server sent SHUTDOWN ACK, this should not happen, let's close the
684 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
686 * SHUTDOWN COM from client, this should not happen, let's close the
689 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
690 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
694 * State : IP_VS_SCTP_S_SHUT_ACK_CLI
695 * SHUTDOWN ACK from the client, awaiting for SHUTDOWN COM from server
698 * We received the data chuck, keep the state unchanged. I assume
699 * that still data chuncks can be received by both the peers in
703 {{IP_VS_SCTP_S_SHUT_ACK_CLI /* IP_VS_SCTP_EVE_DATA_CLI */ },
704 {IP_VS_SCTP_S_SHUT_ACK_CLI /* IP_VS_SCTP_EVE_DATA_SER */ },
706 * We have got an INIT from client. From the spec.“Upon receipt of
707 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
708 * an INIT ACK using the same parameters it sent in its original
709 * INIT chunk (including its Initiate Tag, unchanged”).
711 {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ },
712 {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ },
714 * INIT_ACK sent by the server, Unexpected INIT ACK, spec says,
715 * “If an INIT ACK is received by an endpoint in any state other
716 * than the COOKIE-WAIT state, the endpoint should discard the
717 * INIT ACK chunk”. Stay in the same state
719 {IP_VS_SCTP_S_SHUT_ACK_CLI /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
720 {IP_VS_SCTP_S_SHUT_ACK_CLI /* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
722 * Client sent ECHO, Spec(sec 5.2.4) says it may be handled by the
723 * peer and peer shall move to the ESTABISHED. if it doesn't handle
724 * it will send ERROR chunk. So, stay in the same state
726 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
727 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
729 * COOKIE ACK from client, not sure what to do stay in the same state
731 {IP_VS_SCTP_S_SHUT_ACK_CLI /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
732 {IP_VS_SCTP_S_SHUT_ACK_CLI /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
733 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ },
734 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ },
736 * SHUTDOWN sent from the client, move to SHUDDOWN_CLI
738 {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_SHUT_CLI */ },
740 * SHUTDOWN sent from the server, move to SHUTDOWN_SER
742 {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_SHUT_SER */ },
744 * client resent SHUDTDOWN_ACK, let's stay in the same state
746 {IP_VS_SCTP_S_SHUT_ACK_CLI /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
748 * Server sent SHUTDOWN ACK, this should not happen, let's close the
751 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
753 * SHUTDOWN COM from client, this should not happen, let's close the
756 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
758 * SHUTDOWN COMPLETE from server this is what we are expecting.
760 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
764 * State : IP_VS_SCTP_S_SHUT_ACK_SER
765 * SHUTDOWN ACK from the server, awaiting for SHUTDOWN COM from client
768 * We received the data chuck, keep the state unchanged. I assume
769 * that still data chuncks can be received by both the peers in
773 {{IP_VS_SCTP_S_SHUT_ACK_SER /* IP_VS_SCTP_EVE_DATA_CLI */ },
774 {IP_VS_SCTP_S_SHUT_ACK_SER /* IP_VS_SCTP_EVE_DATA_SER */ },
776 * We have got an INIT from client. From the spec.“Upon receipt of
777 * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with
778 * an INIT ACK using the same parameters it sent in its original
779 * INIT chunk (including its Initiate Tag, unchanged”).
781 {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ },
782 {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ },
784 * INIT_ACK sent by the server, Unexpected INIT ACK, spec says,
785 * “If an INIT ACK is received by an endpoint in any state other
786 * than the COOKIE-WAIT state, the endpoint should discard the
787 * INIT ACK chunk”. Stay in the same state
789 {IP_VS_SCTP_S_SHUT_ACK_SER /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
790 {IP_VS_SCTP_S_SHUT_ACK_SER /* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
792 * Client sent ECHO, Spec(sec 5.2.4) says it may be handled by the
793 * peer and peer shall move to the ESTABISHED. if it doesn't handle
794 * it will send ERROR chunk. So, stay in the same state
796 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
797 {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
799 * COOKIE ACK from client, not sure what to do stay in the same state
801 {IP_VS_SCTP_S_SHUT_ACK_SER /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
802 {IP_VS_SCTP_S_SHUT_ACK_SER /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
803 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ },
804 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ },
806 * SHUTDOWN sent from the client, move to SHUDDOWN_CLI
808 {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_SHUT_CLI */ },
810 * SHUTDOWN sent from the server, move to SHUTDOWN_SER
812 {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_SHUT_SER */ },
814 * client sent SHUDTDOWN_ACK, this should not happen let's close
817 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
819 * Server resent SHUTDOWN ACK, stay in the same state
821 {IP_VS_SCTP_S_SHUT_ACK_SER /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
823 * SHUTDOWN COM from client, this what we are expecting, let's close
826 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
828 * SHUTDOWN COMPLETE from server this should not happen.
830 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
833 * State : IP_VS_SCTP_S_CLOSED
835 {{IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_CLI */ },
836 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_SER */ },
837 {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ },
838 {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ },
839 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ },
840 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_SER */ },
841 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ },
842 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ },
843 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ },
844 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ },
845 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ },
846 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ },
847 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_CLI */ },
848 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_SER */ },
849 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ },
850 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ },
851 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ },
852 {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ }
857 * Timeout table[state]
859 static const int sctp_timeouts[IP_VS_SCTP_S_LAST + 1] = {
860 [IP_VS_SCTP_S_NONE] = 2 * HZ,
861 [IP_VS_SCTP_S_INIT_CLI] = 1 * 60 * HZ,
862 [IP_VS_SCTP_S_INIT_SER] = 1 * 60 * HZ,
863 [IP_VS_SCTP_S_INIT_ACK_CLI] = 1 * 60 * HZ,
864 [IP_VS_SCTP_S_INIT_ACK_SER] = 1 * 60 * HZ,
865 [IP_VS_SCTP_S_ECHO_CLI] = 1 * 60 * HZ,
866 [IP_VS_SCTP_S_ECHO_SER] = 1 * 60 * HZ,
867 [IP_VS_SCTP_S_ESTABLISHED] = 15 * 60 * HZ,
868 [IP_VS_SCTP_S_SHUT_CLI] = 1 * 60 * HZ,
869 [IP_VS_SCTP_S_SHUT_SER] = 1 * 60 * HZ,
870 [IP_VS_SCTP_S_SHUT_ACK_CLI] = 1 * 60 * HZ,
871 [IP_VS_SCTP_S_SHUT_ACK_SER] = 1 * 60 * HZ,
872 [IP_VS_SCTP_S_CLOSED] = 10 * HZ,
873 [IP_VS_SCTP_S_LAST] = 2 * HZ,
876 static const char *sctp_state_name_table[IP_VS_SCTP_S_LAST + 1] = {
877 [IP_VS_SCTP_S_NONE] = "NONE",
878 [IP_VS_SCTP_S_INIT_CLI] = "INIT_CLI",
879 [IP_VS_SCTP_S_INIT_SER] = "INIT_SER",
880 [IP_VS_SCTP_S_INIT_ACK_CLI] = "INIT_ACK_CLI",
881 [IP_VS_SCTP_S_INIT_ACK_SER] = "INIT_ACK_SER",
882 [IP_VS_SCTP_S_ECHO_CLI] = "COOKIE_ECHO_CLI",
883 [IP_VS_SCTP_S_ECHO_SER] = "COOKIE_ECHO_SER",
884 [IP_VS_SCTP_S_ESTABLISHED] = "ESTABISHED",
885 [IP_VS_SCTP_S_SHUT_CLI] = "SHUTDOWN_CLI",
886 [IP_VS_SCTP_S_SHUT_SER] = "SHUTDOWN_SER",
887 [IP_VS_SCTP_S_SHUT_ACK_CLI] = "SHUTDOWN_ACK_CLI",
888 [IP_VS_SCTP_S_SHUT_ACK_SER] = "SHUTDOWN_ACK_SER",
889 [IP_VS_SCTP_S_CLOSED] = "CLOSED",
890 [IP_VS_SCTP_S_LAST] = "BUG!"
894 static const char *sctp_state_name(int state)
896 if (state >= IP_VS_SCTP_S_LAST)
898 if (sctp_state_name_table[state])
899 return sctp_state_name_table[state];
904 set_sctp_state(struct ip_vs_proto_data *pd, struct ip_vs_conn *cp,
905 int direction, const struct sk_buff *skb)
907 sctp_chunkhdr_t _sctpch, *sch;
908 unsigned char chunk_type;
909 int event, next_state;
912 #ifdef CONFIG_IP_VS_IPV6
913 ihl = cp->af == AF_INET ? ip_hdrlen(skb) : sizeof(struct ipv6hdr);
915 ihl = ip_hdrlen(skb);
918 sch = skb_header_pointer(skb, ihl + sizeof(sctp_sctphdr_t),
919 sizeof(_sctpch), &_sctpch);
923 chunk_type = sch->type;
925 * Section 3: Multiple chunks can be bundled into one SCTP packet
926 * up to the MTU size, except for the INIT, INIT ACK, and
927 * SHUTDOWN COMPLETE chunks. These chunks MUST NOT be bundled with
928 * any other chunk in a packet.
930 * Section 3.3.7: DATA chunks MUST NOT be bundled with ABORT. Control
931 * chunks (except for INIT, INIT ACK, and SHUTDOWN COMPLETE) MAY be
932 * bundled with an ABORT, but they MUST be placed before the ABORT
933 * in the SCTP packet or they will be ignored by the receiver.
935 if ((sch->type == SCTP_CID_COOKIE_ECHO) ||
936 (sch->type == SCTP_CID_COOKIE_ACK)) {
937 sch = skb_header_pointer(skb, (ihl + sizeof(sctp_sctphdr_t) +
938 sch->length), sizeof(_sctpch), &_sctpch);
940 if (sch->type == SCTP_CID_ABORT)
941 chunk_type = sch->type;
945 event = sctp_events[chunk_type];
948 * If the direction is IP_VS_DIR_OUTPUT, this event is from server
950 if (direction == IP_VS_DIR_OUTPUT)
955 next_state = sctp_states_table[cp->state][event].next_state;
957 if (next_state != cp->state) {
958 struct ip_vs_dest *dest = cp->dest;
960 IP_VS_DBG_BUF(8, "%s %s %s:%d->"
961 "%s:%d state: %s->%s conn->refcnt:%d\n",
963 ((direction == IP_VS_DIR_OUTPUT) ?
964 "output " : "input "),
965 IP_VS_DBG_ADDR(cp->af, &cp->daddr),
967 IP_VS_DBG_ADDR(cp->af, &cp->caddr),
969 sctp_state_name(cp->state),
970 sctp_state_name(next_state),
971 atomic_read(&cp->refcnt));
973 if (!(cp->flags & IP_VS_CONN_F_INACTIVE) &&
974 (next_state != IP_VS_SCTP_S_ESTABLISHED)) {
975 atomic_dec(&dest->activeconns);
976 atomic_inc(&dest->inactconns);
977 cp->flags |= IP_VS_CONN_F_INACTIVE;
978 } else if ((cp->flags & IP_VS_CONN_F_INACTIVE) &&
979 (next_state == IP_VS_SCTP_S_ESTABLISHED)) {
980 atomic_inc(&dest->activeconns);
981 atomic_dec(&dest->inactconns);
982 cp->flags &= ~IP_VS_CONN_F_INACTIVE;
987 cp->timeout = pd->timeout_table[cp->state = next_state];
988 else /* What to do ? */
989 cp->timeout = sctp_timeouts[cp->state = next_state];
993 sctp_state_transition(struct ip_vs_conn *cp, int direction,
994 const struct sk_buff *skb, struct ip_vs_proto_data *pd)
996 spin_lock(&cp->lock);
997 set_sctp_state(pd, cp, direction, skb);
998 spin_unlock(&cp->lock);
1001 static inline __u16 sctp_app_hashkey(__be16 port)
1003 return (((__force u16)port >> SCTP_APP_TAB_BITS) ^ (__force u16)port)
1004 & SCTP_APP_TAB_MASK;
1007 static int sctp_register_app(struct net *net, struct ip_vs_app *inc)
1009 struct ip_vs_app *i;
1011 __be16 port = inc->port;
1013 struct netns_ipvs *ipvs = net_ipvs(net);
1014 struct ip_vs_proto_data *pd = ip_vs_proto_data_get(net, IPPROTO_SCTP);
1016 hash = sctp_app_hashkey(port);
1018 spin_lock_bh(&ipvs->sctp_app_lock);
1019 list_for_each_entry(i, &ipvs->sctp_apps[hash], p_list) {
1020 if (i->port == port) {
1025 list_add(&inc->p_list, &ipvs->sctp_apps[hash]);
1026 atomic_inc(&pd->appcnt);
1028 spin_unlock_bh(&ipvs->sctp_app_lock);
1033 static void sctp_unregister_app(struct net *net, struct ip_vs_app *inc)
1035 struct netns_ipvs *ipvs = net_ipvs(net);
1036 struct ip_vs_proto_data *pd = ip_vs_proto_data_get(net, IPPROTO_SCTP);
1038 spin_lock_bh(&ipvs->sctp_app_lock);
1039 atomic_dec(&pd->appcnt);
1040 list_del(&inc->p_list);
1041 spin_unlock_bh(&ipvs->sctp_app_lock);
1044 static int sctp_app_conn_bind(struct ip_vs_conn *cp)
1046 struct netns_ipvs *ipvs = net_ipvs(ip_vs_conn_net(cp));
1048 struct ip_vs_app *inc;
1051 /* Default binding: bind app only for NAT */
1052 if (IP_VS_FWD_METHOD(cp) != IP_VS_CONN_F_MASQ)
1054 /* Lookup application incarnations and bind the right one */
1055 hash = sctp_app_hashkey(cp->vport);
1057 spin_lock(&ipvs->sctp_app_lock);
1058 list_for_each_entry(inc, &ipvs->sctp_apps[hash], p_list) {
1059 if (inc->port == cp->vport) {
1060 if (unlikely(!ip_vs_app_inc_get(inc)))
1062 spin_unlock(&ipvs->sctp_app_lock);
1064 IP_VS_DBG_BUF(9, "%s: Binding conn %s:%u->"
1065 "%s:%u to app %s on port %u\n",
1067 IP_VS_DBG_ADDR(cp->af, &cp->caddr),
1069 IP_VS_DBG_ADDR(cp->af, &cp->vaddr),
1071 inc->name, ntohs(inc->port));
1074 result = inc->init_conn(inc, cp);
1078 spin_unlock(&ipvs->sctp_app_lock);
1083 /* ---------------------------------------------
1084 * timeouts is netns related now.
1085 * ---------------------------------------------
1087 static int __ip_vs_sctp_init(struct net *net, struct ip_vs_proto_data *pd)
1089 struct netns_ipvs *ipvs = net_ipvs(net);
1091 ip_vs_init_hash_table(ipvs->sctp_apps, SCTP_APP_TAB_SIZE);
1092 spin_lock_init(&ipvs->sctp_app_lock);
1093 pd->timeout_table = ip_vs_create_timeout_table((int *)sctp_timeouts,
1094 sizeof(sctp_timeouts));
1095 if (!pd->timeout_table)
1100 static void __ip_vs_sctp_exit(struct net *net, struct ip_vs_proto_data *pd)
1102 kfree(pd->timeout_table);
1105 struct ip_vs_protocol ip_vs_protocol_sctp = {
1107 .protocol = IPPROTO_SCTP,
1108 .num_states = IP_VS_SCTP_S_LAST,
1112 .init_netns = __ip_vs_sctp_init,
1113 .exit_netns = __ip_vs_sctp_exit,
1114 .register_app = sctp_register_app,
1115 .unregister_app = sctp_unregister_app,
1116 .conn_schedule = sctp_conn_schedule,
1117 .conn_in_get = ip_vs_conn_in_get_proto,
1118 .conn_out_get = ip_vs_conn_out_get_proto,
1119 .snat_handler = sctp_snat_handler,
1120 .dnat_handler = sctp_dnat_handler,
1121 .csum_check = sctp_csum_check,
1122 .state_name = sctp_state_name,
1123 .state_transition = sctp_state_transition,
1124 .app_conn_bind = sctp_app_conn_bind,
1125 .debug_packet = ip_vs_tcpudp_debug_packet,
1126 .timeout_change = NULL,