#include #include #include #include #include #include #include #include #include static struct ip_vs_conn * sctp_conn_in_get(int af, const struct sk_buff *skb, struct ip_vs_protocol *pp, const struct ip_vs_iphdr *iph, unsigned int proto_off, int inverse) { __be16 _ports[2], *pptr; pptr = skb_header_pointer(skb, proto_off, sizeof(_ports), _ports); if (pptr == NULL) return NULL; if (likely(!inverse)) return ip_vs_conn_in_get(af, iph->protocol, &iph->saddr, pptr[0], &iph->daddr, pptr[1]); else return ip_vs_conn_in_get(af, iph->protocol, &iph->daddr, pptr[1], &iph->saddr, pptr[0]); } static struct ip_vs_conn * sctp_conn_out_get(int af, const struct sk_buff *skb, struct ip_vs_protocol *pp, const struct ip_vs_iphdr *iph, unsigned int proto_off, int inverse) { __be16 _ports[2], *pptr; pptr = skb_header_pointer(skb, proto_off, sizeof(_ports), _ports); if (pptr == NULL) return NULL; if (likely(!inverse)) return ip_vs_conn_out_get(af, iph->protocol, &iph->saddr, pptr[0], &iph->daddr, pptr[1]); else return ip_vs_conn_out_get(af, iph->protocol, &iph->daddr, pptr[1], &iph->saddr, pptr[0]); } static int sctp_conn_schedule(int af, struct sk_buff *skb, struct ip_vs_protocol *pp, int *verdict, struct ip_vs_conn **cpp) { struct ip_vs_service *svc; sctp_chunkhdr_t _schunkh, *sch; sctp_sctphdr_t *sh, _sctph; struct ip_vs_iphdr iph; ip_vs_fill_iphdr(af, skb_network_header(skb), &iph); sh = skb_header_pointer(skb, iph.len, sizeof(_sctph), &_sctph); if (sh == NULL) return 0; sch = skb_header_pointer(skb, iph.len + sizeof(sctp_sctphdr_t), sizeof(_schunkh), &_schunkh); if (sch == NULL) return 0; if ((sch->type == SCTP_CID_INIT) && (svc = ip_vs_service_get(af, skb->mark, iph.protocol, &iph.daddr, sh->dest))) { if (ip_vs_todrop()) { /* * It seems that we are very loaded. * We have to drop this packet :( */ ip_vs_service_put(svc); *verdict = NF_DROP; return 0; } /* * Let the virtual server select a real server for the * incoming connection, and create a connection entry. */ *cpp = ip_vs_schedule(svc, skb); if (!*cpp) { *verdict = ip_vs_leave(svc, skb, pp); return 0; } ip_vs_service_put(svc); } return 1; } static int sctp_snat_handler(struct sk_buff *skb, struct ip_vs_protocol *pp, struct ip_vs_conn *cp) { sctp_sctphdr_t *sctph; unsigned int sctphoff; __be32 crc32; #ifdef CONFIG_IP_VS_IPV6 if (cp->af == AF_INET6) sctphoff = sizeof(struct ipv6hdr); else #endif sctphoff = ip_hdrlen(skb); /* csum_check requires unshared skb */ if (!skb_make_writable(skb, sctphoff + sizeof(*sctph))) return 0; if (unlikely(cp->app != NULL)) { /* Some checks before mangling */ if (pp->csum_check && !pp->csum_check(cp->af, skb, pp)) return 0; /* Call application helper if needed */ if (!ip_vs_app_pkt_out(cp, skb)) return 0; } sctph = (void *) skb_network_header(skb) + sctphoff; sctph->source = cp->vport; /* Calculate the checksum */ crc32 = sctp_start_cksum((u8 *) sctph, skb_headlen(skb) - sctphoff); for (skb = skb_shinfo(skb)->frag_list; skb; skb = skb->next) crc32 = sctp_update_cksum((u8 *) skb->data, skb_headlen(skb), crc32); crc32 = sctp_end_cksum(crc32); sctph->checksum = crc32; return 1; } static int sctp_dnat_handler(struct sk_buff *skb, struct ip_vs_protocol *pp, struct ip_vs_conn *cp) { sctp_sctphdr_t *sctph; unsigned int sctphoff; __be32 crc32; #ifdef CONFIG_IP_VS_IPV6 if (cp->af == AF_INET6) sctphoff = sizeof(struct ipv6hdr); else #endif sctphoff = ip_hdrlen(skb); /* csum_check requires unshared skb */ if (!skb_make_writable(skb, sctphoff + sizeof(*sctph))) return 0; if (unlikely(cp->app != NULL)) { /* Some checks before mangling */ if (pp->csum_check && !pp->csum_check(cp->af, skb, pp)) return 0; /* Call application helper if needed */ if (!ip_vs_app_pkt_out(cp, skb)) return 0; } sctph = (void *) skb_network_header(skb) + sctphoff; sctph->dest = cp->dport; /* Calculate the checksum */ crc32 = sctp_start_cksum((u8 *) sctph, skb_headlen(skb) - sctphoff); for (skb = skb_shinfo(skb)->frag_list; skb; skb = skb->next) crc32 = sctp_update_cksum((u8 *) skb->data, skb_headlen(skb), crc32); crc32 = sctp_end_cksum(crc32); sctph->checksum = crc32; return 1; } static int sctp_csum_check(int af, struct sk_buff *skb, struct ip_vs_protocol *pp) { struct sk_buff *list = skb_shinfo(skb)->frag_list; unsigned int sctphoff; struct sctphdr *sh, _sctph; __le32 cmp; __le32 val; __u32 tmp; #ifdef CONFIG_IP_VS_IPV6 if (af == AF_INET6) sctphoff = sizeof(struct ipv6hdr); else #endif sctphoff = ip_hdrlen(skb); sh = skb_header_pointer(skb, sctphoff, sizeof(_sctph), &_sctph); if (sh == NULL) return 0; cmp = sh->checksum; tmp = sctp_start_cksum((__u8 *) sh, skb_headlen(skb)); for (; list; list = list->next) tmp = sctp_update_cksum((__u8 *) list->data, skb_headlen(list), tmp); val = sctp_end_cksum(tmp); if (val != cmp) { /* CRC failure, dump it. */ IP_VS_DBG_RL_PKT(0, pp, skb, 0, "Failed checksum for"); return 0; } return 1; } struct ipvs_sctp_nextstate { int next_state; }; enum ipvs_sctp_event_t { IP_VS_SCTP_EVE_DATA_CLI, IP_VS_SCTP_EVE_DATA_SER, IP_VS_SCTP_EVE_INIT_CLI, IP_VS_SCTP_EVE_INIT_SER, IP_VS_SCTP_EVE_INIT_ACK_CLI, IP_VS_SCTP_EVE_INIT_ACK_SER, IP_VS_SCTP_EVE_COOKIE_ECHO_CLI, IP_VS_SCTP_EVE_COOKIE_ECHO_SER, IP_VS_SCTP_EVE_COOKIE_ACK_CLI, IP_VS_SCTP_EVE_COOKIE_ACK_SER, IP_VS_SCTP_EVE_ABORT_CLI, IP_VS_SCTP_EVE__ABORT_SER, IP_VS_SCTP_EVE_SHUT_CLI, IP_VS_SCTP_EVE_SHUT_SER, IP_VS_SCTP_EVE_SHUT_ACK_CLI, IP_VS_SCTP_EVE_SHUT_ACK_SER, IP_VS_SCTP_EVE_SHUT_COM_CLI, IP_VS_SCTP_EVE_SHUT_COM_SER, IP_VS_SCTP_EVE_LAST }; static enum ipvs_sctp_event_t sctp_events[255] = { IP_VS_SCTP_EVE_DATA_CLI, IP_VS_SCTP_EVE_INIT_CLI, IP_VS_SCTP_EVE_INIT_ACK_CLI, IP_VS_SCTP_EVE_DATA_CLI, IP_VS_SCTP_EVE_DATA_CLI, IP_VS_SCTP_EVE_DATA_CLI, IP_VS_SCTP_EVE_ABORT_CLI, IP_VS_SCTP_EVE_SHUT_CLI, IP_VS_SCTP_EVE_SHUT_ACK_CLI, IP_VS_SCTP_EVE_DATA_CLI, IP_VS_SCTP_EVE_COOKIE_ECHO_CLI, IP_VS_SCTP_EVE_COOKIE_ACK_CLI, IP_VS_SCTP_EVE_DATA_CLI, IP_VS_SCTP_EVE_DATA_CLI, IP_VS_SCTP_EVE_SHUT_COM_CLI, }; static struct ipvs_sctp_nextstate sctp_states_table[IP_VS_SCTP_S_LAST][IP_VS_SCTP_EVE_LAST] = { /* * STATE : IP_VS_SCTP_S_NONE */ /*next state *//*event */ {{IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_SER */ }, {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ }, {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ }, }, /* * STATE : IP_VS_SCTP_S_INIT_CLI * Cient sent INIT and is waiting for reply from server(In ECHO_WAIT) */ {{IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_SER */ }, {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ }, {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ }, {IP_VS_SCTP_S_INIT_ACK_SER /* IP_VS_SCTP_EVE_INIT_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ECHO_CLI */ }, {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_ECHO_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ }, {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ } }, /* * State : IP_VS_SCTP_S_INIT_SER * Server sent INIT and waiting for INIT ACK from the client */ {{IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_SER */ }, {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ }, {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ }, {IP_VS_SCTP_S_INIT_ACK_CLI /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_SER */ }, {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ }, {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ } }, /* * State : IP_VS_SCTP_S_INIT_ACK_CLI * Client sent INIT ACK and waiting for ECHO from the server */ {{IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_SER */ }, /* * We have got an INIT from client. From the spec.“Upon receipt of * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with * an INIT ACK using the same parameters it sent in its original * INIT chunk (including its Initiate Tag, unchanged”). */ {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ }, {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ }, /* * INIT_ACK has been resent by the client, let us stay is in * the same state */ {IP_VS_SCTP_S_INIT_ACK_CLI /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ }, /* * INIT_ACK sent by the server, close the connection */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_SER */ }, /* * ECHO by client, it should not happen, close the connection */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ }, /* * ECHO by server, this is what we are expecting, move to ECHO_SER */ {IP_VS_SCTP_S_ECHO_SER /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ }, /* * COOKIE ACK from client, it should not happen, close the connection */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ }, /* * Unexpected COOKIE ACK from server, staty in the same state */ {IP_VS_SCTP_S_INIT_ACK_CLI /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ } }, /* * State : IP_VS_SCTP_S_INIT_ACK_SER * Server sent INIT ACK and waiting for ECHO from the client */ {{IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_SER */ }, /* * We have got an INIT from client. From the spec.“Upon receipt of * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with * an INIT ACK using the same parameters it sent in its original * INIT chunk (including its Initiate Tag, unchanged”). */ {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ }, {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ }, /* * Unexpected INIT_ACK by the client, let us close the connection */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ }, /* * INIT_ACK resent by the server, let us move to same state */ {IP_VS_SCTP_S_INIT_ACK_SER /* IP_VS_SCTP_EVE_INIT_ACK_SER */ }, /* * Client send the ECHO, this is what we are expecting, * move to ECHO_CLI */ {IP_VS_SCTP_S_ECHO_CLI /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ }, /* * ECHO received from the server, Not sure what to do, * let us close it */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ }, /* * COOKIE ACK from client, let us stay in the same state */ {IP_VS_SCTP_S_INIT_ACK_SER /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ }, /* * COOKIE ACK from server, hmm... this should not happen, lets close * the connection. */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ } }, /* * State : IP_VS_SCTP_S_ECHO_CLI * Cient sent ECHO and waiting COOKEI ACK from the Server */ {{IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_SER */ }, /* * We have got an INIT from client. From the spec.“Upon receipt of * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with * an INIT ACK using the same parameters it sent in its original * INIT chunk (including its Initiate Tag, unchanged”). */ {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ }, {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ }, /* * INIT_ACK has been by the client, let us close the connection */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ }, /* * INIT_ACK sent by the server, Unexpected INIT ACK, spec says, * “If an INIT ACK is received by an endpoint in any state other * than the COOKIE-WAIT state, the endpoint should discard the * INIT ACK chunk”. Stay in the same state */ {IP_VS_SCTP_S_ECHO_CLI /* IP_VS_SCTP_EVE_INIT_ACK_SER */ }, /* * Client resent the ECHO, let us stay in the same state */ {IP_VS_SCTP_S_ECHO_CLI /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ }, /* * ECHO received from the server, Not sure what to do, * let us close it */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ }, /* * COOKIE ACK from client, this shoud not happen, let's close the * connection */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ }, /* * COOKIE ACK from server, this is what we are awaiting,lets move to * ESTABLISHED. */ {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ } }, /* * State : IP_VS_SCTP_S_ECHO_SER * Server sent ECHO and waiting COOKEI ACK from the client */ {{IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_SER */ }, /* * We have got an INIT from client. From the spec.“Upon receipt of * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with * an INIT ACK using the same parameters it sent in its original * INIT chunk (including its Initiate Tag, unchanged”). */ {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ }, {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ }, /* * INIT_ACK sent by the server, Unexpected INIT ACK, spec says, * “If an INIT ACK is received by an endpoint in any state other * than the COOKIE-WAIT state, the endpoint should discard the * INIT ACK chunk”. Stay in the same state */ {IP_VS_SCTP_S_ECHO_SER /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ }, /* * INIT_ACK has been by the server, let us close the connection */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_SER */ }, /* * Client sent the ECHO, not sure what to do, let's close the * connection. */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ }, /* * ECHO resent by the server, stay in the same state */ {IP_VS_SCTP_S_ECHO_SER /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ }, /* * COOKIE ACK from client, this is what we are expecting, let's move * to ESTABLISHED. */ {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ }, /* * COOKIE ACK from server, this should not happen, lets close the * connection. */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ } }, /* * State : IP_VS_SCTP_S_ESTABLISHED * Association established */ {{IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_DATA_CLI */ }, {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_DATA_SER */ }, /* * We have got an INIT from client. From the spec.“Upon receipt of * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with * an INIT ACK using the same parameters it sent in its original * INIT chunk (including its Initiate Tag, unchanged”). */ {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ }, {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ }, /* * INIT_ACK sent by the server, Unexpected INIT ACK, spec says, * “If an INIT ACK is received by an endpoint in any state other * than the COOKIE-WAIT state, the endpoint should discard the * INIT ACK chunk”. Stay in the same state */ {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ }, {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_INIT_ACK_SER */ }, /* * Client sent ECHO, Spec(sec 5.2.4) says it may be handled by the * peer and peer shall move to the ESTABISHED. if it doesn't handle * it will send ERROR chunk. So, stay in the same state */ {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ }, {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ }, /* * COOKIE ACK from client, not sure what to do stay in the same state */ {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ }, {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ }, /* * SHUTDOWN from the client, move to SHUDDOWN_CLI */ {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_SHUT_CLI */ }, /* * SHUTDOWN from the server, move to SHUTDOWN_SER */ {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_SHUT_SER */ }, /* * client sent SHUDTDOWN_ACK, this should not happen, let's close * the connection */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ } }, /* * State : IP_VS_SCTP_S_SHUT_CLI * SHUTDOWN sent from the client, waitinf for SHUT ACK from the server */ /* * We recieved the data chuck, keep the state unchanged. I assume * that still data chuncks can be received by both the peers in * SHUDOWN state */ {{IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_DATA_CLI */ }, {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_DATA_SER */ }, /* * We have got an INIT from client. From the spec.“Upon receipt of * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with * an INIT ACK using the same parameters it sent in its original * INIT chunk (including its Initiate Tag, unchanged”). */ {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ }, {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ }, /* * INIT_ACK sent by the server, Unexpected INIT ACK, spec says, * “If an INIT ACK is received by an endpoint in any state other * than the COOKIE-WAIT state, the endpoint should discard the * INIT ACK chunk”. Stay in the same state */ {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ }, {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_INIT_ACK_SER */ }, /* * Client sent ECHO, Spec(sec 5.2.4) says it may be handled by the * peer and peer shall move to the ESTABISHED. if it doesn't handle * it will send ERROR chunk. So, stay in the same state */ {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ }, {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ }, /* * COOKIE ACK from client, not sure what to do stay in the same state */ {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ }, {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ }, /* * SHUTDOWN resent from the client, move to SHUDDOWN_CLI */ {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_SHUT_CLI */ }, /* * SHUTDOWN from the server, move to SHUTDOWN_SER */ {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_SHUT_SER */ }, /* * client sent SHUDTDOWN_ACK, this should not happen, let's close * the connection */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ }, /* * Server sent SHUTDOWN ACK, this is what we are expecting, let's move * to SHUDOWN_ACK_SER */ {IP_VS_SCTP_S_SHUT_ACK_SER /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ }, /* * SHUTDOWN COM from client, this should not happen, let's close the * connection */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ } }, /* * State : IP_VS_SCTP_S_SHUT_SER * SHUTDOWN sent from the server, waitinf for SHUTDOWN ACK from client */ /* * We recieved the data chuck, keep the state unchanged. I assume * that still data chuncks can be received by both the peers in * SHUDOWN state */ {{IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_DATA_CLI */ }, {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_DATA_SER */ }, /* * We have got an INIT from client. From the spec.“Upon receipt of * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with * an INIT ACK using the same parameters it sent in its original * INIT chunk (including its Initiate Tag, unchanged”). */ {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ }, {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ }, /* * INIT_ACK sent by the server, Unexpected INIT ACK, spec says, * “If an INIT ACK is received by an endpoint in any state other * than the COOKIE-WAIT state, the endpoint should discard the * INIT ACK chunk”. Stay in the same state */ {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ }, {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_INIT_ACK_SER */ }, /* * Client sent ECHO, Spec(sec 5.2.4) says it may be handled by the * peer and peer shall move to the ESTABISHED. if it doesn't handle * it will send ERROR chunk. So, stay in the same state */ {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ }, {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ }, /* * COOKIE ACK from client, not sure what to do stay in the same state */ {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ }, {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ }, /* * SHUTDOWN resent from the client, move to SHUDDOWN_CLI */ {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_SHUT_CLI */ }, /* * SHUTDOWN resent from the server, move to SHUTDOWN_SER */ {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_SHUT_SER */ }, /* * client sent SHUDTDOWN_ACK, this is what we are expecting, let's * move to SHUT_ACK_CLI */ {IP_VS_SCTP_S_SHUT_ACK_CLI /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ }, /* * Server sent SHUTDOWN ACK, this should not happen, let's close the * connection */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ }, /* * SHUTDOWN COM from client, this should not happen, let's close the * connection */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ } }, /* * State : IP_VS_SCTP_S_SHUT_ACK_CLI * SHUTDOWN ACK from the client, awaiting for SHUTDOWN COM from server */ /* * We recieved the data chuck, keep the state unchanged. I assume * that still data chuncks can be received by both the peers in * SHUDOWN state */ {{IP_VS_SCTP_S_SHUT_ACK_CLI /* IP_VS_SCTP_EVE_DATA_CLI */ }, {IP_VS_SCTP_S_SHUT_ACK_CLI /* IP_VS_SCTP_EVE_DATA_SER */ }, /* * We have got an INIT from client. From the spec.“Upon receipt of * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with * an INIT ACK using the same parameters it sent in its original * INIT chunk (including its Initiate Tag, unchanged”). */ {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ }, {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ }, /* * INIT_ACK sent by the server, Unexpected INIT ACK, spec says, * “If an INIT ACK is received by an endpoint in any state other * than the COOKIE-WAIT state, the endpoint should discard the * INIT ACK chunk”. Stay in the same state */ {IP_VS_SCTP_S_SHUT_ACK_CLI /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ }, {IP_VS_SCTP_S_SHUT_ACK_CLI /* IP_VS_SCTP_EVE_INIT_ACK_SER */ }, /* * Client sent ECHO, Spec(sec 5.2.4) says it may be handled by the * peer and peer shall move to the ESTABISHED. if it doesn't handle * it will send ERROR chunk. So, stay in the same state */ {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ }, {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ }, /* * COOKIE ACK from client, not sure what to do stay in the same state */ {IP_VS_SCTP_S_SHUT_ACK_CLI /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ }, {IP_VS_SCTP_S_SHUT_ACK_CLI /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ }, /* * SHUTDOWN sent from the client, move to SHUDDOWN_CLI */ {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_SHUT_CLI */ }, /* * SHUTDOWN sent from the server, move to SHUTDOWN_SER */ {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_SHUT_SER */ }, /* * client resent SHUDTDOWN_ACK, let's stay in the same state */ {IP_VS_SCTP_S_SHUT_ACK_CLI /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ }, /* * Server sent SHUTDOWN ACK, this should not happen, let's close the * connection */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ }, /* * SHUTDOWN COM from client, this should not happen, let's close the * connection */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ }, /* * SHUTDOWN COMPLETE from server this is what we are expecting. */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ } }, /* * State : IP_VS_SCTP_S_SHUT_ACK_SER * SHUTDOWN ACK from the server, awaiting for SHUTDOWN COM from client */ /* * We recieved the data chuck, keep the state unchanged. I assume * that still data chuncks can be received by both the peers in * SHUDOWN state */ {{IP_VS_SCTP_S_SHUT_ACK_SER /* IP_VS_SCTP_EVE_DATA_CLI */ }, {IP_VS_SCTP_S_SHUT_ACK_SER /* IP_VS_SCTP_EVE_DATA_SER */ }, /* * We have got an INIT from client. From the spec.“Upon receipt of * an INIT in the COOKIE-WAIT state, an endpoint MUST respond with * an INIT ACK using the same parameters it sent in its original * INIT chunk (including its Initiate Tag, unchanged”). */ {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ }, {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ }, /* * INIT_ACK sent by the server, Unexpected INIT ACK, spec says, * “If an INIT ACK is received by an endpoint in any state other * than the COOKIE-WAIT state, the endpoint should discard the * INIT ACK chunk”. Stay in the same state */ {IP_VS_SCTP_S_SHUT_ACK_SER /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ }, {IP_VS_SCTP_S_SHUT_ACK_SER /* IP_VS_SCTP_EVE_INIT_ACK_SER */ }, /* * Client sent ECHO, Spec(sec 5.2.4) says it may be handled by the * peer and peer shall move to the ESTABISHED. if it doesn't handle * it will send ERROR chunk. So, stay in the same state */ {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ }, {IP_VS_SCTP_S_ESTABLISHED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ }, /* * COOKIE ACK from client, not sure what to do stay in the same state */ {IP_VS_SCTP_S_SHUT_ACK_SER /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ }, {IP_VS_SCTP_S_SHUT_ACK_SER /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ }, /* * SHUTDOWN sent from the client, move to SHUDDOWN_CLI */ {IP_VS_SCTP_S_SHUT_CLI /* IP_VS_SCTP_EVE_SHUT_CLI */ }, /* * SHUTDOWN sent from the server, move to SHUTDOWN_SER */ {IP_VS_SCTP_S_SHUT_SER /* IP_VS_SCTP_EVE_SHUT_SER */ }, /* * client sent SHUDTDOWN_ACK, this should not happen let's close * the connection. */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ }, /* * Server resent SHUTDOWN ACK, stay in the same state */ {IP_VS_SCTP_S_SHUT_ACK_SER /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ }, /* * SHUTDOWN COM from client, this what we are expecting, let's close * the connection */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ }, /* * SHUTDOWN COMPLETE from server this should not happen. */ {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ } }, /* * State : IP_VS_SCTP_S_CLOSED */ {{IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_DATA_SER */ }, {IP_VS_SCTP_S_INIT_CLI /* IP_VS_SCTP_EVE_INIT_CLI */ }, {IP_VS_SCTP_S_INIT_SER /* IP_VS_SCTP_EVE_INIT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_INIT_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ECHO_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_COOKIE_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_ABORT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_ACK_SER */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_CLI */ }, {IP_VS_SCTP_S_CLOSED /* IP_VS_SCTP_EVE_SHUT_COM_SER */ } } }; /* * Timeout table[state] */ static int sctp_timeouts[IP_VS_SCTP_S_LAST + 1] = { [IP_VS_SCTP_S_NONE] = 2 * HZ, [IP_VS_SCTP_S_INIT_CLI] = 1 * 60 * HZ, [IP_VS_SCTP_S_INIT_SER] = 1 * 60 * HZ, [IP_VS_SCTP_S_INIT_ACK_CLI] = 1 * 60 * HZ, [IP_VS_SCTP_S_INIT_ACK_SER] = 1 * 60 * HZ, [IP_VS_SCTP_S_ECHO_CLI] = 1 * 60 * HZ, [IP_VS_SCTP_S_ECHO_SER] = 1 * 60 * HZ, [IP_VS_SCTP_S_ESTABLISHED] = 15 * 60 * HZ, [IP_VS_SCTP_S_SHUT_CLI] = 1 * 60 * HZ, [IP_VS_SCTP_S_SHUT_SER] = 1 * 60 * HZ, [IP_VS_SCTP_S_SHUT_ACK_CLI] = 1 * 60 * HZ, [IP_VS_SCTP_S_SHUT_ACK_SER] = 1 * 60 * HZ, [IP_VS_SCTP_S_CLOSED] = 10 * HZ, [IP_VS_SCTP_S_LAST] = 2 * HZ, }; static const char *sctp_state_name_table[IP_VS_SCTP_S_LAST + 1] = { [IP_VS_SCTP_S_NONE] = "NONE", [IP_VS_SCTP_S_INIT_CLI] = "INIT_CLI", [IP_VS_SCTP_S_INIT_SER] = "INIT_SER", [IP_VS_SCTP_S_INIT_ACK_CLI] = "INIT_ACK_CLI", [IP_VS_SCTP_S_INIT_ACK_SER] = "INIT_ACK_SER", [IP_VS_SCTP_S_ECHO_CLI] = "COOKIE_ECHO_CLI", [IP_VS_SCTP_S_ECHO_SER] = "COOKIE_ECHO_SER", [IP_VS_SCTP_S_ESTABLISHED] = "ESTABISHED", [IP_VS_SCTP_S_SHUT_CLI] = "SHUTDOWN_CLI", [IP_VS_SCTP_S_SHUT_SER] = "SHUTDOWN_SER", [IP_VS_SCTP_S_SHUT_ACK_CLI] = "SHUTDOWN_ACK_CLI", [IP_VS_SCTP_S_SHUT_ACK_SER] = "SHUTDOWN_ACK_SER", [IP_VS_SCTP_S_CLOSED] = "CLOSED", [IP_VS_SCTP_S_LAST] = "BUG!" }; static const char *sctp_state_name(int state) { if (state >= IP_VS_SCTP_S_LAST) return "ERR!"; if (sctp_state_name_table[state]) return sctp_state_name_table[state]; return "?"; } static void sctp_timeout_change(struct ip_vs_protocol *pp, int flags) { } static int sctp_set_state_timeout(struct ip_vs_protocol *pp, char *sname, int to) { return ip_vs_set_state_timeout(pp->timeout_table, IP_VS_SCTP_S_LAST, sctp_state_name_table, sname, to); } static inline int set_sctp_state(struct ip_vs_protocol *pp, struct ip_vs_conn *cp, int direction, const struct sk_buff *skb) { sctp_chunkhdr_t _sctpch, *sch; unsigned char chunk_type; int event, next_state; int ihl; #ifdef CONFIG_IP_VS_IPV6 ihl = cp->af == AF_INET ? ip_hdrlen(skb) : sizeof(struct ipv6hdr); #else ihl = ip_hdrlen(skb); #endif sch = skb_header_pointer(skb, ihl + sizeof(sctp_sctphdr_t), sizeof(_sctpch), &_sctpch); if (sch == NULL) return 0; chunk_type = sch->type; /* * Section 3: Multiple chunks can be bundled into one SCTP packet * up to the MTU size, except for the INIT, INIT ACK, and * SHUTDOWN COMPLETE chunks. These chunks MUST NOT be bundled with * any other chunk in a packet. * * Section 3.3.7: DATA chunks MUST NOT be bundled with ABORT. Control * chunks (except for INIT, INIT ACK, and SHUTDOWN COMPLETE) MAY be * bundled with an ABORT, but they MUST be placed before the ABORT * in the SCTP packet or they will be ignored by the receiver. */ if ((sch->type == SCTP_CID_COOKIE_ECHO) || (sch->type == SCTP_CID_COOKIE_ACK)) { sch = skb_header_pointer(skb, (ihl + sizeof(sctp_sctphdr_t) + sch->length), sizeof(_sctpch), &_sctpch); if (sch) { if (sch->type == SCTP_CID_ABORT) chunk_type = sch->type; } } event = sctp_events[chunk_type]; /* * If the direction is IP_VS_DIR_OUTPUT, this event is from server */ if (direction == IP_VS_DIR_OUTPUT) event++; /* * get next state */ next_state = sctp_states_table[cp->state][event].next_state; if (next_state != cp->state) { struct ip_vs_dest *dest = cp->dest; IP_VS_DBG_BUF(8, "%s %s %s:%d->" "%s:%d state: %s->%s conn->refcnt:%d\n", pp->name, ((direction == IP_VS_DIR_OUTPUT) ? "output " : "input "), IP_VS_DBG_ADDR(cp->af, &cp->daddr), ntohs(cp->dport), IP_VS_DBG_ADDR(cp->af, &cp->caddr), ntohs(cp->cport), sctp_state_name(cp->state), sctp_state_name(next_state), atomic_read(&cp->refcnt)); if (dest) { if (!(cp->flags & IP_VS_CONN_F_INACTIVE) && (next_state != IP_VS_SCTP_S_ESTABLISHED)) { atomic_dec(&dest->activeconns); atomic_inc(&dest->inactconns); cp->flags |= IP_VS_CONN_F_INACTIVE; } else if ((cp->flags & IP_VS_CONN_F_INACTIVE) && (next_state == IP_VS_SCTP_S_ESTABLISHED)) { atomic_inc(&dest->activeconns); atomic_dec(&dest->inactconns); cp->flags &= ~IP_VS_CONN_F_INACTIVE; } } } cp->timeout = pp->timeout_table[cp->state = next_state]; return 1; } static int sctp_state_transition(struct ip_vs_conn *cp, int direction, const struct sk_buff *skb, struct ip_vs_protocol *pp) { int ret = 0; spin_lock(&cp->lock); ret = set_sctp_state(pp, cp, direction, skb); spin_unlock(&cp->lock); return ret; } /* * Hash table for SCTP application incarnations */ #define SCTP_APP_TAB_BITS 4 #define SCTP_APP_TAB_SIZE (1 << SCTP_APP_TAB_BITS) #define SCTP_APP_TAB_MASK (SCTP_APP_TAB_SIZE - 1) static struct list_head sctp_apps[SCTP_APP_TAB_SIZE]; static DEFINE_SPINLOCK(sctp_app_lock); static inline __u16 sctp_app_hashkey(__be16 port) { return (((__force u16)port >> SCTP_APP_TAB_BITS) ^ (__force u16)port) & SCTP_APP_TAB_MASK; } static int sctp_register_app(struct ip_vs_app *inc) { struct ip_vs_app *i; __u16 hash; __be16 port = inc->port; int ret = 0; hash = sctp_app_hashkey(port); spin_lock_bh(&sctp_app_lock); list_for_each_entry(i, &sctp_apps[hash], p_list) { if (i->port == port) { ret = -EEXIST; goto out; } } list_add(&inc->p_list, &sctp_apps[hash]); atomic_inc(&ip_vs_protocol_sctp.appcnt); out: spin_unlock_bh(&sctp_app_lock); return ret; } static void sctp_unregister_app(struct ip_vs_app *inc) { spin_lock_bh(&sctp_app_lock); atomic_dec(&ip_vs_protocol_sctp.appcnt); list_del(&inc->p_list); spin_unlock_bh(&sctp_app_lock); } static int sctp_app_conn_bind(struct ip_vs_conn *cp) { int hash; struct ip_vs_app *inc; int result = 0; /* Default binding: bind app only for NAT */ if (IP_VS_FWD_METHOD(cp) != IP_VS_CONN_F_MASQ) return 0; /* Lookup application incarnations and bind the right one */ hash = sctp_app_hashkey(cp->vport); spin_lock(&sctp_app_lock); list_for_each_entry(inc, &sctp_apps[hash], p_list) { if (inc->port == cp->vport) { if (unlikely(!ip_vs_app_inc_get(inc))) break; spin_unlock(&sctp_app_lock); IP_VS_DBG_BUF(9, "%s: Binding conn %s:%u->" "%s:%u to app %s on port %u\n", __func__, IP_VS_DBG_ADDR(cp->af, &cp->caddr), ntohs(cp->cport), IP_VS_DBG_ADDR(cp->af, &cp->vaddr), ntohs(cp->vport), inc->name, ntohs(inc->port)); cp->app = inc; if (inc->init_conn) result = inc->init_conn(inc, cp); goto out; } } spin_unlock(&sctp_app_lock); out: return result; } static void ip_vs_sctp_init(struct ip_vs_protocol *pp) { IP_VS_INIT_HASH_TABLE(sctp_apps); pp->timeout_table = sctp_timeouts; } static void ip_vs_sctp_exit(struct ip_vs_protocol *pp) { } struct ip_vs_protocol ip_vs_protocol_sctp = { .name = "SCTP", .protocol = IPPROTO_SCTP, .num_states = IP_VS_SCTP_S_LAST, .dont_defrag = 0, .appcnt = ATOMIC_INIT(0), .init = ip_vs_sctp_init, .exit = ip_vs_sctp_exit, .register_app = sctp_register_app, .unregister_app = sctp_unregister_app, .conn_schedule = sctp_conn_schedule, .conn_in_get = sctp_conn_in_get, .conn_out_get = sctp_conn_out_get, .snat_handler = sctp_snat_handler, .dnat_handler = sctp_dnat_handler, .csum_check = sctp_csum_check, .state_name = sctp_state_name, .state_transition = sctp_state_transition, .app_conn_bind = sctp_app_conn_bind, .debug_packet = ip_vs_tcpudp_debug_packet, .timeout_change = sctp_timeout_change, .set_state_timeout = sctp_set_state_timeout, };