1/*- 2 * Copyright (c) 2001-2007, Cisco Systems, Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are met: 6 * 7 * a) Redistributions of source code must retain the above copyright notice, 8 * this list of conditions and the following disclaimer. --- 17 unchanged lines hidden (view full) --- 26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 28 * THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31/* $KAME: sctp_output.c,v 1.46 2005/03/06 16:04:17 itojun Exp $ */ 32 33#include <sys/cdefs.h> |
34__FBSDID("$FreeBSD: head/sys/netinet/sctp_output.c 167598 2007-03-15 11:27:14Z rrs $"); |
35 36#include <netinet/sctp_os.h> 37#include <sys/proc.h> 38#include <netinet/sctp_var.h> |
39#include <netinet/sctp_sysctl.h> |
40#include <netinet/sctp_header.h> 41#include <netinet/sctp_pcb.h> 42#include <netinet/sctputil.h> 43#include <netinet/sctp_output.h> 44#include <netinet/sctp_uio.h> 45#include <netinet/sctputil.h> 46#include <netinet/sctp_auth.h> 47#include <netinet/sctp_timer.h> 48#include <netinet/sctp_asconf.h> 49#include <netinet/sctp_indata.h> 50#include <netinet/sctp_bsd_addr.h> 51 |
52 |
53 |
54#define SCTP_MAX_GAPS_INARRAY 4 55struct sack_track { 56 uint8_t right_edge; /* mergable on the right edge */ 57 uint8_t left_edge; /* mergable on the left edge */ 58 uint8_t num_entries; 59 uint8_t spare; 60 struct sctp_gap_ack_block gaps[SCTP_MAX_GAPS_INARRAY]; 61}; --- 1789 unchanged lines hidden (view full) --- 1851 {0, 0}, 1852 {0, 0}, 1853 {0, 0} 1854 } 1855 } 1856}; 1857 1858 |
1859int 1860sctp_is_address_in_scope(struct sctp_ifa *ifa, 1861 int ipv4_addr_legal, 1862 int ipv6_addr_legal, 1863 int loopback_scope, 1864 int ipv4_local_scope, 1865 int local_scope, 1866 int site_scope, 1867 int do_update) 1868{ 1869 if ((loopback_scope == 0) && 1870 (ifa->ifn_p) && SCTP_IFN_IS_IFT_LOOP(ifa->ifn_p)) { 1871 /* 1872 * skip loopback if not in scope * 1873 */ 1874 return (0); 1875 } 1876 if ((ifa->address.sa.sa_family == AF_INET) && ipv4_addr_legal) { 1877 struct sockaddr_in *sin; |
1878 |
1879 sin = (struct sockaddr_in *)&ifa->address.sin; 1880 if (sin->sin_addr.s_addr == 0) { 1881 /* not in scope , unspecified */ 1882 return (0); 1883 } 1884 if ((ipv4_local_scope == 0) && 1885 (IN4_ISPRIVATE_ADDRESS(&sin->sin_addr))) { 1886 /* private address not in scope */ 1887 return (0); 1888 } 1889 } else if ((ifa->address.sa.sa_family == AF_INET6) && ipv6_addr_legal) { 1890 struct sockaddr_in6 *sin6; |
1891 |
1892 /* 1893 * Must update the flags, bummer, which means any IFA locks 1894 * must now be applied HERE <-> 1895 */ 1896 if (do_update) { 1897 sctp_gather_internal_ifa_flags(ifa); 1898 } 1899 if (ifa->localifa_flags & SCTP_ADDR_IFA_UNUSEABLE) { 1900 return (0); 1901 } 1902 /* ok to use deprecated addresses? */ 1903 sin6 = (struct sockaddr_in6 *)&ifa->address.sin6; 1904 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) { 1905 /* skip unspecifed addresses */ 1906 return (0); 1907 } 1908 if ( /* (local_scope == 0) && */ 1909 (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr))) { 1910 return (0); 1911 } 1912 if ((site_scope == 0) && 1913 (IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr))) { 1914 return (0); 1915 } 1916 } else { 1917 return (0); 1918 } 1919 return (1); 1920} |
1921 |
1922static struct mbuf * 1923sctp_add_addr_to_mbuf(struct mbuf *m, struct sctp_ifa *ifa) 1924{ 1925 struct sctp_paramhdr *parmh; 1926 struct mbuf *mret; 1927 int len; 1928 1929 if (ifa->address.sa.sa_family == AF_INET) { 1930 len = sizeof(struct sctp_ipv4addr_param); 1931 } else if (ifa->address.sa.sa_family == AF_INET6) { 1932 len = sizeof(struct sctp_ipv6addr_param); 1933 } else { 1934 /* unknown type */ 1935 return (m); 1936 } 1937 if (M_TRAILINGSPACE(m) >= len) { 1938 /* easy side we just drop it on the end */ 1939 parmh = (struct sctp_paramhdr *)(SCTP_BUF_AT(m, SCTP_BUF_LEN(m))); 1940 mret = m; 1941 } else { 1942 /* Need more space */ 1943 mret = m; 1944 while (SCTP_BUF_NEXT(mret) != NULL) { 1945 mret = SCTP_BUF_NEXT(mret); 1946 } 1947 SCTP_BUF_NEXT(mret) = sctp_get_mbuf_for_msg(len, 0, M_DONTWAIT, 1, MT_DATA); 1948 if (SCTP_BUF_NEXT(mret) == NULL) { 1949 /* We are hosed, can't add more addresses */ 1950 return (m); 1951 } 1952 mret = SCTP_BUF_NEXT(mret); 1953 parmh = mtod(mret, struct sctp_paramhdr *); 1954 } 1955 /* now add the parameter */ 1956 if (ifa->address.sa.sa_family == AF_INET) { 1957 struct sctp_ipv4addr_param *ipv4p; 1958 struct sockaddr_in *sin; 1959 1960 sin = (struct sockaddr_in *)&ifa->address.sin; 1961 ipv4p = (struct sctp_ipv4addr_param *)parmh; 1962 parmh->param_type = htons(SCTP_IPV4_ADDRESS); 1963 parmh->param_length = htons(len); 1964 ipv4p->addr = sin->sin_addr.s_addr; 1965 SCTP_BUF_LEN(mret) += len; 1966 } else if (ifa->address.sa.sa_family == AF_INET6) { 1967 struct sctp_ipv6addr_param *ipv6p; 1968 struct sockaddr_in6 *sin6; 1969 1970 sin6 = (struct sockaddr_in6 *)&ifa->address.sin6; 1971 ipv6p = (struct sctp_ipv6addr_param *)parmh; 1972 parmh->param_type = htons(SCTP_IPV6_ADDRESS); 1973 parmh->param_length = htons(len); 1974 memcpy(ipv6p->addr, &sin6->sin6_addr, 1975 sizeof(ipv6p->addr)); 1976 /* clear embedded scope in the address */ 1977 in6_clearscope((struct in6_addr *)ipv6p->addr); 1978 SCTP_BUF_LEN(mret) += len; 1979 } else { 1980 return (m); 1981 } 1982 return (mret); 1983} 1984 1985 1986struct mbuf * 1987sctp_add_addresses_to_i_ia(struct sctp_inpcb *inp, struct sctp_scoping *scope, 1988 struct mbuf *m_at, int cnt_inits_to) 1989{ 1990 struct sctp_vrf *vrf = NULL; 1991 int cnt, limit_out = 0, total_count; 1992 uint32_t vrf_id; 1993 1994 vrf_id = SCTP_DEFAULT_VRFID; 1995 SCTP_IPI_ADDR_LOCK(); 1996 vrf = sctp_find_vrf(vrf_id); 1997 if (vrf == NULL) { 1998 SCTP_IPI_ADDR_UNLOCK(); 1999 return (m_at); 2000 } 2001 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) { 2002 struct sctp_ifa *sctp_ifap; 2003 struct sctp_ifn *sctp_ifnp; 2004 2005 cnt = cnt_inits_to; 2006 if (vrf->total_ifa_count > SCTP_COUNT_LIMIT) { 2007 limit_out = 1; 2008 cnt = SCTP_ADDRESS_LIMIT; 2009 goto skip_count; 2010 } 2011 LIST_FOREACH(sctp_ifnp, &vrf->ifnlist, next_ifn) { 2012 if ((scope->loopback_scope == 0) && 2013 SCTP_IFN_IS_IFT_LOOP(sctp_ifnp)) { 2014 /* 2015 * Skip loopback devices if loopback_scope 2016 * not set 2017 */ 2018 continue; 2019 } 2020 LIST_FOREACH(sctp_ifap, &sctp_ifnp->ifalist, next_ifa) { 2021 if (sctp_is_address_in_scope(sctp_ifap, 2022 scope->ipv4_addr_legal, 2023 scope->ipv6_addr_legal, 2024 scope->loopback_scope, 2025 scope->ipv4_local_scope, 2026 scope->local_scope, 2027 scope->site_scope, 1) == 0) { 2028 continue; 2029 } 2030 cnt++; 2031 if (cnt > SCTP_ADDRESS_LIMIT) { 2032 break; 2033 } 2034 } 2035 if (cnt > SCTP_ADDRESS_LIMIT) { 2036 break; 2037 } 2038 } 2039skip_count: 2040 if (cnt > 1) { 2041 total_count = 0; 2042 LIST_FOREACH(sctp_ifnp, &vrf->ifnlist, next_ifn) { 2043 cnt = 0; 2044 if ((scope->loopback_scope == 0) && 2045 SCTP_IFN_IS_IFT_LOOP(sctp_ifnp)) { 2046 /* 2047 * Skip loopback devices if 2048 * loopback_scope not set 2049 */ 2050 continue; 2051 } 2052 LIST_FOREACH(sctp_ifap, &sctp_ifnp->ifalist, next_ifa) { 2053 if (sctp_is_address_in_scope(sctp_ifap, 2054 scope->ipv4_addr_legal, 2055 scope->ipv6_addr_legal, 2056 scope->loopback_scope, 2057 scope->ipv4_local_scope, 2058 scope->local_scope, 2059 scope->site_scope, 0) == 0) { 2060 continue; 2061 } 2062 m_at = sctp_add_addr_to_mbuf(m_at, sctp_ifap); 2063 if (limit_out) { 2064 cnt++; 2065 total_count++; 2066 if (cnt >= 2) { 2067 /* 2068 * two from each 2069 * address 2070 */ 2071 break; 2072 } 2073 if (total_count > SCTP_ADDRESS_LIMIT) { 2074 /* No more addresses */ 2075 break; 2076 } 2077 } 2078 } 2079 } 2080 } 2081 } else { 2082 struct sctp_laddr *laddr; 2083 2084 cnt = cnt_inits_to; 2085 /* First, how many ? */ 2086 LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) { 2087 if (laddr->ifa == NULL) { 2088 continue; 2089 } 2090 if (laddr->ifa->localifa_flags & SCTP_BEING_DELETED) 2091 /* 2092 * Address being deleted by the system, dont 2093 * list. 2094 */ 2095 continue; 2096 if (laddr->action == SCTP_DEL_IP_ADDRESS) { 2097 /* 2098 * Address being deleted on this ep don't 2099 * list. 2100 */ 2101 continue; 2102 } 2103 if (sctp_is_address_in_scope(laddr->ifa, 2104 scope->ipv4_addr_legal, 2105 scope->ipv6_addr_legal, 2106 scope->loopback_scope, 2107 scope->ipv4_local_scope, 2108 scope->local_scope, 2109 scope->site_scope, 1) == 0) { 2110 continue; 2111 } 2112 cnt++; 2113 } 2114 if (cnt > SCTP_ADDRESS_LIMIT) { 2115 limit_out = 1; 2116 } 2117 /* 2118 * To get through a NAT we only list addresses if we have 2119 * more than one. That way if you just bind a single address 2120 * we let the source of the init dictate our address. 2121 */ 2122 if (cnt > 1) { 2123 LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) { 2124 cnt = 0; 2125 if (laddr->ifa == NULL) { 2126 continue; 2127 } 2128 if (laddr->ifa->localifa_flags & SCTP_BEING_DELETED) 2129 continue; 2130 2131 if (sctp_is_address_in_scope(laddr->ifa, 2132 scope->ipv4_addr_legal, 2133 scope->ipv6_addr_legal, 2134 scope->loopback_scope, 2135 scope->ipv4_local_scope, 2136 scope->local_scope, 2137 scope->site_scope, 0) == 0) { 2138 continue; 2139 } 2140 m_at = sctp_add_addr_to_mbuf(m_at, laddr->ifa); 2141 cnt++; 2142 if (cnt >= SCTP_ADDRESS_LIMIT) { 2143 break; 2144 } 2145 } 2146 } 2147 } 2148 SCTP_IPI_ADDR_UNLOCK(); 2149 return (m_at); 2150} 2151 2152static struct sctp_ifa * 2153sctp_is_ifa_addr_prefered(struct sctp_ifa *ifa, 2154 uint8_t dest_is_loop, 2155 uint8_t dest_is_priv, 2156 sa_family_t fam) 2157{ 2158 uint8_t dest_is_global = 0; 2159 2160 /* 2161 * is_scope -> dest_is_priv is true if destination is a private 2162 * address 2163 */ 2164 /* dest_is_loop is true if destination is a loopback addresses */ 2165 2166 /* 2167 * Here we determine if its a prefered address. A prefered address 2168 * means it is the same scope or higher scope then the destination. 2169 * L = loopback, P = private, G = global 2170 * ----------------------------------------- src | dest | result 2171 * ---------------------------------------- L | L | yes 2172 * ----------------------------------------- P | L | 2173 * yes-v4 no-v6 ----------------------------------------- G | 2174 * L | yes-v4 no-v6 ----------------------------------------- L 2175 * | P | no ----------------------------------------- P | 2176 * P | yes ----------------------------------------- G | 2177 * P | no ----------------------------------------- L | G 2178 * | no ----------------------------------------- P | G | 2179 * no ----------------------------------------- G | G | 2180 * yes ----------------------------------------- 2181 */ 2182 2183 if (ifa->address.sa.sa_family != fam) { 2184 /* forget mis-matched family */ 2185 return (NULL); 2186 } 2187 if ((dest_is_priv == 0) && (dest_is_loop == 0)) { 2188 dest_is_global = 1; 2189 } 2190 /* Ok the address may be ok */ 2191 if (fam == AF_INET6) { 2192 /* ok to use deprecated addresses? */ 2193 if (ifa->localifa_flags & SCTP_ADDR_IFA_UNUSEABLE) { 2194 return (NULL); 2195 } 2196 if (ifa->src_is_priv) { 2197 if (dest_is_loop) { 2198 return (NULL); 2199 } 2200 } 2201 if (ifa->src_is_glob) { 2202 2203 if (dest_is_loop) { 2204 return (NULL); 2205 } 2206 } 2207 } 2208 /* 2209 * Now that we know what is what, implement or table this could in 2210 * theory be done slicker (it used to be), but this is 2211 * straightforward and easier to validate :-) 2212 */ 2213 if ((ifa->src_is_loop) && (dest_is_priv)) { 2214 return (NULL); 2215 } 2216 if ((ifa->src_is_glob) && (dest_is_priv)) { 2217 return (NULL); 2218 } 2219 if ((ifa->src_is_loop) && (dest_is_global)) { 2220 return (NULL); 2221 } 2222 if ((ifa->src_is_priv) && (dest_is_global)) { 2223 return (NULL); 2224 } 2225 /* its a prefered address */ 2226 return (ifa); 2227} 2228 2229static struct sctp_ifa * 2230sctp_is_ifa_addr_acceptable(struct sctp_ifa *ifa, 2231 uint8_t dest_is_loop, 2232 uint8_t dest_is_priv, 2233 sa_family_t fam) 2234{ 2235 uint8_t dest_is_global = 0; 2236 2237 2238 /* 2239 * Here we determine if its a acceptable address. A acceptable 2240 * address means it is the same scope or higher scope but we can 2241 * allow for NAT which means its ok to have a global dest and a 2242 * private src. 2243 * 2244 * L = loopback, P = private, G = global 2245 * ----------------------------------------- src | dest | result 2246 * ----------------------------------------- L | L | yes 2247 * ----------------------------------------- P | L | 2248 * yes-v4 no-v6 ----------------------------------------- G | 2249 * L | yes ----------------------------------------- L | 2250 * P | no ----------------------------------------- P | P 2251 * | yes ----------------------------------------- G | P 2252 * | yes - May not work ----------------------------------------- 2253 * L | G | no ----------------------------------------- P 2254 * | G | yes - May not work 2255 * ----------------------------------------- G | G | yes 2256 * ----------------------------------------- 2257 */ 2258 2259 if (ifa->address.sa.sa_family != fam) { 2260 /* forget non matching family */ 2261 return (NULL); 2262 } 2263 /* Ok the address may be ok */ 2264 if ((dest_is_loop == 0) && (dest_is_priv == 0)) { 2265 dest_is_global = 1; 2266 } 2267 if (fam == AF_INET6) { 2268 /* ok to use deprecated addresses? */ 2269 if (ifa->localifa_flags & SCTP_ADDR_IFA_UNUSEABLE) { 2270 return (NULL); 2271 } 2272 if (ifa->src_is_priv) { 2273 /* Special case, linklocal to loop */ 2274 if (dest_is_loop) 2275 return (NULL); 2276 } 2277 } 2278 /* 2279 * Now that we know what is what, implement or table this could in 2280 * theory be done slicker (it used to be), but this is 2281 * straightforward and easier to validate :-) 2282 */ 2283 2284 if ((ifa->src_is_loop == 0) && (dest_is_priv)) { 2285 return (NULL); 2286 } 2287 if ((ifa->src_is_loop == 0) && (dest_is_global)) { 2288 return (NULL); 2289 } 2290 /* its an acceptable address */ 2291 return (ifa); 2292} 2293 2294int 2295sctp_is_addr_restricted(struct sctp_tcb *stcb, struct sctp_ifa *ifa) 2296{ 2297 struct sctp_laddr *laddr; 2298 2299 if (stcb == NULL) { 2300 /* There are no restrictions, no TCB :-) */ 2301 return (0); 2302 } 2303 LIST_FOREACH(laddr, &stcb->asoc.sctp_restricted_addrs, sctp_nxt_addr) { 2304 if (laddr->ifa == NULL) { 2305#ifdef SCTP_DEBUG 2306 if (sctp_debug_on & SCTP_DEBUG_OUTPUT1) { 2307 printf("Help I have fallen and I can't get up!\n"); 2308 } 2309#endif 2310 continue; 2311 } 2312 if (laddr->ifa == ifa) { 2313 /* Yes it is on the list */ 2314 return (1); 2315 } 2316 } 2317 return (0); 2318} 2319 2320 2321int 2322sctp_is_addr_in_ep(struct sctp_inpcb *inp, struct sctp_ifa *ifa) 2323{ 2324 struct sctp_laddr *laddr; 2325 2326 if (ifa == NULL) 2327 return (0); 2328 LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) { 2329 if (laddr->ifa == NULL) { 2330#ifdef SCTP_DEBUG 2331 if (sctp_debug_on & SCTP_DEBUG_OUTPUT1) { 2332 printf("Help I have fallen and I can't get up!\n"); 2333 } 2334#endif 2335 continue; 2336 } 2337 if ((laddr->ifa == ifa) && laddr->action == 0) 2338 /* same pointer */ 2339 return (1); 2340 } 2341 return (0); 2342} 2343 2344 2345 2346static struct sctp_ifa * 2347sctp_choose_boundspecific_inp(struct sctp_inpcb *inp, 2348 struct route *ro, 2349 uint32_t vrf_id, 2350 int non_asoc_addr_ok, 2351 uint8_t dest_is_priv, 2352 uint8_t dest_is_loop, 2353 sa_family_t fam) 2354{ 2355 struct sctp_laddr *laddr, *starting_point; 2356 void *ifn; 2357 int resettotop = 0; 2358 struct sctp_ifn *sctp_ifn; 2359 struct sctp_ifa *sctp_ifa, *pass; 2360 struct sctp_vrf *vrf; 2361 uint32_t ifn_index; 2362 2363 vrf = sctp_find_vrf(vrf_id); 2364 if (vrf == NULL) 2365 return (NULL); 2366 2367 ifn = SCTP_GET_IFN_VOID_FROM_ROUTE(ro); 2368 ifn_index = SCTP_GET_IF_INDEX_FROM_ROUTE(ro); 2369 sctp_ifn = sctp_find_ifn(vrf, ifn, ifn_index); 2370 /* 2371 * first question, is the ifn we will emit on in our list, if so, we 2372 * want such an address. Note that we first looked for a prefered 2373 * address. 2374 */ 2375 if (sctp_ifn) { 2376 /* is a prefered one on the interface we route out? */ 2377 LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) { 2378 if ((sctp_ifa->localifa_flags & SCTP_ADDR_DEFER_USE) && (non_asoc_addr_ok == 0)) 2379 continue; 2380 pass = sctp_is_ifa_addr_prefered(sctp_ifa, dest_is_loop, dest_is_priv, fam); 2381 if (pass == NULL) 2382 continue; 2383 if (sctp_is_addr_in_ep(inp, pass)) { 2384 atomic_add_int(&pass->refcount, 1); 2385 return (pass); 2386 } 2387 } 2388 } 2389 /* 2390 * ok, now we now need to find one on the list of the addresses. We 2391 * can't get one on the emitting interface so lets find first a 2392 * prefered one. If not that a acceptable one otherwise... we return 2393 * NULL. 2394 */ 2395 starting_point = inp->next_addr_touse; 2396once_again: 2397 if (inp->next_addr_touse == NULL) { 2398 inp->next_addr_touse = LIST_FIRST(&inp->sctp_addr_list); 2399 resettotop = 1; 2400 } 2401 for (laddr = inp->next_addr_touse; laddr; laddr = LIST_NEXT(laddr, sctp_nxt_addr)) { 2402 if (laddr->ifa == NULL) { 2403 /* address has been removed */ 2404 continue; 2405 } 2406 pass = sctp_is_ifa_addr_prefered(laddr->ifa, dest_is_loop, dest_is_priv, fam); 2407 if (pass == NULL) 2408 continue; 2409 atomic_add_int(&pass->refcount, 1); 2410 return (pass); 2411 } 2412 if (resettotop == 0) { 2413 inp->next_addr_touse = NULL; 2414 goto once_again; 2415 } 2416 inp->next_addr_touse = starting_point; 2417 resettotop = 0; 2418once_again_too: 2419 if (inp->next_addr_touse == NULL) { 2420 inp->next_addr_touse = LIST_FIRST(&inp->sctp_addr_list); 2421 resettotop = 1; 2422 } 2423 /* ok, what about an acceptable address in the inp */ 2424 for (laddr = inp->next_addr_touse; laddr; laddr = LIST_NEXT(laddr, sctp_nxt_addr)) { 2425 if (laddr->ifa == NULL) { 2426 /* address has been removed */ 2427 continue; 2428 } 2429 pass = sctp_is_ifa_addr_acceptable(laddr->ifa, dest_is_loop, dest_is_priv, fam); 2430 if (pass == NULL) 2431 continue; 2432 atomic_add_int(&pass->refcount, 1); 2433 return (pass); 2434 } 2435 if (resettotop == 0) { 2436 inp->next_addr_touse = NULL; 2437 goto once_again_too; 2438 } 2439 /* 2440 * no address bound can be a source for the destination we are in 2441 * trouble 2442 */ 2443 return (NULL); 2444} 2445 2446 2447 2448static struct sctp_ifa * 2449sctp_choose_boundspecific_stcb(struct sctp_inpcb *inp, 2450 struct sctp_tcb *stcb, 2451 struct sctp_nets *net, 2452 struct route *ro, 2453 uint32_t vrf_id, 2454 uint8_t dest_is_priv, 2455 uint8_t dest_is_loop, 2456 int non_asoc_addr_ok, 2457 sa_family_t fam) 2458{ 2459 struct sctp_laddr *laddr, *starting_point; 2460 void *ifn; 2461 struct sctp_ifn *sctp_ifn; 2462 struct sctp_ifa *sctp_ifa, *pass; 2463 uint8_t start_at_beginning = 0; 2464 struct sctp_vrf *vrf; 2465 uint32_t ifn_index; 2466 2467 /* 2468 * first question, is the ifn we will emit on in our list, if so, we 2469 * want that one. 2470 */ 2471 vrf = sctp_find_vrf(vrf_id); 2472 if (vrf == NULL) 2473 return (NULL); 2474 2475 ifn = SCTP_GET_IFN_VOID_FROM_ROUTE(ro); 2476 ifn_index = SCTP_GET_IF_INDEX_FROM_ROUTE(ro); 2477 sctp_ifn = sctp_find_ifn(vrf, ifn, ifn_index); 2478 2479 /* 2480 * first question, is the ifn we will emit on in our list, if so, we 2481 * want that one.. First we look for a prefered. Second we go for an 2482 * acceptable. 2483 */ 2484 if (sctp_ifn) { 2485 /* first try for an prefered address on the ep */ 2486 LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) { 2487 if ((sctp_ifa->localifa_flags & SCTP_ADDR_DEFER_USE) && (non_asoc_addr_ok == 0)) 2488 continue; 2489 if (sctp_is_addr_in_ep(inp, sctp_ifa)) { 2490 pass = sctp_is_ifa_addr_prefered(sctp_ifa, dest_is_loop, dest_is_priv, fam); 2491 if (pass == NULL) 2492 continue; 2493 if ((non_asoc_addr_ok == 0) && 2494 (sctp_is_addr_restricted(stcb, pass))) { 2495 /* on the no-no list */ 2496 continue; 2497 } 2498 atomic_add_int(&pass->refcount, 1); 2499 return (pass); 2500 } 2501 } 2502 /* next try for an acceptable address on the ep */ 2503 LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) { 2504 if ((sctp_ifa->localifa_flags & SCTP_ADDR_DEFER_USE) && (non_asoc_addr_ok == 0)) 2505 continue; 2506 if (sctp_is_addr_in_ep(inp, sctp_ifa)) { 2507 pass = sctp_is_ifa_addr_acceptable(sctp_ifa, dest_is_loop, dest_is_priv, fam); 2508 if (pass == NULL) 2509 continue; 2510 if ((non_asoc_addr_ok == 0) && 2511 (sctp_is_addr_restricted(stcb, pass))) { 2512 /* on the no-no list */ 2513 continue; 2514 } 2515 atomic_add_int(&pass->refcount, 1); 2516 return (pass); 2517 } 2518 } 2519 2520 } 2521 /* 2522 * if we can't find one like that then we must look at all addresses 2523 * bound to pick one at first prefereable then secondly acceptable. 2524 */ 2525 starting_point = stcb->asoc.last_used_address; 2526sctp_from_the_top: 2527 if (stcb->asoc.last_used_address == NULL) { 2528 start_at_beginning = 1; 2529 stcb->asoc.last_used_address = LIST_FIRST(&inp->sctp_addr_list); 2530 } 2531 /* search beginning with the last used address */ 2532 for (laddr = stcb->asoc.last_used_address; laddr; 2533 laddr = LIST_NEXT(laddr, sctp_nxt_addr)) { 2534 if (laddr->ifa == NULL) { 2535 /* address has been removed */ 2536 continue; 2537 } 2538 pass = sctp_is_ifa_addr_prefered(laddr->ifa, dest_is_loop, dest_is_priv, fam); 2539 if (pass == NULL) 2540 continue; 2541 if ((non_asoc_addr_ok == 0) && 2542 (sctp_is_addr_restricted(stcb, pass))) { 2543 /* on the no-no list */ 2544 continue; 2545 } 2546 stcb->asoc.last_used_address = laddr; 2547 atomic_add_int(&pass->refcount, 1); 2548 return (pass); 2549 2550 } 2551 if (start_at_beginning == 0) { 2552 stcb->asoc.last_used_address = NULL; 2553 goto sctp_from_the_top; 2554 } 2555 /* now try for any higher scope than the destination */ 2556 stcb->asoc.last_used_address = starting_point; 2557 start_at_beginning = 0; 2558sctp_from_the_top2: 2559 if (stcb->asoc.last_used_address == NULL) { 2560 start_at_beginning = 1; 2561 stcb->asoc.last_used_address = LIST_FIRST(&inp->sctp_addr_list); 2562 } 2563 /* search beginning with the last used address */ 2564 for (laddr = stcb->asoc.last_used_address; laddr; 2565 laddr = LIST_NEXT(laddr, sctp_nxt_addr)) { 2566 if (laddr->ifa == NULL) { 2567 /* address has been removed */ 2568 continue; 2569 } 2570 pass = sctp_is_ifa_addr_acceptable(laddr->ifa, dest_is_loop, dest_is_priv, fam); 2571 if (pass == NULL) 2572 continue; 2573 if ((non_asoc_addr_ok == 0) && 2574 (sctp_is_addr_restricted(stcb, pass))) { 2575 /* on the no-no list */ 2576 continue; 2577 } 2578 stcb->asoc.last_used_address = laddr; 2579 atomic_add_int(&pass->refcount, 1); 2580 return (pass); 2581 } 2582 if (start_at_beginning == 0) { 2583 stcb->asoc.last_used_address = NULL; 2584 goto sctp_from_the_top2; 2585 } 2586 return (NULL); 2587} 2588 2589static struct sctp_ifa * 2590sctp_select_nth_prefered_addr_from_ifn_boundall(struct sctp_ifn *ifn, 2591 struct sctp_tcb *stcb, 2592 int non_asoc_addr_ok, 2593 uint8_t dest_is_loop, 2594 uint8_t dest_is_priv, 2595 int addr_wanted, 2596 sa_family_t fam) 2597{ 2598 struct sctp_ifa *ifa, *pass; 2599 int num_eligible_addr = 0; 2600 2601 LIST_FOREACH(ifa, &ifn->ifalist, next_ifa) { 2602 if ((ifa->localifa_flags & SCTP_ADDR_DEFER_USE) && (non_asoc_addr_ok == 0)) 2603 continue; 2604 pass = sctp_is_ifa_addr_prefered(ifa, dest_is_loop, dest_is_priv, fam); 2605 if (pass == NULL) 2606 continue; 2607 if (stcb) { 2608 if ((non_asoc_addr_ok == 0) && sctp_is_addr_restricted(stcb, pass)) { 2609 /* 2610 * It is restricted for some reason.. 2611 * probably not yet added. 2612 */ 2613 continue; 2614 } 2615 } 2616 if (num_eligible_addr >= addr_wanted) { 2617 return (pass); 2618 } 2619 num_eligible_addr++; 2620 } 2621 return (NULL); 2622} 2623 2624 |
2625static int |
2626sctp_count_num_prefered_boundall(struct sctp_ifn *ifn, 2627 struct sctp_tcb *stcb, 2628 int non_asoc_addr_ok, 2629 uint8_t dest_is_loop, 2630 uint8_t dest_is_priv, 2631 sa_family_t fam) 2632{ 2633 struct sctp_ifa *ifa, *pass; 2634 int num_eligible_addr = 0; 2635 2636 LIST_FOREACH(ifa, &ifn->ifalist, next_ifa) { 2637 if ((ifa->localifa_flags & SCTP_ADDR_DEFER_USE) && (non_asoc_addr_ok == 0)) { 2638 continue; 2639 } 2640 pass = sctp_is_ifa_addr_prefered(ifa, dest_is_loop, dest_is_priv, fam); 2641 if (pass == NULL) { 2642 continue; 2643 } 2644 if (stcb) { 2645 if ((non_asoc_addr_ok == 0) && sctp_is_addr_restricted(stcb, pass)) { 2646 /* 2647 * It is restricted for some reason.. 2648 * probably not yet added. 2649 */ 2650 continue; 2651 } 2652 } 2653 num_eligible_addr++; 2654 } 2655 return (num_eligible_addr); 2656} 2657 2658static struct sctp_ifa * 2659sctp_choose_boundall(struct sctp_inpcb *inp, 2660 struct sctp_tcb *stcb, 2661 struct sctp_nets *net, 2662 struct route *ro, 2663 uint32_t vrf_id, 2664 uint8_t dest_is_priv, 2665 uint8_t dest_is_loop, 2666 int non_asoc_addr_ok, 2667 sa_family_t fam) 2668{ 2669 int cur_addr_num = 0, num_prefered = 0; 2670 void *ifn; 2671 struct sctp_ifn *sctp_ifn, *looked_at = NULL, *emit_ifn; 2672 struct sctp_ifa *sctp_ifa, *pass; 2673 uint32_t ifn_index; 2674 struct sctp_vrf *vrf; 2675 2676 /* 2677 * For boundall we can use any address in the association. If 2678 * non_asoc_addr_ok is set we can use any address (at least in 2679 * theory). So we look for prefered addresses first. If we find one, 2680 * we use it. Otherwise we next try to get an address on the 2681 * interface, which we should be able to do (unless non_asoc_addr_ok 2682 * is false and we are routed out that way). In these cases where we 2683 * can't use the address of the interface we go through all the 2684 * ifn's looking for an address we can use and fill that in. Punting 2685 * means we send back address 0, which will probably cause problems 2686 * actually since then IP will fill in the address of the route ifn, 2687 * which means we probably already rejected it.. i.e. here comes an 2688 * abort :-<. 2689 */ 2690 vrf = sctp_find_vrf(vrf_id); 2691 if (vrf == NULL) 2692 return (NULL); 2693 2694 ifn = SCTP_GET_IFN_VOID_FROM_ROUTE(ro); 2695 ifn_index = SCTP_GET_IF_INDEX_FROM_ROUTE(ro); 2696 2697 emit_ifn = looked_at = sctp_ifn = sctp_find_ifn(vrf, ifn, ifn_index); 2698 if (sctp_ifn == NULL) { 2699 /* ?? We don't have this guy ?? */ 2700 goto bound_all_plan_b; 2701 } 2702 if (net) { 2703 cur_addr_num = net->indx_of_eligible_next_to_use; 2704 } 2705 num_prefered = sctp_count_num_prefered_boundall(sctp_ifn, 2706 stcb, 2707 non_asoc_addr_ok, 2708 dest_is_loop, 2709 dest_is_priv, fam); 2710#ifdef SCTP_DEBUG 2711 if (sctp_debug_on & SCTP_DEBUG_OUTPUT1) { 2712 printf("Found %d prefered source addresses\n", num_prefered); 2713 } 2714#endif 2715 if (num_prefered == 0) { 2716 /* 2717 * no eligible addresses, we must use some other interface 2718 * address if we can find one. 2719 */ 2720 goto bound_all_plan_b; 2721 } 2722 /* 2723 * Ok we have num_eligible_addr set with how many we can use, this 2724 * may vary from call to call due to addresses being deprecated 2725 * etc.. 2726 */ 2727 if (cur_addr_num >= num_prefered) { 2728 cur_addr_num = 0; 2729 } 2730 /* 2731 * select the nth address from the list (where cur_addr_num is the 2732 * nth) and 0 is the first one, 1 is the second one etc... 2733 */ 2734#ifdef SCTP_DEBUG 2735 if (sctp_debug_on & SCTP_DEBUG_OUTPUT1) { 2736 printf("cur_addr_num:%d\n", cur_addr_num); 2737 } 2738#endif 2739 sctp_ifa = sctp_select_nth_prefered_addr_from_ifn_boundall(sctp_ifn, stcb, non_asoc_addr_ok, dest_is_loop, 2740 dest_is_priv, cur_addr_num, fam); 2741 2742 /* if sctp_ifa is NULL something changed??, fall to plan b. */ 2743 if (sctp_ifa) { 2744 atomic_add_int(&sctp_ifa->refcount, 1); 2745 if (net) { 2746 /* save off where the next one we will want */ 2747 net->indx_of_eligible_next_to_use = cur_addr_num + 1; 2748 } 2749 return (sctp_ifa); 2750 } 2751 /* 2752 * plan_b: Look at all interfaces and find a prefered address. If no 2753 * prefered fall through to plan_c. 2754 */ 2755bound_all_plan_b: 2756 LIST_FOREACH(sctp_ifn, &vrf->ifnlist, next_ifn) { 2757 if (dest_is_loop == 0 && SCTP_IFN_IS_IFT_LOOP(sctp_ifn)) { 2758 /* wrong base scope */ 2759 continue; 2760 } 2761 if ((sctp_ifn == looked_at) && looked_at) 2762 /* already looked at this guy */ 2763 continue; 2764 num_prefered = sctp_count_num_prefered_boundall(sctp_ifn, stcb, non_asoc_addr_ok, 2765 dest_is_loop, dest_is_priv, fam); 2766#ifdef SCTP_DEBUG 2767 if (sctp_debug_on & SCTP_DEBUG_OUTPUT1) { 2768 printf("Found ifn:%p %d prefered source addresses\n", ifn, num_prefered); 2769 } 2770#endif 2771 if (num_prefered == 0) { 2772 /* 2773 * None on this interface. 2774 */ 2775 continue; 2776 } 2777#ifdef SCTP_DEBUG 2778 if (sctp_debug_on & SCTP_DEBUG_OUTPUT2) { 2779 printf("num prefered:%d on interface:%p cur_addr_num:%d\n", 2780 num_prefered, 2781 sctp_ifn, 2782 cur_addr_num); 2783 } 2784#endif 2785 2786 /* 2787 * Ok we have num_eligible_addr set with how many we can 2788 * use, this may vary from call to call due to addresses 2789 * being deprecated etc.. 2790 */ 2791 if (cur_addr_num >= num_prefered) { 2792 cur_addr_num = 0; 2793 } 2794 pass = sctp_select_nth_prefered_addr_from_ifn_boundall(sctp_ifn, stcb, non_asoc_addr_ok, dest_is_loop, 2795 dest_is_priv, cur_addr_num, fam); 2796 if (pass == NULL) 2797 continue; 2798 if (net) { 2799 net->indx_of_eligible_next_to_use = cur_addr_num + 1; 2800#ifdef SCTP_DEBUG 2801 if (sctp_debug_on & SCTP_DEBUG_OUTPUT2) { 2802 printf("we selected %d\n", cur_addr_num); 2803 printf("Source:"); 2804 sctp_print_address(&pass->address.sa); 2805 printf("Dest:"); 2806 sctp_print_address(&net->ro._l_addr.sa); 2807 } 2808#endif 2809 } 2810 atomic_add_int(&pass->refcount, 1); 2811 return (pass); 2812 2813 } 2814 2815 /* 2816 * plan_c: See if we have an acceptable address on the emit 2817 * interface 2818 */ 2819#ifdef SCTP_DEBUG 2820 if (sctp_debug_on & SCTP_DEBUG_OUTPUT2) { 2821 if (net) { 2822 printf("Plan C no prefered for Dest:"); 2823 sctp_print_address(&net->ro._l_addr.sa); 2824 } 2825 } 2826#endif 2827 2828 LIST_FOREACH(sctp_ifa, &emit_ifn->ifalist, next_ifa) { 2829 if ((sctp_ifa->localifa_flags & SCTP_ADDR_DEFER_USE) && (non_asoc_addr_ok == 0)) 2830 continue; 2831 pass = sctp_is_ifa_addr_acceptable(sctp_ifa, dest_is_loop, dest_is_priv, fam); 2832 if (pass == NULL) 2833 continue; 2834 if (stcb) { 2835 if ((non_asoc_addr_ok == 0) && sctp_is_addr_restricted(stcb, pass)) { 2836 /* 2837 * It is restricted for some reason.. 2838 * probably not yet added. 2839 */ 2840 continue; 2841 } 2842 } 2843 atomic_add_int(&pass->refcount, 1); 2844 return (pass); 2845 } 2846 2847 /* 2848 * plan_d: We are in trouble. No prefered address on the emit 2849 * interface. And not even a perfered address on all interfaces. Go 2850 * out and see if we can find an acceptable address somewhere 2851 * amongst all interfaces. 2852 */ 2853 LIST_FOREACH(sctp_ifn, &vrf->ifnlist, next_ifn) { 2854 if (dest_is_loop == 0 && SCTP_IFN_IS_IFT_LOOP(sctp_ifn)) { 2855 /* wrong base scope */ 2856 continue; 2857 } 2858 if ((sctp_ifn == looked_at) && looked_at) 2859 /* already looked at this guy */ 2860 continue; 2861 2862 LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) { 2863 if ((sctp_ifa->localifa_flags & SCTP_ADDR_DEFER_USE) && (non_asoc_addr_ok == 0)) 2864 continue; 2865 pass = sctp_is_ifa_addr_acceptable(sctp_ifa, dest_is_loop, dest_is_priv, fam); 2866 if (pass == NULL) 2867 continue; 2868 if (stcb) { 2869 if ((non_asoc_addr_ok == 0) && sctp_is_addr_restricted(stcb, pass)) { 2870 /* 2871 * It is restricted for some 2872 * reason.. probably not yet added. 2873 */ 2874 continue; 2875 } 2876 } 2877 atomic_add_int(&pass->refcount, 1); 2878 return (pass); 2879 } 2880 } 2881 /* 2882 * Ok we can find NO address to source from that is not on our 2883 * negative list and non_asoc_address is NOT ok, or its on our 2884 * negative list. We cant source to it :-( 2885 */ 2886 return (NULL); 2887} 2888 2889 2890 2891/* tcb may be NULL */ 2892struct sctp_ifa * 2893sctp_source_address_selection(struct sctp_inpcb *inp, 2894 struct sctp_tcb *stcb, 2895 struct route *ro, 2896 struct sctp_nets *net, 2897 int non_asoc_addr_ok, uint32_t vrf_id) 2898{ 2899 2900 struct sockaddr_in *to = (struct sockaddr_in *)&ro->ro_dst; 2901 struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&ro->ro_dst; 2902 struct sctp_ifa *answer; 2903 uint8_t dest_is_priv, dest_is_loop; 2904 int did_rtalloc = 0; 2905 sa_family_t fam; 2906 2907 /* 2908 * Rules: - Find the route if needed, cache if I can. - Look at 2909 * interface address in route, Is it in the bound list. If so we 2910 * have the best source. - If not we must rotate amongst the 2911 * addresses. 2912 * 2913 * Cavets and issues 2914 * 2915 * Do we need to pay attention to scope. We can have a private address 2916 * or a global address we are sourcing or sending to. So if we draw 2917 * it out zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz 2918 * For V4 ------------------------------------------ source * 2919 * dest * result ----------------------------------------- <a> 2920 * Private * Global * NAT 2921 * ----------------------------------------- <b> Private * 2922 * Private * No problem ----------------------------------------- 2923 * <c> Global * Private * Huh, How will this work? 2924 * ----------------------------------------- <d> Global * 2925 * Global * No Problem ------------------------------------------ 2926 * zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz For V6 2927 * ------------------------------------------ source * dest * 2928 * result ----------------------------------------- <a> Linklocal * 2929 * Global * ----------------------------------------- <b> 2930 * Linklocal * Linklocal * No problem 2931 * ----------------------------------------- <c> Global * 2932 * Linklocal * Huh, How will this work? 2933 * ----------------------------------------- <d> Global * 2934 * Global * No Problem ------------------------------------------ 2935 * zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz 2936 * 2937 * And then we add to that what happens if there are multiple addresses 2938 * assigned to an interface. Remember the ifa on a ifn is a linked 2939 * list of addresses. So one interface can have more than one IP 2940 * address. What happens if we have both a private and a global 2941 * address? Do we then use context of destination to sort out which 2942 * one is best? And what about NAT's sending P->G may get you a NAT 2943 * translation, or should you select the G thats on the interface in 2944 * preference. 2945 * 2946 * Decisions: 2947 * 2948 * - count the number of addresses on the interface. - if its one, no 2949 * problem except case <c>. For <a> we will assume a NAT out there. 2950 * - if there are more than one, then we need to worry about scope P 2951 * or G. We should prefer G -> G and P -> P if possible. Then as a 2952 * secondary fall back to mixed types G->P being a last ditch one. - 2953 * The above all works for bound all, but bound specific we need to 2954 * use the same concept but instead only consider the bound 2955 * addresses. If the bound set is NOT assigned to the interface then 2956 * we must use rotation amongst the bound addresses.. 2957 * 2958 */ 2959 if (ro->ro_rt == NULL) { 2960 /* 2961 * Need a route to cache. 2962 * 2963 */ 2964 rtalloc_ign(ro, 0UL); 2965 did_rtalloc = 1; 2966 } 2967 if (ro->ro_rt == NULL) { 2968 return (NULL); 2969 } 2970 fam = to->sin_family; 2971 dest_is_priv = dest_is_loop = 0; 2972 /* Setup our scopes for the destination */ 2973 if (fam == AF_INET) { 2974 /* Scope based on outbound address */ 2975 if ((IN4_ISPRIVATE_ADDRESS(&to->sin_addr))) { 2976 dest_is_priv = 1; 2977 } else if (IN4_ISLOOPBACK_ADDRESS(&to->sin_addr)) { 2978 dest_is_loop = 1; 2979 if (net != NULL) { 2980 /* mark it as local */ 2981 net->addr_is_local = 1; 2982 } 2983 } 2984 } else if (fam == AF_INET6) { 2985 /* Scope based on outbound address */ 2986 if (IN6_IS_ADDR_LOOPBACK(&to6->sin6_addr)) { 2987 /* 2988 * If the route goes to the loopback address OR the 2989 * address is a loopback address, we are loopback 2990 * scope. But we don't use dest_is_priv (link local 2991 * addresses). 2992 */ 2993 dest_is_loop = 1; 2994 if (net != NULL) { 2995 /* mark it as local */ 2996 net->addr_is_local = 1; 2997 } 2998 } else if (IN6_IS_ADDR_LINKLOCAL(&to6->sin6_addr)) { 2999 dest_is_priv = 1; 3000 } 3001 } 3002 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) { 3003 /* 3004 * When bound to all if the address list is set it is a 3005 * negative list. Addresses being added by asconf. 3006 */ 3007 answer = sctp_choose_boundall(inp, stcb, net, ro, vrf_id, 3008 dest_is_priv, 3009 dest_is_loop, 3010 non_asoc_addr_ok, 3011 fam); 3012 return (answer); 3013 } 3014 /* 3015 * Three possiblities here: 3016 * 3017 * a) stcb is NULL, which means we operate only from the list of 3018 * addresses (ifa's) bound to the endpoint and we care not about the 3019 * list. b) stcb is NOT-NULL, which means we have an assoc structure 3020 * and auto-asconf is on. This means that the list of addresses is a 3021 * NOT list. We use the list from the inp, but any listed address in 3022 * our list is NOT yet added. However if the non_asoc_addr_ok is set 3023 * we CAN use an address NOT available (i.e. being added). Its a 3024 * negative list. c) stcb is NOT-NULL, which means we have an assoc 3025 * structure and auto-asconf is off. This means that the list of 3026 * addresses is the ONLY addresses I can use.. its positive. 3027 * 3028 * Note we collapse b & c into the same function just like in the v6 3029 * address selection. 3030 */ 3031 if (stcb) { 3032 answer = sctp_choose_boundspecific_stcb(inp, stcb, net, ro, vrf_id, 3033 dest_is_priv, dest_is_loop, non_asoc_addr_ok, fam); 3034 3035 } else { 3036 answer = sctp_choose_boundspecific_inp(inp, ro, vrf_id, non_asoc_addr_ok, dest_is_priv, dest_is_loop, fam); 3037 3038 } 3039 return (answer); 3040} 3041 3042static int |
3043sctp_find_cmsg(int c_type, void *data, struct mbuf *control, int cpsize) 3044{ 3045 struct cmsghdr cmh; 3046 int tlen, at; 3047 3048 tlen = SCTP_BUF_LEN(control); 3049 at = 0; 3050 /* --- 33 unchanged lines hidden (view full) --- 3084 } 3085 } 3086 } 3087 /* not found */ 3088 return (0); 3089} 3090 3091 |
3092struct mbuf * |
3093sctp_get_mbuf_for_msg(unsigned int space_needed, int want_header, 3094 int how, int allonebuf, int type) 3095{ 3096 struct mbuf *m = NULL; 3097 int aloc_size; 3098 int index = 0; 3099 int mbuf_threshold; 3100 --- 187 unchanged lines hidden (view full) --- 3288 stcb->asoc.hb_ect_randombit++; 3289 return (SCTP_ECT1_BIT); 3290 } else { 3291 stcb->asoc.hb_ect_randombit++; 3292 return (SCTP_ECT0_BIT); 3293 } 3294} 3295 |
3296static int 3297sctp_lowlevel_chunk_output(struct sctp_inpcb *inp, 3298 struct sctp_tcb *stcb, /* may be NULL */ 3299 struct sctp_nets *net, 3300 struct sockaddr *to, 3301 struct mbuf *m, 3302 uint32_t auth_offset, 3303 struct sctp_auth_chunk *auth, --- 17 unchanged lines hidden (view full) --- 3321 struct mbuf *o_pak; 3322 3323 struct sctphdr *sctphdr; 3324 int packet_length; 3325 int o_flgs; 3326 uint32_t csum; 3327 int ret; 3328 unsigned int have_mtu; |
3329 uint32_t vrf_id; |
3330 struct route *ro; 3331 |
3332 |
3333 if ((net) && (net->dest_state & SCTP_ADDR_OUT_OF_SCOPE)) { 3334 sctp_m_freem(m); 3335 return (EFAULT); 3336 } |
3337 if (stcb == NULL) { 3338 vrf_id = SCTP_DEFAULT_VRFID; 3339 } else { 3340 vrf_id = stcb->asoc.vrf_id; 3341 } 3342 |
3343 /* fill in the HMAC digest for any AUTH chunk in the packet */ 3344 if ((auth != NULL) && (stcb != NULL)) { 3345 sctp_fill_hmac_digest_m(m, auth_offset, auth, stcb); 3346 } 3347 /* Calculate the csum and fill in the length of the packet */ 3348 sctphdr = mtod(m, struct sctphdr *); 3349 have_mtu = 0; 3350 if (sctp_no_csum_on_loopback && --- 8 unchanged lines hidden (view full) --- 3359 packet_length = sctp_calculate_len(m); 3360 } else { 3361 sctphdr->checksum = 0; 3362 csum = sctp_calculate_sum(m, &packet_length, 0); 3363 sctphdr->checksum = csum; 3364 } 3365 3366 if (to->sa_family == AF_INET) { |
3367 struct ip *ip = NULL; |
3368 struct route iproute; 3369 uint8_t tos_value; 3370 3371 o_pak = SCTP_GET_HEADER_FOR_OUTPUT(sizeof(struct ip)); 3372 if (o_pak == NULL) { 3373 /* failed to prepend data, give up */ 3374 sctp_m_freem(m); 3375 return (ENOMEM); --- 47 unchanged lines hidden (view full) --- 3423 } 3424 /* Now the address selection part */ 3425 ip->ip_dst.s_addr = ((struct sockaddr_in *)to)->sin_addr.s_addr; 3426 3427 /* call the routine to select the src address */ 3428 if (net) { 3429 if (net->src_addr_selected == 0) { 3430 /* Cache the source address */ |
3431 net->ro._s_addr = sctp_source_address_selection(inp, stcb, 3432 ro, net, out_of_asoc_ok, vrf_id); 3433 if (net->ro._s_addr == NULL) { 3434 /* No route to host */ 3435 goto no_route; 3436 } 3437 net->src_addr_selected = 1; |
3438 } |
3439 ip->ip_src = net->ro._s_addr->address.sin.sin_addr; |
3440 } else { |
3441 struct sctp_ifa *_lsrc; 3442 3443 _lsrc = sctp_source_address_selection(inp, 3444 stcb, ro, net, out_of_asoc_ok, vrf_id); 3445 if (_lsrc == NULL) { 3446 goto no_route; 3447 } 3448 ip->ip_src = _lsrc->address.sin.sin_addr; 3449 sctp_free_ifa(_lsrc); |
3450 } 3451 3452 /* 3453 * If source address selection fails and we find no route 3454 * then the ip_output should fail as well with a 3455 * NO_ROUTE_TO_HOST type error. We probably should catch 3456 * that somewhere and abort the association right away 3457 * (assuming this is an INIT being sent). 3458 */ 3459 if ((ro->ro_rt == NULL)) { 3460 /* 3461 * src addr selection failed to find a route (or 3462 * valid source addr), so we can't get there from |
3463 * here (yet)! |
3464 */ |
3465 no_route: |
3466#ifdef SCTP_DEBUG 3467 if (sctp_debug_on & SCTP_DEBUG_OUTPUT1) { |
3468 printf("low_level_output: dropped packet - no valid source addr\n"); 3469 if (net) { 3470 printf("Destination was "); 3471 sctp_print_address(&net->ro._l_addr.sa); 3472 } |
3473 } 3474#endif /* SCTP_DEBUG */ 3475 if (net) { |
3476 if (net->dest_state & SCTP_ADDR_CONFIRMED) { 3477 if ((net->dest_state & SCTP_ADDR_REACHABLE) && stcb) { 3478 printf("no route takes interface %p down\n", net); 3479 sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN, 3480 stcb, 3481 SCTP_FAILED_THRESHOLD, 3482 (void *)net); 3483 net->dest_state &= ~SCTP_ADDR_REACHABLE; 3484 net->dest_state |= SCTP_ADDR_NOT_REACHABLE; 3485 } 3486 } |
3487 if (stcb) { 3488 if (net == stcb->asoc.primary_destination) { 3489 /* need a new primary */ 3490 struct sctp_nets *alt; 3491 3492 alt = sctp_find_alternate_net(stcb, net, 0); 3493 if (alt != net) { 3494 if (sctp_set_primary_addr(stcb, 3495 (struct sockaddr *)NULL, 3496 alt) == 0) { 3497 net->dest_state |= SCTP_ADDR_WAS_PRIMARY; |
3498 if (net->ro._s_addr) { 3499 sctp_free_ifa(net->ro._s_addr); 3500 net->ro._s_addr = NULL; 3501 } |
3502 net->src_addr_selected = 0; 3503 } 3504 } 3505 } 3506 } 3507 } 3508 sctp_m_freem(o_pak); 3509 return (EHOSTUNREACH); --- 33 unchanged lines hidden (view full) --- 3543 SCTP_STAT_INCR(sctps_senderrors); 3544#ifdef SCTP_DEBUG 3545 if (sctp_debug_on & SCTP_DEBUG_OUTPUT3) { 3546 printf("Ip output returns %d\n", ret); 3547 } 3548#endif 3549 if (net == NULL) { 3550 /* free tempy routes */ |
3551 if (ro->ro_rt) { |
3552 RTFREE(ro->ro_rt); |
3553 ro->ro_rt = NULL; 3554 } |
3555 } else { 3556 /* PMTU check versus smallest asoc MTU goes here */ 3557 if (ro->ro_rt != NULL) { 3558 if (ro->ro_rt->rt_rmx.rmx_mtu && 3559 (stcb->asoc.smallest_mtu > ro->ro_rt->rt_rmx.rmx_mtu)) { 3560 sctp_mtu_size_reset(inp, &stcb->asoc, 3561 ro->ro_rt->rt_rmx.rmx_mtu); 3562 } 3563 } else { 3564 /* route was freed */ |
3565 if (net->ro._s_addr && 3566 net->src_addr_selected) { 3567 sctp_free_ifa(net->ro._s_addr); 3568 net->ro._s_addr = NULL; 3569 } |
3570 net->src_addr_selected = 0; 3571 } 3572 } 3573 return (ret); 3574 } 3575#ifdef INET6 3576 else if (to->sa_family == AF_INET6) { 3577 uint32_t flowlabel; --- 71 unchanged lines hidden (view full) --- 3649 */ 3650 bzero(&lsa6_tmp, sizeof(lsa6_tmp)); 3651 lsa6_tmp.sin6_family = AF_INET6; 3652 lsa6_tmp.sin6_len = sizeof(lsa6_tmp); 3653 lsa6 = &lsa6_tmp; 3654 if (net) { 3655 if (net->src_addr_selected == 0) { 3656 /* Cache the source address */ |
3657 net->ro._s_addr = sctp_source_address_selection(inp, 3658 stcb, 3659 ro, 3660 net, 3661 out_of_asoc_ok, 3662 vrf_id); 3663 if (net->ro._s_addr == NULL) { 3664#ifdef SCTP_DEBUG 3665 printf("V6:No route to host\n"); 3666#endif 3667 goto no_route; 3668 } 3669 net->src_addr_selected = 1; |
3670 } |
3671 lsa6->sin6_addr = net->ro._s_addr->address.sin6.sin6_addr; |
3672 } else { |
3673 struct sctp_ifa *_lsrc; 3674 3675 _lsrc = sctp_source_address_selection(inp, stcb, ro, net, out_of_asoc_ok, vrf_id); 3676 if (_lsrc == NULL) { 3677 goto no_route; 3678 } 3679 lsa6->sin6_addr = _lsrc->address.sin6.sin6_addr; 3680 sctp_free_ifa(_lsrc); |
3681 } 3682 lsa6->sin6_port = inp->sctp_lport; 3683 3684 if ((ro->ro_rt == NULL)) { 3685 /* 3686 * src addr selection failed to find a route (or 3687 * valid source addr), so we can't get there from 3688 * here! 3689 */ |
3690 goto no_route; |
3691 } 3692 /* 3693 * XXX: sa6 may not have a valid sin6_scope_id in the 3694 * non-SCOPEDROUTING case. 3695 */ 3696 bzero(&lsa6_storage, sizeof(lsa6_storage)); 3697 lsa6_storage.sin6_family = AF_INET6; 3698 lsa6_storage.sin6_len = sizeof(lsa6_storage); --- 50 unchanged lines hidden (view full) --- 3749 } 3750#ifdef SCTP_DEBUG 3751 if (sctp_debug_on & SCTP_DEBUG_OUTPUT3) { 3752 printf("return from send is %d\n", ret); 3753 } 3754#endif /* SCTP_DEBUG_OUTPUT */ 3755 SCTP_STAT_INCR(sctps_sendpackets); 3756 SCTP_STAT_INCR_COUNTER64(sctps_outpackets); |
3757 if (ret) { |
3758 SCTP_STAT_INCR(sctps_senderrors); |
3759 } |
3760 if (net == NULL) { 3761 /* Now if we had a temp route free it */ 3762 if (ro->ro_rt) { 3763 RTFREE(ro->ro_rt); 3764 } 3765 } else { 3766 /* PMTU check versus smallest asoc MTU goes here */ 3767 if (ro->ro_rt == NULL) { 3768 /* Route was freed */ |
3769 3770 if (net->ro._s_addr && 3771 net->src_addr_selected) { 3772 sctp_free_ifa(net->ro._s_addr); 3773 net->ro._s_addr = NULL; 3774 } |
3775 net->src_addr_selected = 0; 3776 } 3777 if (ro->ro_rt != NULL) { 3778 if (ro->ro_rt->rt_rmx.rmx_mtu && 3779 (stcb->asoc.smallest_mtu > ro->ro_rt->rt_rmx.rmx_mtu)) { 3780 sctp_mtu_size_reset(inp, 3781 &stcb->asoc, 3782 ro->ro_rt->rt_rmx.rmx_mtu); --- 672 unchanged lines hidden (view full) --- 4455 struct sockaddr *to; 4456 struct sctp_state_cookie stc; 4457 struct sctp_nets *net = NULL; 4458 int cnt_inits_to = 0; 4459 uint16_t his_limit, i_want; 4460 int abort_flag, padval, sz_of; 4461 int num_ext; 4462 int p_len; |
4463 uint32_t vrf_id; |
4464 |
4465 vrf_id = SCTP_DEFAULT_VRFID; |
4466 if (stcb) { 4467 asoc = &stcb->asoc; 4468 } else { 4469 asoc = NULL; 4470 } 4471 m_last = NULL; 4472 if ((asoc != NULL) && 4473 (SCTP_GET_STATE(asoc) != SCTP_STATE_COOKIE_WAIT) && --- 77 unchanged lines hidden (view full) --- 4551 /* now for scope setup */ 4552 memset((caddr_t)&store, 0, sizeof(store)); 4553 sin = (struct sockaddr_in *)&store; 4554 sin6 = (struct sockaddr_in6 *)&store; 4555 if (net == NULL) { 4556 to = (struct sockaddr *)&store; 4557 iph = mtod(init_pkt, struct ip *); 4558 if (iph->ip_v == IPVERSION) { |
4559 struct sctp_ifa *addr; |
4560 struct route iproute; 4561 4562 sin->sin_family = AF_INET; 4563 sin->sin_len = sizeof(struct sockaddr_in); 4564 sin->sin_port = sh->src_port; 4565 sin->sin_addr = iph->ip_src; 4566 /* lookup address */ 4567 stc.address[0] = sin->sin_addr.s_addr; 4568 stc.address[1] = 0; 4569 stc.address[2] = 0; 4570 stc.address[3] = 0; 4571 stc.addr_type = SCTP_IPV4_ADDRESS; 4572 /* local from address */ 4573 memset(&iproute, 0, sizeof(iproute)); 4574 ro = &iproute; 4575 memcpy(&ro->ro_dst, sin, sizeof(*sin)); |
4576 addr = sctp_source_address_selection(inp, NULL, 4577 ro, NULL, 0, vrf_id); 4578 if (addr == NULL) 4579 return; 4580 |
4581 if (ro->ro_rt) { 4582 RTFREE(ro->ro_rt); |
4583 ro->ro_rt = NULL; |
4584 } |
4585 stc.laddress[0] = addr->address.sin.sin_addr.s_addr; |
4586 stc.laddress[1] = 0; 4587 stc.laddress[2] = 0; 4588 stc.laddress[3] = 0; 4589 stc.laddr_type = SCTP_IPV4_ADDRESS; 4590 /* scope_id is only for v6 */ 4591 stc.scope_id = 0; 4592#ifndef SCTP_DONT_DO_PRIVADDR_SCOPE 4593 if (IN4_ISPRIVATE_ADDRESS(&sin->sin_addr)) { 4594 stc.ipv4_scope = 1; 4595 } 4596#else 4597 stc.ipv4_scope = 1; 4598#endif /* SCTP_DONT_DO_PRIVADDR_SCOPE */ 4599 /* Must use the address in this case */ |
4600 if (sctp_is_address_on_local_host((struct sockaddr *)sin, vrf_id)) { |
4601 stc.loopback_scope = 1; 4602 stc.ipv4_scope = 1; 4603 stc.site_scope = 1; |
4604 stc.local_scope = 0; |
4605 } 4606 } else if (iph->ip_v == (IPV6_VERSION >> 4)) { |
4607 struct sctp_ifa *addr; |
4608 4609 struct route_in6 iproute6; 4610 4611 ip6 = mtod(init_pkt, struct ip6_hdr *); 4612 sin6->sin6_family = AF_INET6; 4613 sin6->sin6_len = sizeof(struct sockaddr_in6); 4614 sin6->sin6_port = sh->src_port; 4615 sin6->sin6_addr = ip6->ip6_src; 4616 /* lookup address */ 4617 memcpy(&stc.address, &sin6->sin6_addr, 4618 sizeof(struct in6_addr)); 4619 sin6->sin6_scope_id = 0; 4620 stc.addr_type = SCTP_IPV6_ADDRESS; 4621 stc.scope_id = 0; |
4622 if (sctp_is_address_on_local_host((struct sockaddr *)sin6, vrf_id)) { |
4623 stc.loopback_scope = 1; |
4624 stc.local_scope = 0; |
4625 stc.site_scope = 1; 4626 stc.ipv4_scope = 1; 4627 } else if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) { 4628 /* 4629 * If the new destination is a LINK_LOCAL we 4630 * must have common both site and local 4631 * scope. Don't set local scope though since 4632 * we must depend on the source to be added --- 23 unchanged lines hidden (view full) --- 4656 * we must have site scope in common. 4657 */ 4658 stc.site_scope = 1; 4659 } 4660 /* local from address */ 4661 memset(&iproute6, 0, sizeof(iproute6)); 4662 ro = (struct route *)&iproute6; 4663 memcpy(&ro->ro_dst, sin6, sizeof(*sin6)); |
4664 addr = sctp_source_address_selection(inp, NULL, 4665 ro, NULL, 0, vrf_id); 4666 if (addr == NULL) 4667 return; 4668 |
4669 if (ro->ro_rt) { 4670 RTFREE(ro->ro_rt); |
4671 ro->ro_rt = NULL; |
4672 } |
4673 memcpy(&stc.laddress, &addr->address.sin6.sin6_addr, sizeof(struct in6_addr)); |
4674 stc.laddr_type = SCTP_IPV6_ADDRESS; 4675 } 4676 } else { 4677 /* set the scope per the existing tcb */ 4678 struct sctp_nets *lnet; 4679 4680 stc.loopback_scope = asoc->loopback_scope; 4681 stc.ipv4_scope = asoc->ipv4_local_scope; --- 20 unchanged lines hidden (view full) --- 4702 stc.address[2] = 0; 4703 stc.address[3] = 0; 4704 stc.addr_type = SCTP_IPV4_ADDRESS; 4705 if (net->src_addr_selected == 0) { 4706 /* 4707 * strange case here, the INIT should have 4708 * did the selection. 4709 */ |
4710 net->ro._s_addr = sctp_source_address_selection(inp, 4711 stcb, (struct route *)&net->ro, 4712 net, 0, vrf_id); 4713 if (net->ro._s_addr == NULL) 4714 return; 4715 |
4716 net->src_addr_selected = 1; 4717 4718 } |
4719 stc.laddress[0] = net->ro._s_addr->address.sin.sin_addr.s_addr; |
4720 stc.laddress[1] = 0; 4721 stc.laddress[2] = 0; 4722 stc.laddress[3] = 0; 4723 stc.laddr_type = SCTP_IPV4_ADDRESS; 4724 } else if (to->sa_family == AF_INET6) { 4725 sin6 = (struct sockaddr_in6 *)to; 4726 memcpy(&stc.address, &sin6->sin6_addr, 4727 sizeof(struct in6_addr)); 4728 stc.addr_type = SCTP_IPV6_ADDRESS; 4729 if (net->src_addr_selected == 0) { 4730 /* 4731 * strange case here, the INIT should have 4732 * did the selection. 4733 */ |
4734 net->ro._s_addr = sctp_source_address_selection(inp, 4735 stcb, (struct route *)&net->ro, 4736 net, 0, vrf_id); 4737 if (net->ro._s_addr == NULL) 4738 return; 4739 |
4740 net->src_addr_selected = 1; 4741 } |
4742 memcpy(&stc.laddress, &net->ro._s_addr->address.sin6.sin6_addr, |
4743 sizeof(struct in6_addr)); 4744 stc.laddr_type = SCTP_IPV6_ADDRESS; 4745 } 4746 } 4747 /* Now lets put the SCTP header in place */ 4748 initackm_out = mtod(m, struct sctp_init_msg *); 4749 initackm_out->sh.src_port = inp->sctp_lport; 4750 initackm_out->sh.dest_port = sh->src_port; --- 126 unchanged lines hidden (view full) --- 4877 /* add authentication parameters */ 4878 if (!sctp_auth_disable) { 4879 struct sctp_auth_random *random; 4880 struct sctp_auth_hmac_algo *hmacs; 4881 struct sctp_auth_chunk_list *chunks; 4882 uint16_t random_len; 4883 4884 /* generate and add RANDOM parameter */ |
4885 random_len = SCTP_AUTH_RANDOM_SIZE_DEFAULT; |
4886 random = (struct sctp_auth_random *)(mtod(m, caddr_t)+SCTP_BUF_LEN(m)); 4887 random->ph.param_type = htons(SCTP_RANDOM); 4888 p_len = sizeof(*random) + random_len; 4889 random->ph.param_length = htons(p_len); 4890 SCTP_READ_RANDOM(random->random_data, random_len); 4891 /* zero out any padding required */ 4892 bzero((caddr_t)random + p_len, SCTP_SIZE32(p_len) - p_len); 4893 SCTP_BUF_LEN(m) += SCTP_SIZE32(p_len); --- 324 unchanged lines hidden (view full) --- 5218 siz -= sctp_get_auth_chunk_len(stcb->asoc.peer_hmac_id); 5219 5220 if (siz % 4) { 5221 /* make it an even word boundary please */ 5222 siz -= (siz % 4); 5223 } 5224 return (siz); 5225} |
5226 5227static void 5228sctp_set_prsctp_policy(struct sctp_tcb *stcb, 5229 struct sctp_stream_queue_pending *sp) 5230{ 5231 sp->pr_sctp_on = 0; 5232 if (stcb->asoc.peer_supports_prsctp) { 5233 /* --- 584 unchanged lines hidden (view full) --- 5818 mat = m; 5819 ca->sndlen = 0; 5820 while (m) { 5821 ca->sndlen += SCTP_BUF_LEN(m); 5822 m = SCTP_BUF_NEXT(m); 5823 } 5824 ca->m = m; 5825 } |
5826 ret = sctp_initiate_iterator(NULL, sctp_sendall_iterator, NULL, |
5827 SCTP_PCB_ANY_FLAGS, SCTP_PCB_ANY_FEATURES, SCTP_ASOC_ANY_STATE, 5828 (void *)ca, 0, 5829 sctp_sendall_completes, inp, 1); 5830 if (ret) { 5831#ifdef SCTP_DEBUG 5832 printf("Failed to initiate iterator for sendall\n"); 5833#endif 5834 SCTP_FREE(ca); --- 178 unchanged lines hidden (view full) --- 6013 /* special handling, we must look into the param */ 6014 if (chk != asoc->str_reset) { 6015 goto clean_up_anyway; 6016 } 6017 } 6018 } 6019} 6020 |
6021 6022static __inline int 6023sctp_can_we_split_this(struct sctp_tcb *stcb, 6024 struct sctp_stream_queue_pending *sp, 6025 int goal_mtu, int frag_point, int eeor_on) 6026{ 6027 /* 6028 * Make a decision on if I should split a msg into multiple parts. --- 370 unchanged lines hidden (view full) --- 6399 6400} 6401 6402static void 6403sctp_fill_outqueue(struct sctp_tcb *stcb, 6404 struct sctp_nets *net, int frag_point, int eeor_mode) 6405{ 6406 struct sctp_association *asoc; |
6407 struct sctp_stream_out *strq, *strqn, *strqt; |
6408 int goal_mtu, moved_how_much, total_moved = 0; 6409 int locked, giveup; 6410 struct sctp_stream_queue_pending *sp; 6411 6412 SCTP_TCB_LOCK_ASSERT(stcb); 6413 asoc = &stcb->asoc; |
6414#ifdef INET6 |
6415 if (net->ro._l_addr.sin6.sin6_family == AF_INET6) { 6416 goal_mtu = net->mtu - SCTP_MIN_OVERHEAD; 6417 } else { 6418 /* ?? not sure what else to do */ 6419 goal_mtu = net->mtu - SCTP_MIN_V4_OVERHEAD; 6420 } 6421#else 6422 goal_mtu = net->mtu - SCTP_MIN_OVERHEAD; --- 50 unchanged lines hidden (view full) --- 6473 asoc->last_out_stream = strq; 6474 if (locked) { 6475 asoc->locked_on_sending = strq; 6476 if ((moved_how_much == 0) || (giveup)) 6477 /* no more to move for now */ 6478 break; 6479 } else { 6480 asoc->locked_on_sending = NULL; |
6481 strqt = sctp_select_a_stream(stcb, asoc); |
6482 if (TAILQ_FIRST(&strq->outqueue) == NULL) { 6483 sctp_remove_from_wheel(stcb, asoc, strq); 6484 } 6485 if (giveup) { 6486 break; 6487 } |
6488 strq = strqt; |
6489 if (strq == NULL) { 6490 break; 6491 } 6492 } 6493 total_moved += moved_how_much; 6494 goal_mtu -= moved_how_much; 6495 goal_mtu &= 0xfffffffc; 6496 } --- 45 unchanged lines hidden (view full) --- 6542 sctp_free_remote_addr(chk->whoTo); 6543 chk->whoTo = a_net; 6544 atomic_add_int(&a_net->ref_count, 1); 6545 } 6546 } 6547 } 6548} 6549 |
6550int 6551sctp_med_chunk_output(struct sctp_inpcb *inp, 6552 struct sctp_tcb *stcb, 6553 struct sctp_association *asoc, 6554 int *num_out, 6555 int *reason_code, 6556 int control_only, int *cwnd_full, int from_where, 6557 struct timeval *now, int *now_filled, int frag_point) --- 10 unchanged lines hidden (view full) --- 6568 struct sctp_nets *net; 6569 struct mbuf *outchain, *endoutchain; 6570 struct sctp_tmit_chunk *chk, *nchk; 6571 struct sctphdr *shdr; 6572 6573 /* temp arrays for unlinking */ 6574 struct sctp_tmit_chunk *data_list[SCTP_MAX_DATA_BUNDLING]; 6575 int no_fragmentflg, error; |
6576 int one_chunk, hbflag, skip_data_for_this_net; |
6577 int asconf, cookie, no_out_cnt; 6578 int bundle_at, ctl_cnt, no_data_chunks, cwnd_full_ind, eeor_mode; 6579 unsigned int mtu, r_mtu, omtu, mx_mtu, to_out; 6580 struct sctp_nets *start_at, *old_startat = NULL, *send_start_at; 6581 int tsns_sent = 0; 6582 uint32_t auth_offset = 0; 6583 struct sctp_auth_chunk *auth = NULL; 6584 --- 134 unchanged lines hidden (view full) --- 6719 * queued to this address. Skip it. 6720 */ 6721 continue; 6722 } 6723 ctl_cnt = bundle_at = 0; 6724 endoutchain = outchain = NULL; 6725 no_fragmentflg = 1; 6726 one_chunk = 0; |
6727 if (net->dest_state & SCTP_ADDR_UNCONFIRMED) { 6728 skip_data_for_this_net = 1; 6729 } else { 6730 skip_data_for_this_net = 0; 6731 } |
6732 if ((net->ro.ro_rt) && (net->ro.ro_rt->rt_ifp)) { 6733 /* 6734 * if we have a route and an ifp check to see if we 6735 * have room to send to this guy 6736 */ 6737 struct ifnet *ifp; 6738 6739 ifp = net->ro.ro_rt->rt_ifp; --- 209 unchanged lines hidden (view full) --- 6949 if (error == EHOSTUNREACH) { 6950 /* 6951 * Destination went 6952 * unreachable 6953 * during this send 6954 */ 6955 sctp_move_to_an_alt(stcb, asoc, net); 6956 } |
6957 *reason_code = 7; |
6958 continue; |
6959 } else 6960 asoc->ifp_had_enobuf = 0; 6961 /* Only HB or ASCONF advances time */ 6962 if (hbflag) { 6963 if (*now_filled == 0) { 6964 SCTP_GETTIME_TIMEVAL(&net->last_sent_time); 6965 *now_filled = 1; 6966 *now = net->last_sent_time; --- 44 unchanged lines hidden (view full) --- 7011 else 7012 omtu = 0; 7013 } else { 7014 if (net->mtu > (sizeof(struct ip6_hdr) + sizeof(struct sctphdr))) 7015 omtu = net->mtu - (sizeof(struct ip6_hdr) + sizeof(struct sctphdr)); 7016 else 7017 omtu = 0; 7018 } |
7019 if ((((asoc->state & SCTP_STATE_OPEN) == SCTP_STATE_OPEN) && (skip_data_for_this_net == 0)) || |
7020 (cookie)) { 7021 for (chk = TAILQ_FIRST(&asoc->send_queue); chk; chk = nchk) { 7022 if (no_data_chunks) { 7023 /* let only control go out */ 7024 *reason_code = 1; 7025 break; 7026 } 7027 if (net->flight_size >= net->cwnd) { --- 188 unchanged lines hidden (view full) --- 7216 } 7217 if (error == EHOSTUNREACH) { 7218 /* 7219 * Destination went unreachable 7220 * during this send 7221 */ 7222 sctp_move_to_an_alt(stcb, asoc, net); 7223 } |
7224 *reason_code = 6; |
7225 continue; |
7226 } else { 7227 asoc->ifp_had_enobuf = 0; 7228 } 7229 outchain = endoutchain = NULL; 7230 auth = NULL; 7231 auth_offset = 0; 7232 if (bundle_at || hbflag) { 7233 /* For data/asconf and hb set time */ --- 879 unchanged lines hidden (view full) --- 8113 SCTP_STAT_INCR(sctps_sendretransdata); 8114 data_list[i]->sent = SCTP_DATAGRAM_SENT; 8115 /* 8116 * When we have a revoked data, and we 8117 * retransmit it, then we clear the revoked 8118 * flag since this flag dictates if we 8119 * subtracted from the fs 8120 */ |
8121 if (data_list[i]->rec.data.chunk_was_revoked) { 8122 /* Deflate the cwnd */ 8123 data_list[i]->whoTo->cwnd -= data_list[i]->book_size; 8124 data_list[i]->rec.data.chunk_was_revoked = 0; 8125 } |
8126 data_list[i]->snd_count++; 8127 sctp_ucount_decr(asoc->sent_queue_retran_cnt); 8128 /* record the time */ 8129 data_list[i]->sent_rcv_time = asoc->time_last_sent; 8130 if (asoc->sent_queue_retran_cnt < 0) { 8131 asoc->sent_queue_retran_cnt = 0; 8132 } 8133 if (data_list[i]->book_size_scale) { --- 602 unchanged lines hidden (view full) --- 8736 a_chk->whoTo = NULL; 8737 break; 8738 } 8739 } 8740 if (a_chk == NULL) { 8741 sctp_alloc_a_chunk(stcb, a_chk); 8742 if (a_chk == NULL) { 8743 /* No memory so we drop the idea, and set a timer */ |
8744 if (stcb->asoc.delayed_ack) { 8745 sctp_timer_stop(SCTP_TIMER_TYPE_RECV, 8746 stcb->sctp_ep, stcb, NULL, SCTP_FROM_SCTP_OUTPUT + SCTP_LOC_5); 8747 sctp_timer_start(SCTP_TIMER_TYPE_RECV, 8748 stcb->sctp_ep, stcb, NULL); 8749 } else { 8750 stcb->asoc.send_sack = 1; 8751 } |
8752 return; 8753 } 8754 a_chk->copy_by_ref = 0; 8755 /* a_chk->rec.chunk_id.id = SCTP_SELECTIVE_ACK; */ 8756 a_chk->rec.chunk_id.id = SCTP_SELECTIVE_ACK; 8757 a_chk->rec.chunk_id.can_take_data = 1; 8758 } |
8759 /* Clear our pkt counts */ 8760 asoc->data_pkts_seen = 0; 8761 |
8762 a_chk->asoc = asoc; 8763 a_chk->snd_count = 0; 8764 a_chk->send_size = 0; /* fill in later */ 8765 a_chk->sent = SCTP_DATAGRAM_UNSENT; 8766 8767 if ((asoc->numduptsns) || 8768 (asoc->last_data_chunk_from->dest_state & SCTP_ADDR_NOT_REACHABLE) 8769 ) { --- 42 unchanged lines hidden (view full) --- 8812 if (a_chk->data) { 8813 /* was a problem with the destination */ 8814 sctp_m_freem(a_chk->data); 8815 a_chk->data = NULL; 8816 } 8817 if (a_chk->whoTo) 8818 atomic_subtract_int(&a_chk->whoTo->ref_count, 1); 8819 sctp_free_a_chunk(stcb, a_chk); |
8820 if (stcb->asoc.delayed_ack) { 8821 sctp_timer_stop(SCTP_TIMER_TYPE_RECV, 8822 stcb->sctp_ep, stcb, NULL, SCTP_FROM_SCTP_OUTPUT + SCTP_LOC_6); 8823 sctp_timer_start(SCTP_TIMER_TYPE_RECV, 8824 stcb->sctp_ep, stcb, NULL); 8825 } else { 8826 stcb->asoc.send_sack = 1; 8827 } |
8828 return; 8829 } 8830 /* ok, lets go through and fill it in */ 8831 SCTP_BUF_RESV_UF(a_chk->data, SCTP_MIN_OVERHEAD); 8832 space = M_TRAILINGSPACE(a_chk->data); 8833 if (space > (a_chk->whoTo->mtu - SCTP_MIN_OVERHEAD)) { 8834 space = (a_chk->whoTo->mtu - SCTP_MIN_OVERHEAD); 8835 } --- 122 unchanged lines hidden (view full) --- 8958 (num_gap_blocks * sizeof(struct sctp_gap_ack_block)) + 8959 (num_dups * sizeof(int32_t))); 8960 SCTP_BUF_LEN(a_chk->data) = a_chk->send_size; 8961 sack->sack.num_gap_ack_blks = htons(num_gap_blocks); 8962 sack->sack.num_dup_tsns = htons(num_dups); 8963 sack->ch.chunk_length = htons(a_chk->send_size); 8964 TAILQ_INSERT_TAIL(&asoc->control_send_queue, a_chk, sctp_next); 8965 asoc->ctrl_queue_cnt++; |
8966 asoc->send_sack = 0; |
8967 SCTP_STAT_INCR(sctps_sendsacks); 8968 return; 8969} 8970 8971 8972void 8973sctp_send_abort_tcb(struct sctp_tcb *stcb, struct mbuf *operr) 8974{ --- 1461 unchanged lines hidden (view full) --- 10436 } 10437 } 10438 error = sctp_lower_sosend(so, addr, uio, top, control, flags, 10439 use_rcvinfo, &srcv, p); 10440 return (error); 10441} 10442 10443 |
10444int 10445sctp_lower_sosend(struct socket *so, 10446 struct sockaddr *addr, 10447 struct uio *uio, 10448 struct mbuf *i_pak, 10449 struct mbuf *control, 10450 int flags, 10451 int use_rcvinfo, --- 150 unchanged lines hidden (view full) --- 10602 } else if (addr == NULL) { 10603 error = ENOENT; 10604 goto out_unlocked; 10605 } else { 10606 /* 10607 * UDP style, we must go ahead and start the INIT 10608 * process 10609 */ |
10610 uint32_t vrf; 10611 |
10612 if ((use_rcvinfo) && (srcv) && 10613 ((srcv->sinfo_flags & SCTP_ABORT) || 10614 ((srcv->sinfo_flags & SCTP_EOF) && 10615 (uio->uio_resid == 0)))) { 10616 /* 10617 * User asks to abort a non-existant assoc, 10618 * or EOF a non-existant assoc with no data 10619 */ 10620 error = ENOENT; 10621 goto out_unlocked; 10622 } 10623 /* get an asoc/stcb struct */ |
10624 vrf = SCTP_DEFAULT_VRFID; 10625 stcb = sctp_aloc_assoc(inp, addr, 1, &error, 0, vrf); |
10626 if (stcb == NULL) { 10627 /* Error is setup for us in the call */ 10628 goto out_unlocked; 10629 } 10630 if (create_lock_applied) { 10631 SCTP_ASOC_CREATE_UNLOCK(inp); 10632 create_lock_applied = 0; 10633 } else { --- 112 unchanged lines hidden (view full) --- 10746 * but the ro structure may now have an update and 10747 * thus we may need to change it BEFORE we append 10748 * the message. 10749 */ 10750 net = stcb->asoc.primary_destination; 10751 asoc = &stcb->asoc; 10752 } 10753 } |
10754 if ((SCTP_SO_IS_NBIO(so) |
10755 || (flags & MSG_NBIO) 10756 )) { 10757 non_blocking = 1; 10758 } 10759 asoc = &stcb->asoc; 10760 /* would we block? */ 10761 if (non_blocking) { 10762 if ((so->so_snd.sb_hiwat < --- 858 unchanged lines hidden --- |