| blob | 20865c4370423aa65349d752a31d325290766365 |
1 /*-
2 * Copyright (c) 2001-2007, by 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.
9 *
10 * b) Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in
12 * the documentation and/or other materials provided with the distribution.
13 *
14 * c) Neither the name of Cisco Systems, Inc. nor the names of its
15 * contributors may be used to endorse or promote products derived
16 * from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
20 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
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 */
31 /* $KAME: sctputil.c,v 1.37 2005/03/07 23:26:09 itojun Exp $ */
33 #include <sys/cdefs.h>
36 #include <netinet/sctp_os.h>
37 #include <netinet/sctp_pcb.h>
38 #include <netinet/sctputil.h>
39 #include <netinet/sctp_var.h>
40 #include <netinet/sctp_sysctl.h>
41 #ifdef INET6
42 #endif
43 #include <netinet/sctp_header.h>
44 #include <netinet/sctp_output.h>
45 #include <netinet/sctp_uio.h>
46 #include <netinet/sctp_timer.h>
47 #include <netinet/sctp_crc32.h>
49 #include <netinet/sctp_auth.h>
50 #include <netinet/sctp_asconf.h>
51 #include <netinet/sctp_cc_functions.h>
53 #define NUMBER_OF_MTU_SIZES 18
56 #ifndef KTR_SCTP
57 #define KTR_SCTP KTR_SUBSYS
58 #endif
60 void
63 {
70 else
74 SCTP_LOG_EVENT_SB,
75 from,
80 }
82 void
84 {
95 }
98 SCTP_LOG_EVENT_CLOSE,
104 }
107 void
109 {
116 SCTP_LOG_EVENT_RTT,
117 from,
123 }
125 void
126 sctp_log_strm_del_alt(struct sctp_tcb *stcb, uint32_t tsn, uint16_t sseq, uint16_t stream, int from)
127 {
137 SCTP_LOG_EVENT_STRM,
138 from,
144 }
146 void
148 {
157 SCTP_LOG_EVENT_NAGLE,
158 action,
163 }
166 void
167 sctp_log_sack(uint32_t old_cumack, uint32_t cumack, uint32_t tsn, uint16_t gaps, uint16_t dups, int from)
168 {
177 SCTP_LOG_EVENT_SACK,
178 from,
183 }
185 void
187 {
195 SCTP_LOG_EVENT_MAP,
196 from,
201 }
203 void
206 {
214 SCTP_LOG_EVENT_FR,
215 from,
221 }
224 void
226 {
239 }
241 SCTP_LOG_EVENT_MBUF,
242 from,
247 }
250 void
253 {
259 }
270 }
272 SCTP_LOG_EVENT_STRM,
273 from,
279 }
281 void
283 {
289 else
293 else
302 }
305 }
308 SCTP_LOG_EVENT_CWND,
309 from,
315 }
317 void
319 {
328 }
334 }
341 }
351 }
353 SCTP_LOG_LOCK_EVENT,
354 from,
360 }
362 void
363 sctp_log_maxburst(struct sctp_tcb *stcb, struct sctp_nets *net, int error, int burst, uint8_t from)
364 {
374 else
378 else
381 SCTP_LOG_EVENT_MAXBURST,
382 from,
388 }
390 void
392 {
400 SCTP_LOG_EVENT_RWND,
401 from,
406 }
408 void
409 sctp_log_rwnd_set(uint8_t from, uint32_t peers_rwnd, uint32_t flight_size, uint32_t overhead, uint32_t a_rwndval)
410 {
418 SCTP_LOG_EVENT_RWND,
419 from,
424 }
426 void
427 sctp_log_mbcnt(uint8_t from, uint32_t total_oq, uint32_t book, uint32_t total_mbcnt_q, uint32_t mbcnt)
428 {
436 SCTP_LOG_EVENT_MBCNT,
437 from,
443 }
445 void
447 {
449 SCTP_LOG_MISC_EVENT,
450 from,
452 }
454 void
456 {
467 else
472 else
476 /* set in the defered mode stuff */
483 /* what about the sb */
490 }
492 SCTP_LOG_EVENT_WAKE,
493 from,
499 }
501 void
503 {
514 SCTP_LOG_EVENT_BLOCK,
515 from,
521 }
523 int
525 {
526 /* May need to fix this if ktrdump does not work */
528 }
530 #ifdef SCTP_AUDITING_ENABLED
534 static
535 void
537 {
554 }
557 cnt++;
560 }
573 }
576 cnt++;
579 }
581 }
583 void
586 {
593 sctp_audit_indx++;
596 }
600 sctp_audit_indx++;
603 }
605 }
609 sctp_audit_indx++;
612 }
614 }
618 sctp_audit_indx++;
621 }
627 resend_cnt++;
630 tot_book_cnt++;
631 }
632 }
636 sctp_audit_indx++;
639 }
647 sctp_audit_indx++;
650 }
651 }
655 sctp_audit_indx++;
658 }
663 }
667 sctp_audit_indx++;
670 }
675 }
679 }
683 sctp_audit_indx++;
686 }
690 /* now corrective action */
698 }
699 }
703 tot_out);
705 }
706 }
707 }
710 }
711 }
713 void
715 {
719 sctp_audit_indx++;
722 }
723 }
725 #endif
727 /*
728 * a list of sizes based on typical mtu's, used only if next hop size not
729 * returned.
730 */
749 65535
750 };
752 void
754 {
769 }
770 }
772 int
774 {
777 /*
778 * if we are in here we must find the next best fit based on the
779 * size of the dg that failed to be sent.
780 */
788 }
789 }
791 }
793 void
795 {
796 /*
797 * Here we use the MD5/SHA-1 to hash with our good randomNumbers and
798 * our counter. The result becomes our good random numbers and we
799 * then setup to give these out. Note that we do no locking to
800 * protect this. This is ok, since if competing folks call this we
801 * will get more gobbled gook in the random store which is what we
802 * want. There is a danger that two guys will use the same random
803 * numbers, but thats ok too since that is random as well :->
804 */
810 }
812 uint32_t
814 {
815 /*
816 * A true implementation should use random selection process to get
817 * the initial stream sequence number, using RFC1750 as a good
818 * guideline
819 */
830 }
831 retry:
836 }
839 }
841 /* Refill the random store */
843 }
848 }
850 uint32_t
852 {
861 /* we never use 0 */
863 }
866 }
867 }
869 }
871 int
874 {
877 /*
878 * Anything set to zero is taken care of by the allocation routine's
879 * bzero
880 */
882 /*
883 * Up front select what scoping to apply on addresses I tell my peer
884 * Not sure what to do with these right now, we will need to come up
885 * with a way to set them. We may need to pass them through from the
886 * caller in the sctp_aloc_assoc() function.
887 */
891 /* init all variables to a known value. */
897 /* JRS 5/21/07 - Init CMT PF variables */
900 #ifdef INET
902 #else
904 #endif
906 #ifdef INET6
908 #else
910 #endif
917 /*
918 * It must be in the time-wait hash, we put it there
919 * when we aloc one. If not the peer is playing
920 * games.
921 */
925 #ifdef INVARIANTS
927 #endif
929 }
933 }
934 /* Get the nonce tags */
941 else
944 #ifdef SCTP_ASOCLOG_OF_TSNS
951 #endif
952 #ifdef SCTP_FS_SPEC_LOG
954 #endif
961 /* we are optimisitic here */
966 /* for CMT */
969 /* This will need to be adjusted */
975 /* here we are different, we hold the next one we expect */
987 /* ECN Nonce initialization */
1005 /* Its a V6 socket */
1008 /* Now look at the binding flag to see if V4 will be legal */
1012 /* V4 addresses are NOT legal on the association */
1014 }
1016 /* Its a V4 socket, no - V6 */
1019 }
1025 #ifdef SCTP_PRINT_FOR_B_AND_M
1028 #endif
1044 /* Setup to fill the hb random cache at first HB */
1049 /*
1050 * JRS - Pick the default congestion control module based on the
1051 * sysctl.
1052 */
1054 /* JRS - Standard TCP congestion control */
1056 {
1063 stcb->asoc.cc_functions.sctp_cwnd_update_after_packet_dropped = &sctp_cwnd_update_after_packet_dropped;
1067 }
1068 /* JRS - High Speed TCP congestion control (Floyd) */
1070 {
1077 stcb->asoc.cc_functions.sctp_cwnd_update_after_packet_dropped = &sctp_cwnd_update_after_packet_dropped;
1081 }
1082 /* JRS - HTCP congestion control */
1084 {
1090 stcb->asoc.cc_functions.sctp_cwnd_update_after_ecn_echo = &sctp_htcp_cwnd_update_after_ecn_echo;
1091 stcb->asoc.cc_functions.sctp_cwnd_update_after_packet_dropped = &sctp_cwnd_update_after_packet_dropped;
1093 stcb->asoc.cc_functions.sctp_cwnd_update_after_fr_timer = &sctp_htcp_cwnd_update_after_fr_timer;
1095 }
1096 /* JRS - By default, use RFC2581 */
1098 {
1105 stcb->asoc.cc_functions.sctp_cwnd_update_after_packet_dropped = &sctp_cwnd_update_after_packet_dropped;
1109 }
1110 }
1112 /*
1113 * Now the stream parameters, here we allocate space for all streams
1114 * that we request by default.
1115 */
1120 SCTP_M_STRMO);
1122 /* big trouble no memory */
1125 }
1127 /*
1128 * inbound side must be set to 0xffff, also NOTE when we get
1129 * the INIT-ACK back (for INIT sender) we MUST reduce the
1130 * count (streamoutcnt) but first check if we sent to any of
1131 * the upper streams that were dropped (if some were). Those
1132 * that were dropped must be notified to the upper layer as
1133 * failed to send.
1134 */
1141 }
1142 /* Now the mapping array */
1145 SCTP_M_MAP);
1150 }
1152 /* Now the init of the other outqueues */
1163 /* authentication fields */
1180 /*
1181 * sa_ignore MEMLEAK {memory is put in the assoc mapping array and
1182 * freed later whe the association is freed.
1183 */
1185 }
1187 int
1189 {
1190 /* mapping array needs to grow */
1197 /* can't get more, forget it */
1199 new_size);
1201 }
1208 }
1210 #if defined(SCTP_USE_THREAD_BASED_ITERATOR)
1211 static void
1213 {
1220 }
1222 /* iterator is complete */
1223 done_with_iterator:
1227 }
1230 }
1231 select_a_new_ep:
1237 /* endpoint flags or features don't match, so keep looking */
1241 }
1246 }
1248 }
1253 /* now go through each assoc which is in the desired state */
1258 }
1260 /* run the per instance function */
1262 }
1268 }
1271 }
1275 /* not in the right state... keep looking */
1278 }
1279 /* see if we have limited out the iterator loop */
1280 iteration_count++;
1282 /* Pause to let others grab the lock */
1296 }
1297 /* run function on this one */
1300 /*
1301 * we lie here, it really needs to have its own type but
1302 * first I must verify that this won't effect things :-0
1303 */
1308 next_assoc:
1311 /* Run last function */
1316 }
1317 }
1318 }
1320 no_stcb:
1321 /* done with all assocs on this endpoint, move on to next endpoint */
1331 }
1334 }
1336 }
1338 void
1340 {
1343 /* This function is called with the WQ lock in place */
1346 again:
1349 /* now lets work on this one */
1354 /* sa_ignore FREED_MEMORY */
1356 }
1359 }
1362 }
1364 #endif
1367 static void
1369 {
1370 /* deal with the ADDR wq from the rtsock calls */
1377 /* Try later, no memory */
1383 }
1393 }
1399 sctp_asconf_iterator_stcb,
1401 SCTP_PCB_FLAGS_BOUNDALL,
1402 SCTP_PCB_ANY_FEATURES,
1403 SCTP_ASOC_ANY_STATE,
1406 }
1407 }
1412 void
1414 {
1420 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
1423 #endif
1433 #ifdef SCTP_AUDITING_ENABLED
1436 #endif
1438 /* sanity checks... */
1440 /*
1441 * SCTP_PRINTF("Stale SCTP timer fired (%p), ignoring...\n",
1442 * tmr);
1443 */
1445 }
1448 /*
1449 * SCTP_PRINTF("SCTP timer fired with invalid type: 0x%x\n",
1450 * tmr->type);
1451 */
1453 }
1457 }
1458 /* if this is an iterator timeout, get the struct and clear inp */
1463 }
1473 ) {
1476 }
1477 }
1485 }
1487 }
1488 }
1494 }
1497 }
1499 }
1511 }
1513 }
1514 }
1515 /* record in stopped what t-o occured */
1518 /* mark as being serviced now */
1520 /*
1521 * Callout has been rescheduled.
1522 */
1524 }
1526 /*
1527 * Not active, so no action.
1528 */
1530 }
1533 /* call the handler for the appropriate timer type */
1538 }
1541 }
1546 }
1549 }
1561 }
1567 }
1572 /* no need to unlock on tcb its gone */
1575 }
1577 #ifdef SCTP_AUDITING_ENABLED
1579 #endif
1583 ) {
1586 /*
1587 * safeguard. If there on some on the sent queue
1588 * somewhere but no timers running something is
1589 * wrong... so we start a timer on the first chunk
1590 * on the send queue on whatever net it is sent to.
1591 */
1595 }
1600 }
1604 /* no need to unlock on tcb its gone */
1606 }
1607 /* We do output but not here */
1613 } {
1621 }
1622 #ifdef SCTP_AUDITING_ENABLED
1624 #endif
1630 }
1632 /* no need to unlock on tcb its gone */
1634 }
1637 #ifdef SCTP_AUDITING_ENABLED
1639 #endif
1643 {
1649 }
1655 cnt_of_unconf++;
1656 }
1657 }
1660 cnt_of_unconf)) {
1661 /* no need to unlock on tcb its gone */
1663 }
1664 }
1665 #ifdef SCTP_AUDITING_ENABLED
1667 #endif
1671 }
1676 }
1678 /* no need to unlock on tcb its gone */
1680 }
1683 #ifdef SCTP_AUDITING_ENABLED
1685 #endif
1686 /*
1687 * We consider T3 and Cookie timer pretty much the same with
1688 * respect to where from in chunk_output.
1689 */
1693 {
1699 }
1708 SCTP_HOW_MANY_SECRETS) {
1710 }
1715 }
1718 }
1724 }
1732 }
1734 /* no need to unlock on tcb its gone */
1736 }
1739 #ifdef SCTP_AUDITING_ENABLED
1741 #endif
1747 }
1751 /* no need to unlock on tcb its gone */
1757 }
1759 /* no need to unlock on tcb its gone */
1761 }
1766 /* Need to do FR of things for net */
1769 }
1776 }
1778 /* no need to unlock on tcb its gone */
1780 }
1782 #ifdef SCTP_AUDITING_ENABLED
1784 #endif
1790 }
1798 }
1807 }
1809 /* Can we free it yet? */
1812 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
1819 #endif
1821 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
1823 #endif
1824 /*
1825 * free asoc, always unlocks (or destroy's) so prevent
1826 * duplicate unlock or unlock of a free mtx :-0
1827 */
1834 }
1835 /*
1836 * special case, take away our increment since WE are the
1837 * killer
1838 */
1842 SCTP_CALLED_DIRECTLY_NOCMPSET);
1849 };
1850 #ifdef SCTP_AUDITING_ENABLED
1854 #endif
1856 /*
1857 * Now we need to clean up the control chunk chain if an
1858 * ECNE is on it. It must be marked as UNSENT again so next
1859 * call will continue to send it until such time that we get
1860 * a CWR, to remove it. It is, however, less likely that we
1861 * will find a ecn echo on the chain though.
1862 */
1864 }
1865 get_out:
1868 }
1869 out_decr:
1872 }
1873 out_no_decr:
1875 type);
1876 }
1878 void
1881 {
1893 }
1904 /* Only 1 tick away :-) */
1909 {
1915 }
1918 /* Here we use the RTO timer */
1919 {
1924 }
1930 }
1932 }
1935 /*
1936 * Here we use the INIT timer default usually about 1
1937 * minute.
1938 */
1941 }
1947 }
1950 /*
1951 * Here we use the Delayed-Ack timer value from the inp
1952 * ususually about 200ms.
1953 */
1956 }
1961 /* Here we use the RTO of the destination. */
1964 }
1969 }
1973 /*
1974 * the net is used here so that we can add in the RTO. Even
1975 * though we use a different timer. We also add the HB timer
1976 * PLUS a random jitter.
1977 */
1989 cnt_of_unconf++;
1990 }
1991 }
1995 }
2001 }
2005 /*
2006 * this_random will be 0 - 256 ms RTO is in ms.
2007 */
2011 }
2021 }
2022 }
2024 /* Never been checked */
2027 /* set rto_val to the ms */
2029 }
2035 }
2036 }
2037 /*
2038 * Now we must convert the to_ticks that are now in
2039 * ms to ticks.
2040 */
2043 }
2046 /*
2047 * Here we can use the RTO timer from the network since one
2048 * RTT was compelete. If a retran happened then we will be
2049 * using the RTO initial value.
2050 */
2053 }
2058 }
2062 /*
2063 * nothing needed but the endpoint here ususually about 60
2064 * minutes.
2065 */
2068 }
2075 }
2080 /*
2081 * The inp is setup to die. We re-use the signature_chage
2082 * timer since that has stopped and we are in the GONE
2083 * state.
2084 */
2087 }
2092 /*
2093 * Here we use the value found in the EP for PMTU ususually
2094 * about 10 minutes.
2095 */
2098 }
2101 }
2106 /* Here we use the RTO of the destination */
2109 }
2114 }
2118 /*
2119 * Here we use the endpoints shutdown guard timer usually
2120 * about 3 minutes.
2121 */
2124 }
2129 /*
2130 * Here the timer comes from the stcb but its value is from
2131 * the net's RTO.
2132 */
2135 }
2140 }
2145 {
2150 }
2152 /* no need to start */
2154 }
2157 /* Hmm no rtt estimate yet? */
2161 }
2166 }
2167 }
2170 }
2173 /*
2174 * Here the timer comes from the stcb but its value is from
2175 * the net's RTO.
2176 */
2179 }
2184 }
2190 }
2197 }
2199 /*
2200 * Really an error since stcb is NOT set to
2201 * autoclose
2202 */
2204 }
2213 };
2218 }
2220 /*
2221 * we do NOT allow you to have it already running. if it is
2222 * we leave the current one up unchanged
2223 */
2225 }
2226 /* At this point we can proceed */
2229 }
2239 }
2241 void
2244 {
2254 }
2268 }
2273 {
2278 }
2283 }
2289 }
2295 }
2301 }
2307 }
2313 }
2317 /* nothing needed but the endpoint here */
2319 /*
2320 * We re-use the newcookie timer for the INP kill timer. We
2321 * must assure that we do not kill it by accident.
2322 */
2325 /*
2326 * Stop the asoc kill timer.
2327 */
2330 }
2335 /*
2336 * The inp is setup to die. We re-use the signature_chage
2337 * timer since that has stopped and we are in the GONE
2338 * state.
2339 */
2345 }
2351 }
2357 }
2363 }
2369 }
2375 }
2381 }
2388 };
2391 }
2393 /*
2394 * Ok we have a timer that is under joint use. Cookie timer
2395 * per chance with the SEND timer. We therefore are NOT
2396 * running the timer that the caller wants stopped. So just
2397 * return.
2398 */
2400 }
2405 }
2406 }
2411 }
2413 #ifdef SCTP_USE_ADLER32
2414 static uint32_t
2416 {
2422 /* s1 = (s1 + buf[n]) % BASE */
2423 /* first we add */
2425 /*
2426 * now if we need to, we do a mod by subtracting. It seems a
2427 * bit faster since I really will only ever do one subtract
2428 * at the MOST, since buf[n] is a max of 255.
2429 */
2432 }
2433 /* s2 = (s2 + s1) % BASE */
2434 /* first we add */
2436 /*
2437 * again, it is more efficent (it seems) to subtract since
2438 * the most s2 will ever be is (BASE-1 + BASE-1) in the
2439 * worse case. This would then be (2 * BASE) - 2, which will
2440 * still only do one subtract. On Intel this is much better
2441 * to do this way and avoid the divide. Have not -pg'd on
2442 * sparc.
2443 */
2446 }
2447 }
2448 /* Return the adler32 of the bytes buf[0..len-1] */
2450 }
2452 #endif
2455 uint32_t
2457 {
2465 }
2467 }
2469 #if defined(SCTP_WITH_NO_CSUM)
2471 uint32_t
2473 {
2474 /*
2475 * given a mbuf chain with a packetheader offset by 'offset'
2476 * pointing at a sctphdr (with csum set to 0) go through the chain
2477 * of SCTP_BUF_NEXT()'s and calculate the SCTP checksum. This also
2478 * has a side bonus as it will calculate the total length of the
2479 * mbuf chain. Note: if offset is greater than the total mbuf
2480 * length, checksum=1, pktlen=0 is returned (ie. no real error code)
2481 */
2486 }
2488 #elif defined(SCTP_USE_INCHKSUM)
2490 #include <machine/in_cksum.h>
2492 uint32_t
2494 {
2495 /*
2496 * given a mbuf chain with a packetheader offset by 'offset'
2497 * pointing at a sctphdr (with csum set to 0) go through the chain
2498 * of SCTP_BUF_NEXT()'s and calculate the SCTP checksum. This also
2499 * has a side bonus as it will calculate the total length of the
2500 * mbuf chain. Note: if offset is greater than the total mbuf
2501 * length, checksum=1, pktlen=0 is returned (ie. no real error code)
2502 */
2511 }
2517 }
2519 #else
2521 uint32_t
2523 {
2524 /*
2525 * given a mbuf chain with a packetheader offset by 'offset'
2526 * pointing at a sctphdr (with csum set to 0) go through the chain
2527 * of SCTP_BUF_NEXT()'s and calculate the SCTP checksum. This also
2528 * has a side bonus as it will calculate the total length of the
2529 * mbuf chain. Note: if offset is greater than the total mbuf
2530 * length, checksum=1, pktlen=0 is returned (ie. no real error code)
2531 */
2534 #ifdef SCTP_USE_ADLER32
2537 #else
2540 #endif
2544 /* find the correct mbuf and offset into mbuf */
2547 * left */
2549 }
2552 #ifdef SCTP_USE_ADLER32
2556 #else
2558 /* Use old method if less than 4 bytes */
2566 }
2567 #endif
2569 /* we only offset once into the first mbuf */
2570 }
2574 else
2576 }
2578 }
2581 }
2582 #ifdef SCTP_USE_ADLER32
2583 /* Adler32 */
2585 #else
2586 /* CRC-32c */
2588 #endif
2590 }
2593 #endif
2595 void
2598 {
2599 /*
2600 * Reset the P-MTU size on this association, this involves changing
2601 * the asoc MTU, going through ANY chunk+overhead larger than mtu to
2602 * allow the DF flag to be cleared.
2603 */
2607 #ifdef SCTP_PRINT_FOR_B_AND_M
2610 #endif
2616 }
2622 }
2623 }
2627 }
2628 }
2629 }
2632 /*
2633 * given an association and starting time of the current RTT period return
2634 * RTO in number of msecs net should point to the current network
2635 */
2636 uint32_t
2642 {
2643 /*-
2644 * given an association and the starting time of the current RTT
2645 * period (in value1/value2) return RTO in number of msecs.
2646 */
2653 /* Copy it out for sparc64 */
2660 /* error */
2663 }
2664 /************************/
2665 /* 1. calculate new RTT */
2666 /************************/
2667 /* get the current time */
2669 /* compute the RTT value */
2676 /* Borrow 1,000ms from current calculation */
2678 /* Add in the slop over */
2680 /* Add in the pre-second ms's */
2682 }
2688 /* impossible .. garbage in nothing out */
2691 /*
2692 * We have to have 1 usec :-D this must be the
2693 * loopback.
2694 */
2697 /* impossible .. garbage in nothing out */
2699 }
2701 /* Clock wrapped? */
2703 }
2704 /***************************/
2705 /* 2. update RTTVAR & SRTT */
2706 /***************************/
2708 /* this is Van Jacobson's integer version */
2711 * shift=3 */
2714 }
2717 * shift=3 */
2720 }
2722 * VAR shift=2 */
2726 }
2728 /* First RTO measurment */
2731 * shift=3 */
2735 }
2740 }
2741 }
2742 calc_rto:
2750 }
2751 /* bound it, per C6/C7 in Section 5.3.1 */
2754 }
2757 }
2758 /* we are now returning the RTO */
2760 }
2762 /*
2763 * return a pointer to a contiguous piece of data from the given mbuf chain
2764 * starting at 'off' for 'len' bytes. If the desired piece spans more than
2765 * one mbuf, a copy is made at 'ptr'. caller must ensure that the buffer size
2766 * is >= 'len' returns NULL if there there isn't 'len' bytes in the chain.
2767 */
2768 caddr_t
2770 {
2778 /* find the desired start location */
2784 }
2788 /* is the current mbuf large enough (eg. contiguous)? */
2792 /* else, it spans more than one mbuf, so save a temp copy... */
2800 }
2803 else
2805 }
2806 }
2815 {
2816 /* This just provides a typed signature to Peter's Pull routine */
2819 }
2822 int
2824 {
2825 /*
2826 * add padlen bytes of 0 filled padding to the end of the mbuf. If
2827 * padlen is > 3 this routine will fail.
2828 */
2835 }
2837 /*
2838 * The easy way. We hope the majority of the time we hit
2839 * here :)
2840 */
2844 /* Hard way we must grow the mbuf */
2849 /* Out of space GAK! we are in big trouble. */
2852 }
2853 /* setup and insert in middle */
2858 }
2859 /* zero out the pad */
2862 dp++;
2863 }
2865 }
2867 int
2869 {
2870 /* find the last mbuf in chain and pad it */
2880 }
2882 }
2883 }
2886 }
2890 static void
2893 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)
2894 SCTP_UNUSED
2895 #endif
2896 )
2897 {
2902 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
2905 #endif
2907 /*
2908 * First if we are are going down dump everything we can to the
2909 * socket rcv queue.
2910 */
2916 ) {
2917 /* If the socket is gone we are out of here */
2919 }
2920 /*
2921 * For TCP model AND UDP connected sockets we will send an error up
2922 * when an ABORT comes in.
2923 */
2933 }
2934 /* Wake ANY sleepers */
2935 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
2946 }
2947 }
2948 #endif
2951 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
2954 }
2955 #endif
2956 sctp_asoc_change_wake++;
2957 }
2959 /* event not enabled */
2961 }
2964 /* no space left */
2974 /* XXX verify these stream counts */
2982 m_notify);
2984 /* no memory */
2987 }
2989 /* not that we need this */
2993 control,
2996 /* Wake up any sleeper */
2997 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
3008 }
3009 }
3010 #endif
3012 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
3015 }
3016 #endif
3017 }
3018 }
3020 static void
3023 {
3029 /* event not enabled */
3044 #ifdef INET6
3046 {
3054 /* recover scope_id for user */
3057 /* clear embedded scope_id for user */
3059 }
3060 }
3062 }
3063 #endif
3065 /* TSNH */
3067 }
3075 /* append to socket */
3078 m_notify);
3080 /* no memory */
3083 }
3086 /* not that we need this */
3089 control,
3091 }
3094 static void
3097 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)
3098 SCTP_UNUSED
3099 #endif
3100 )
3101 {
3108 /* event not enabled */
3113 /* no space left */
3122 else
3126 /* not exactly what the user sent in, but should be close :) */
3136 /* Take off the chunk header */
3139 /* trim out any 0 len mbufs */
3145 }
3150 /* Steal off the mbuf */
3152 /*
3153 * For this case, we check the actual socket buffer, since the assoc
3154 * is going away we don't want to overfill the socket buffer for a
3155 * non-reader
3156 */
3160 }
3161 /* append to socket */
3164 m_notify);
3166 /* no memory */
3169 }
3172 control,
3174 }
3177 static void
3180 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)
3181 SCTP_UNUSED
3182 #endif
3183 )
3184 {
3191 /* event not enabled */
3197 /* no space left */
3204 else
3208 /* not exactly what the user sent in, but should be close :) */
3216 }
3224 /* Steal off the mbuf */
3226 /*
3227 * For this case, we check the actual socket buffer, since the assoc
3228 * is going away we don't want to overfill the socket buffer for a
3229 * non-reader
3230 */
3234 }
3235 /* append to socket */
3238 m_notify);
3240 /* no memory */
3243 }
3246 control,
3248 }
3252 static void
3255 {
3261 /* event not enabled */
3264 m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_adaption_event), 0, M_DONTWAIT, 1, MT_DATA);
3266 /* no space left */
3279 /* append to socket */
3282 m_notify);
3284 /* no memory */
3287 }
3290 /* not that we need this */
3293 control,
3295 }
3297 /* This always must be called with the read-queue LOCKED in the INP */
3298 void
3301 {
3309 /* event not enabled */
3314 /* no space left */
3330 m_notify);
3332 /* no memory */
3335 }
3338 /* not that we need this */
3344 }
3347 sctp_sblog(sb, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBALLOC, SCTP_BUF_LEN(m_notify));
3348 }
3352 }
3358 /* we really should not see this case */
3360 }
3363 }
3365 /* This should always be the case */
3367 }
3368 }
3370 static void
3372 {
3377 /*
3378 * For TCP model AND UDP connected sockets we will send an error up
3379 * when an SHUTDOWN completes
3380 */
3383 }
3386 /* mark socket closed for read/write and wakeup! */
3387 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
3399 }
3400 #endif
3403 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
3405 #endif
3406 }
3408 /* event not enabled */
3411 m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_shutdown_event), 0, M_DONTWAIT, 1, MT_DATA);
3413 /* no space left */
3424 /* append to socket */
3427 m_notify);
3429 /* no memory */
3432 }
3435 /* not that we need this */
3438 control,
3440 }
3442 static void
3445 {
3453 }
3455 /* event not enabled */
3460 /* no space left */
3465 /* never enough room */
3468 }
3475 }
3483 }
3484 }
3488 /* no space */
3491 }
3492 /* append to socket */
3495 m_notify);
3497 /* no memory */
3500 }
3503 /* not that we need this */
3506 control,
3508 }
3511 void
3514 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)
3515 SCTP_UNUSED
3516 #endif
3517 )
3518 {
3520 /* unlikely but */
3522 }
3526 ) {
3527 /* No notifications up when we are in a no socket state */
3529 }
3531 /* Can't send up to a closed socket any notifications */
3533 }
3539 /* Don't report these in front states */
3541 }
3542 }
3548 }
3551 }
3557 {
3564 }
3566 {
3573 }
3575 {
3582 }
3592 {
3598 }
3608 }
3626 sctp_notify_stream_reset(stcb, error, ((uint16_t *) data), (SCTP_STRRESET_OUTBOUND_STR | SCTP_STRRESET_FAILED));
3630 sctp_notify_stream_reset(stcb, error, ((uint16_t *) data), (SCTP_STRRESET_INBOUND_STR | SCTP_STRRESET_FAILED));
3635 error);
3639 error);
3643 error);
3656 #if 0
3669 }
3671 void
3673 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)
3674 SCTP_UNUSED
3675 #endif
3676 )
3677 {
3688 }
3693 }
3694 /* now through all the gunk freeing chunks */
3697 }
3698 /* sent queue SHOULD be empty */
3705 /*
3706 * trim off the sctp chunk header(it should
3707 * be there)
3708 */
3713 }
3714 }
3721 }
3723 /* sa_ignore FREED_MEMORY */
3725 }
3726 }
3727 /* pending send queue SHOULD be empty */
3734 /*
3735 * trim off the sctp chunk header(it should
3736 * be there)
3737 */
3742 }
3743 }
3749 }
3751 /* sa_ignore FREED_MEMORY */
3753 }
3754 }
3756 /* For each stream */
3758 /* clean up any sends there */
3770 }
3774 /* Free the chunk */
3776 /* sa_ignore FREED_MEMORY */
3778 }
3779 }
3783 }
3784 }
3786 void
3788 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)
3789 SCTP_UNUSED
3790 #endif
3791 )
3792 {
3796 }
3801 }
3802 /* Tell them we lost the asoc */
3808 }
3810 }
3812 void
3816 {
3819 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
3822 #endif
3826 /* We have a TCB to abort, send notification too */
3829 /* get the assoc vrf id and table id */
3832 }
3835 /* Ok, now lets free it */
3836 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
3843 #endif
3845 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
3847 #endif
3852 SCTP_CALLED_DIRECTLY_NOCMPSET);
3853 }
3854 }
3855 }
3856 }
3858 #ifdef SCTP_ASOCLOG_OF_TSNS
3859 void
3861 {
3862 #ifdef NOSIY_PRINTS
3870 }
3879 }
3880 }
3889 }
3890 }
3891 none_in:
3896 }
3905 }
3906 }
3915 }
3916 }
3917 #endif
3918 }
3920 #endif
3922 void
3925 int so_locked
3926 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)
3927 SCTP_UNUSED
3928 #endif
3929 )
3930 {
3933 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
3936 #endif
3938 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
3940 #endif
3942 /* Got to have a TCB */
3946 SCTP_CALLED_DIRECTLY_NOCMPSET);
3947 }
3948 }
3952 }
3954 /* notify the ulp */
3957 /* notify the peer */
3958 #if defined(SCTP_PANIC_ON_ABORT)
3960 #endif
3966 }
3967 /* now free the asoc */
3968 #ifdef SCTP_ASOCLOG_OF_TSNS
3970 #endif
3971 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
3978 }
3979 #endif
3981 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
3984 }
3985 #endif
3986 }
3988 void
3991 {
3996 /* Generate a TO address for future reference */
4000 SCTP_CALLED_DIRECTLY_NOCMPSET);
4001 }
4002 }
4008 /* break to abort land */
4010 }
4013 /* We hit here only if the assoc is being freed */
4016 /* we don't respond to pkt-dropped */
4019 /* we don't respond with an ABORT to an ABORT */
4022 /*
4023 * we ignore it since we are not waiting for it and
4024 * peer is gone
4025 */
4032 }
4036 }
4038 }
4040 /*
4041 * check the inbound datagram to make sure there is not an abort inside it,
4042 * if there is return 1, else return 0.
4043 */
4044 int
4046 {
4058 /* packet is probably corrupt */
4060 }
4061 /* we seem to be ok, is it an abort? */
4063 /* yep, tell them */
4065 }
4067 /* need to update the Vtag */
4072 }
4073 }
4074 /* Nope, move to the next chunk */
4078 }
4080 }
4082 /*
4083 * currently (2/02), ifa_addr embeds scope_id's and don't have sin6_scope_id
4084 * set (i.e. it's 0) so, create this function to compare link local scopes
4085 */
4086 #ifdef INET6
4087 uint32_t
4089 {
4092 /* save copies */
4098 /* can't get scope, so can't match */
4100 }
4103 /* can't get scope, so can't match */
4105 }
4110 }
4112 /*
4113 * returns a sockaddr_in6 with embedded scope recovered and removed
4114 */
4117 {
4118 /* check and strip embedded scope junk */
4124 /* use the recovered scope */
4126 }
4128 /* else, return the original "to" addr */
4130 }
4131 }
4132 }
4134 }
4136 #endif
4138 /*
4139 * are the two addresses the same? currently a "scopeless" check returns: 1
4140 * if same, 0 if not
4141 */
4142 int
4144 {
4146 /* must be valid */
4150 /* must be the same family */
4155 #ifdef INET6
4157 {
4158 /* IPv6 addresses */
4164 sin6_2));
4165 }
4166 #endif
4168 {
4169 /* IPv4 addresses */
4175 }
4177 /* we don't do these... */
4179 }
4180 }
4182 void
4184 {
4185 #ifdef INET6
4189 #endif
4192 #ifdef INET6
4194 {
4203 }
4204 #endif
4206 {
4215 }
4219 }
4220 }
4222 void
4224 {
4227 {
4245 }
4246 #ifdef INET6
4248 {
4268 }
4269 #endif
4271 /* TSNH */
4273 }
4274 }
4276 void
4281 {
4282 /*
4283 * go through our old INP and pull off any control structures that
4284 * belong to stcb and move then to the new inp.
4285 */
4297 /*
4298 * Gak, can't get sblock, we have a problem. data will be
4299 * left stranded.. and we don't dare look at it since the
4300 * other thread may be reading something. Oh well, its a
4301 * screwed up app that does a peeloff OR a accept while
4302 * reading from the main socket... actually its only the
4303 * peeloff() case, since I think read will fail on a
4304 * listening socket..
4305 */
4307 }
4308 /* lock the socket buffers */
4311 /* Pull off all for out target stcb */
4315 /* remove it we want it */
4321 sctp_sblog(&old_so->so_rcv, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBFREE, SCTP_BUF_LEN(m));
4322 }
4326 }
4328 }
4329 }
4331 }
4333 /* Remove the sb-lock on the old socket */
4336 /* Now we move them over to the new socket buffer */
4345 sctp_sblog(&new_so->so_rcv, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBALLOC, SCTP_BUF_LEN(m));
4346 }
4350 }
4352 }
4354 }
4356 }
4359 void
4365 int so_locked
4366 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)
4367 SCTP_UNUSED
4368 #endif
4369 )
4370 {
4371 /*
4372 * Here we must place the control on the end of the socket read
4373 * queue AND increment sb_cc so that select will work properly on
4374 * read.
4375 */
4379 /* Gak, TSNH!! */
4380 #ifdef INVARIANTS
4382 #endif
4384 }
4390 }
4391 }
4397 /* Skip mbufs with NO length */
4399 /* First one */
4405 }
4408 }
4410 }
4414 }
4418 }
4421 }
4425 /* Everything got collapsed out?? */
4427 }
4430 }
4437 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
4450 }
4451 }
4452 #endif
4454 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
4457 }
4458 #endif
4459 }
4460 }
4461 }
4464 int
4472 {
4473 /*
4474 * A partial delivery API event is underway. OR we are appending on
4475 * the reassembly queue.
4476 *
4477 * If PDAPI this means we need to add m to the end of the data.
4478 * Increase the length in the control AND increment the sb_cc.
4479 * Otherwise sb is NULL and all we need to do is put it at the end
4480 * of the mbuf chain.
4481 */
4487 }
4489 get_out:
4492 }
4494 }
4496 /* huh this one is complete? */
4498 }
4502 }
4505 /* Skip mbufs with NO lenght */
4507 /* First one */
4513 }
4515 }
4521 }
4525 }
4526 }
4528 }
4532 /* Really there should always be a prev */
4534 /* Huh nothing left? */
4535 #ifdef INVARIANTS
4537 #else
4539 #endif
4540 }
4542 }
4544 /* append */
4548 /* nothing there */
4549 #ifdef INVARIANTS
4552 }
4553 #endif
4556 }
4559 /* message is complete */
4562 }
4565 }
4568 }
4569 /*
4570 * When we are appending in partial delivery, the cum-ack is used
4571 * for the actual pd-api highest tsn on this mbuf. The true cum-ack
4572 * is populated in the outbound sinfo structure from the true cumack
4573 * if the association exists...
4574 */
4578 }
4583 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
4595 }
4596 #endif
4598 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
4600 #endif
4601 }
4602 }
4604 }
4608 /*************HOLD THIS COMMENT FOR PATCH FILE OF
4609 *************ALTERNATE ROUTING CODE
4610 */
4612 /*************HOLD THIS COMMENT FOR END OF PATCH FILE OF
4613 *************ALTERNATE ROUTING CODE
4614 */
4618 {
4619 /* Return a MBUF with a invalid mandatory parameter */
4630 }
4632 }
4634 #ifdef SCTP_MBCNT_LOGGING
4635 void
4638 {
4641 }
4649 }
4654 }
4663 }
4664 }
4665 }
4667 #endif
4669 int
4672 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)
4673 SCTP_UNUSED
4674 #endif
4675 )
4676 {
4685 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
4688 #endif
4693 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
4702 /*
4703 * assoc was freed while we were
4704 * unlocked
4705 */
4708 }
4709 }
4710 #endif
4712 #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)
4715 }
4716 #endif
4717 }
4720 }
4723 /* on to the sent queue */
4725 sctp_next);
4727 }
4729 SCTP_DATA_NOT_FRAG) {
4730 /* not frag'ed we ae done */
4734 /* end of frag, we are done */
4738 /*
4739 * Its a begin or middle piece, we must mark all of
4740 * it
4741 */
4744 }
4747 /*
4748 * The multi-part message was scattered across the send and
4749 * sent queue.
4750 */
4752 /*
4753 * recurse throught the send_queue too, starting at the
4754 * beginning.
4755 */
4761 }
4762 }
4764 }
4766 /*
4767 * checks to see if the given address, sa, is one that is currently known by
4768 * the kernel note: can't distinguish the same address on multiple interfaces
4769 * and doesn't handle multiple addresses with different zone/scope id's note:
4770 * ifa_ifwithaddr() compares the entire sockaddr struct
4771 */
4775 {
4780 }
4789 /* found him. */
4792 }
4795 }
4796 }
4797 #ifdef INET6
4801 /* found him. */
4804 }
4807 }
4808 }
4809 #endif
4810 }
4813 }
4815 }
4817 uint32_t
4819 {
4836 }
4838 }
4842 {
4853 stage_right:
4857 }
4871 }
4874 #ifdef INVARIANTS
4877 #else
4880 #endif
4881 }
4887 /* found him. */
4892 }
4893 }
4894 #ifdef INET6
4898 /* found him. */
4903 }
4904 }
4905 #endif
4906 }
4910 }
4912 static void
4915 {
4916 /* User pulled some data, do we need a rwnd update? */
4927 SCTP_STATE_SHUTDOWN_RECEIVED |
4928 SCTP_STATE_SHUTDOWN_ACK_SENT)) {
4929 /* Pre-check If we are freeing no update */
4931 }
4936 }
4940 }
4942 /* Have you have freed enough to look */
4944 /* Yep, its worth a look and the lock overhead */
4946 /* Figure out what the rwnd would be */
4952 }
4957 }
4959 /*
4960 * One last check before we allow the guy possibly
4961 * to get in. There is a race, where the guy has not
4962 * reached the gate. In that case
4963 */
4965 }
4968 /* No reports here */
4971 }
4976 /* make sure no timer is running */
4977 sctp_timer_stop(SCTP_TIMER_TYPE_RECV, stcb->sctp_ep, stcb, NULL, SCTP_FROM_SCTPUTIL + SCTP_LOC_6);
4980 /* Update how much we have pending */
4982 }
4983 out:
4986 }
4988 no_lock:
4991 }
4993 int
5002 {
5003 /*
5004 * MSG flags we will look at MSG_DONTWAIT - non-blocking IO.
5005 * MSG_PEEK - Look don't touch :-D (only valid with OUT mbuf copy
5006 * mp=NULL thus uio is the copy method to userland) MSG_WAITALL - ??
5007 * On the way out we may send out any combination of:
5008 * MSG_NOTIFICATION MSG_EOR
5009 *
5010 */
5035 }
5042 }
5045 /* Pull in and set up our int flags */
5047 /* Out of band's NOT supported */
5049 }
5053 }
5055 | MSG_NBIO
5056 )) ||
5059 }
5060 /* setup the endpoint */
5065 }
5067 /* Must be at least a MTU's worth */
5074 }
5078 }
5083 }
5084 restart:
5087 restart_nosblocks:
5091 }
5095 }
5105 /* indicate EOF */
5108 }
5109 }
5110 }
5112 /* we need to wait for data */
5117 /*
5118 * For active open side clear flags for
5119 * re-use passive open is blocked by
5120 * connect.
5121 */
5123 /*
5124 * You were aborted, passive side
5125 * always hits here
5126 */
5129 /*
5130 * You get this once if you are
5131 * active open side
5132 */
5134 /*
5135 * Remove flag if on the
5136 * active open side
5137 */
5139 }
5140 }
5142 SS_ISDISCONNECTING |
5143 SS_ISCONFIRMING |
5144 SS_ISCONNECTED);
5151 }
5152 }
5154 }
5155 }
5159 }
5171 /*
5172 * For active open side clear flags
5173 * for re-use passive open is
5174 * blocked by connect.
5175 */
5177 /*
5178 * You were aborted, passive
5179 * side always hits here
5180 */
5183 /*
5184 * You get this once if you
5185 * are active open side
5186 */
5188 /*
5189 * Remove flag if on
5190 * the active open
5191 * side
5192 */
5194 }
5195 }
5197 SS_ISDISCONNECTING |
5198 SS_ISCONFIRMING |
5199 SS_ISCONNECTED);
5206 }
5207 }
5209 }
5210 }
5213 }
5215 }
5219 }
5220 /* we possibly have data we can read */
5221 /* sa_ignore FREED_MEMORY */
5224 /*
5225 * This could be happening since the appender did the
5226 * increment but as not yet did the tailq insert onto the
5227 * read_queue
5228 */
5232 }
5235 #ifdef INVARIANTS
5237 #endif
5239 }
5243 }
5246 /*
5247 * Clean up code for freeing assoc that left behind a
5248 * pdapi.. maybe a peer in EEOR that just closed after
5249 * sending and never indicated a EOR.
5250 */
5254 }
5257 /* Hmm there is data here .. fix */
5267 }
5269 }
5272 /* remove it */
5274 /* Add back any hiddend data */
5277 }
5281 }
5283 }
5287 /* find a more suitable one then this */
5295 ) {
5296 /*-
5297 * If we have a different TCB next, and there is data
5298 * present. If we have already taken some (pdapi), OR we can
5299 * ref the tcb and no delivery as started on this stream, we
5300 * take it. Note we allow a notification on a different
5301 * assoc to be delivered..
5302 */
5311 ) {
5312 /*-
5313 * If we have the same tcb, and there is data present, and we
5314 * have the strm interleave feature present. Then if we have
5315 * taken some (pdapi) or we can refer to tht tcb AND we have
5316 * not started a delivery for this stream, we can take it.
5317 * Note we do NOT allow a notificaiton on the same assoc to
5318 * be delivered.
5319 */
5322 }
5324 }
5325 }
5326 /*
5327 * if we reach here, not suitable replacement is available
5328 * <or> fragment interleave is NOT on. So stuff the sb_cc
5329 * into the our held count, and its time to sleep again.
5330 */
5334 }
5335 /* Clear the held length since there is something to read */
5340 }
5341 found_one:
5342 /*
5343 * If we reach here, control has a some data for us to read off.
5344 * Note that stcb COULD be NULL.
5345 */
5350 }
5358 /* you can't free it on me please */
5359 /*
5360 * The lock on the socket buffer protects us so the
5361 * free code will stop. But since we used the
5362 * socketbuf lock and the sender uses the tcb_lock
5363 * to increment, we need to use the atomic add to
5364 * the refcnt
5365 */
5367 #ifdef INVARIANTS
5369 #else
5371 #endif
5375 }
5376 /*
5377 * Setup to remember how much we have not yet told
5378 * the peer our rwnd has opened up. Note we grab the
5379 * value from the tcb from last time. Note too that
5380 * sack sending clears this when a sack is sent,
5381 * which is fine. Once we hit the rwnd_req, we then
5382 * will go to the sctp_user_rcvd() that will not
5383 * lock until it KNOWs it MUST send a WUP-SACK.
5384 */
5387 }
5388 }
5393 }
5394 /* First lets get off the sinfo and sockaddr info */
5407 }
5410 }
5418 }
5419 }
5421 /*
5422 * we explicitly 0 this, since the memcpy
5423 * got some other things beyond the older
5424 * sinfo_ that is on the control's structure
5425 * :-D
5426 */
5433 }
5434 }
5435 /*
5436 * update off the real current cum-ack, if we have an stcb.
5437 */
5440 /*
5441 * mask off the high bits, we keep the actual chunk bits in
5442 * there.
5443 */
5447 }
5448 }
5449 #ifdef SCTP_ASOCLOG_OF_TSNS
5450 {
5459 }
5467 }
5468 #endif
5472 #ifdef INET
5476 #else
5477 /* No AF_INET use AF_INET6 */
5481 #endif
5484 #if defined(INET) && defined(INET6)
5501 }
5502 #endif
5503 #if defined(INET6)
5504 {
5509 }
5510 #endif
5511 }
5512 /* now copy out what data we can */
5514 /* copy out each mbuf in the chain up to length */
5515 get_more_data:
5518 /* Move out all we can */
5522 /* not enough in this buf */
5524 }
5528 }
5531 /* re-read */
5534 }
5538 }
5540 /* error we are out of here */
5542 }
5548 ) {
5551 }
5558 }
5561 }
5562 /* we ate up the mbuf */
5564 /* just looking */
5568 /* dispose of the mbuf */
5572 }
5577 }
5585 /*
5586 * been through it all, must hold sb
5587 * lock ok to null tail
5588 */
5590 #ifdef INVARIANTS
5593 /*
5594 * If the end is not
5595 * added, OR the
5596 * next is NOT null
5597 * we MUST have the
5598 * lock.
5599 */
5602 }
5603 }
5604 #endif
5606 #ifdef INVARIANTS
5609 }
5610 #endif
5611 }
5612 }
5614 /* Do we need to trim the mbuf? */
5617 }
5623 }
5626 stcb) {
5628 }
5636 }
5640 }
5641 }
5644 }
5649 }
5651 /*
5652 * At this point we have looked at it all and we either have
5653 * a MSG_EOR/or read all the user wants... <OR>
5654 * control->length == 0.
5655 */
5657 /* we are done with this control */
5660 #ifdef INVARIANTS
5662 #else
5666 #endif
5667 }
5668 done_with_control:
5670 /*
5671 * If we don't have a next we need a
5672 * lock, if there is a next
5673 * interrupt is filling ahead of us
5674 * and we don't need a lock to
5675 * remove this guy (which is the
5676 * head of the queue).
5677 */
5681 }
5682 }
5684 /* Add back any hiddend data */
5689 }
5693 }
5704 /*
5705 * The user did not read all of this
5706 * message, turn off the returned MSG_EOR
5707 * since we are leaving more behind on the
5708 * control to read.
5709 */
5710 #ifdef INVARIANTS
5715 }
5716 #endif
5719 }
5720 }
5723 }
5726 ) {
5728 }
5729 /*
5730 * If I hit here the receiver wants more and this message is
5731 * NOT done (pd-api). So two questions. Can we block? if not
5732 * we are done. Did the user NOT set MSG_WAITALL?
5733 */
5736 }
5737 /*
5738 * We need to wait for more data a few things: - We don't
5739 * sbunlock() so we don't get someone else reading. - We
5740 * must be sure to account for the case where what is added
5741 * is NOT to our control when we wakeup.
5742 */
5744 /*
5745 * Do we need to tell the transport a rwnd update might be
5746 * needed before we go to sleep?
5747 */
5753 }
5754 wait_some_more:
5757 }
5764 }
5768 }
5771 ) {
5773 }
5778 }
5780 }
5784 }
5786 /* still nothing here */
5788 /* he aborted, or is done i.e.did a shutdown */
5798 }
5800 }
5804 }
5807 /*
5808 * we must re-sync since data is probably being
5809 * added
5810 */
5813 /*
5814 * big trouble.. we have the lock and its
5815 * corrupt?
5816 */
5817 #ifdef INVARIANTS
5819 #endif
5825 }
5827 /* We will fall around to get more data */
5828 }
5831 /*-
5832 * Give caller back the mbuf chain,
5833 * store in uio_resid the length
5834 */
5838 /* Need to get rlock */
5842 }
5843 }
5848 }
5851 }
5859 }
5866 }
5868 }
5872 /* Done with this control */
5874 }
5875 }
5876 release:
5880 }
5884 }
5888 release_unlocked:
5892 }
5898 }
5901 out:
5910 }
5914 }
5918 }
5921 }
5923 /*
5924 * The lock on the socket buffer protects us so the free
5925 * code will stop. But since we used the socketbuf lock and
5926 * the sender uses the tcb_lock to increment, we need to use
5927 * the atomic add to the refcnt.
5928 */
5930 #ifdef INVARIANTS
5933 #else
5935 #endif
5936 }
5939 /* Save the value back for next time */
5941 }
5945 freed_so_far,
5951 freed_so_far,
5955 }
5956 }
5957 stage_left:
5960 }
5962 }
5965 #ifdef SCTP_MBUF_LOGGING
5968 {
5972 }
5973 }
5975 }
5977 void
5979 {
5982 }
5984 #endif
5986 int
5988 {
5989 /*
5990 * Given a local address. For all associations that holds the
5991 * address, request a peer-set-primary.
5992 */
6000 }
6001 /*
6002 * Now that we have the ifa we must awaken the iterator with this
6003 * message.
6004 */
6009 }
6010 /* Now incr the count and int wi structure */
6018 /* Now add it to the work queue */
6020 /*
6021 * Should this really be a tailq? As it is we will process the
6022 * newest first :-0
6023 */
6031 }
6034 int
6041 {
6050 /* pickup the assoc we are reading from */
6054 }
6056 SCTP_PCB_FLAGS_RECVDATAIOEVNT)) ||
6058 /* user does not want the sndrcv ctl */
6060 }
6068 }
6073 /* copy back the sinfo in a CMSG format */
6077 else
6079 }
6081 /* copy back the address info */
6086 }
6087 }
6089 }
6092 int
6099 {
6108 /* pickup the assoc we are reading from */
6112 }
6114 SCTP_PCB_FLAGS_RECVDATAIOEVNT)) ||
6116 /* user does not want the sndrcv ctl */
6118 }
6126 }
6132 filling_sinfo);
6134 /*
6135 * copy back the sinfo in a CMSG format note that the caller
6136 * has reponsibility for freeing the memory.
6137 */
6140 controllen,
6142 }
6144 /* copy back the address info */
6149 }
6150 }
6152 }
6160 int
6163 {
6177 /* assoc gone no un-lock */
6182 }
6183 added++;
6187 /* assoc gone no un-lock */
6192 }
6193 added++;
6194 }
6196 }
6197 out_now:
6199 }
6205 {
6213 /* account and validate addresses */
6223 }
6229 /* Must be non-mapped for connectx */
6234 }
6242 }
6245 /* we are done */
6247 }
6251 /* Already have or am bring up an association */
6255 }
6259 }
6261 }
6263 }
6265 /*
6266 * sctp_bindx(ADD) for one address.
6267 * assumes all arguments are valid/checked by caller.
6268 */
6269 void
6273 {
6276 #ifdef INET6
6279 #endif
6281 /* see if we're bound all already! */
6286 }
6296 }
6298 /* can only bind v6 on PF_INET6 sockets */
6302 }
6307 /* can't bind v4-mapped on PF_INET sockets */
6311 }
6314 }
6315 }
6316 #endif
6322 }
6325 /* can't bind v4 on PF_INET sockets */
6329 }
6330 }
6333 /* Can't get proc for Net/Open BSD */
6337 }
6340 }
6341 /*
6342 * No locks required here since bind and mgmt_ep_sa all do their own
6343 * locking. If we do something for the FIX: below we may need to
6344 * lock in that case.
6345 */
6347 /* add the address */
6351 /* validate the incoming port */
6358 /* user specified 0 port, set it to existing port */
6360 }
6364 /*
6365 * We must decrement the refcount since we have the
6366 * ep already and are binding. No remove going on
6367 * here.
6368 */
6370 }
6372 /* already bound to it.. ok */
6377 SCTP_ADD_IP_ADDRESS,
6381 }
6385 /*
6386 * FIX: decide whether we allow assoc based bindx
6387 */
6388 }
6389 }
6391 /*
6392 * sctp_bindx(DELETE) for one address.
6393 * assumes all arguments are valid/checked by caller.
6394 */
6395 void
6399 {
6402 #ifdef INET6
6405 #endif
6407 /* see if we're bound all already! */
6412 }
6422 }
6424 /* can only bind v6 on PF_INET6 sockets */
6428 }
6433 /* can't bind mapped-v4 on PF_INET sockets */
6437 }
6440 }
6441 }
6442 #endif
6448 }
6451 /* can't bind v4 on PF_INET sockets */
6455 }
6456 }
6457 /*
6458 * No lock required mgmt_ep_sa does its own locking. If the FIX:
6459 * below is ever changed we may need to lock before calling
6460 * association level binding.
6461 */
6463 /* delete the address */
6465 SCTP_DEL_IP_ADDRESS,
6468 /*
6469 * FIX: decide whether we allow assoc based bindx
6470 */
6471 }
6472 }
6474 /*
6475 * returns the valid local address count for an assoc, taking into account
6476 * all scoping rules
6477 */
6478 int
6480 {
6488 /* Turn on all the appropriate scopes */
6498 }
6501 }
6506 /* no vrf, no addresses */
6509 }
6511 /*
6512 * bound all case: go through all ifns on the vrf
6513 */
6518 }
6529 /*
6530 * skip unspecified
6531 * addrs
6532 */
6534 }
6538 }
6539 /* count this one */
6540 count++;
6543 }
6545 #ifdef INET6
6553 }
6559 /*
6560 *
6561 * bad
6562 *
6563 * li
6564 * nk
6565 *
6566 * loc
6567 * al
6568 *
6569 * add
6570 * re
6571 * ss
6572 * */
6574 }
6575 }
6579 }
6580 /* count this one */
6581 count++;
6582 }
6584 #endif
6586 /* TSNH */
6588 }
6589 }
6590 }
6592 /*
6593 * subset bound case
6594 */
6598 sctp_nxt_addr) {
6601 }
6602 /* count this one */
6603 count++;
6604 }
6605 }
6608 }
6610 #if defined(SCTP_LOCAL_TRACE_BUF)
6612 void
6613 sctp_log_trace(uint32_t subsys, const char *str SCTP_UNUSED, uint32_t a, uint32_t b, uint32_t c, uint32_t d, uint32_t e, uint32_t f)
6614 {
6623 }
6627 }
6636 }
6638 #endif
6639 /* We will need to add support
6640 * to bind the ports and such here
6641 * so we can do UDP tunneling. In
6642 * the mean-time, we return error
6643 */
6645 void
6647 {
6649 }
6650 int
6652 {
6654 }