Lines Matching defs:stcb
696 sctp_does_stcb_own_this_addr(struct sctp_tcb *stcb, struct sockaddr *to)
709 loopback_scope = stcb->asoc.scope.loopback_scope;
711 ipv4_local_scope = stcb->asoc.scope.ipv4_local_scope;
712 ipv4_addr_legal = stcb->asoc.scope.ipv4_addr_legal;
715 local_scope = stcb->asoc.scope.local_scope;
716 site_scope = stcb->asoc.scope.site_scope;
717 ipv6_addr_legal = stcb->asoc.scope.ipv6_addr_legal;
721 vrf = sctp_find_vrf(stcb->asoc.vrf_id);
728 if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
735 if (sctp_is_addr_restricted(stcb, sctp_ifa) &&
736 (!sctp_is_addr_pending(stcb, sctp_ifa))) {
760 if (prison_check_ip4(stcb->sctp_ep->ip_inp.inp.inp_cred,
779 if (prison_check_ip6(stcb->sctp_ep->ip_inp.inp.inp_cred,
811 LIST_FOREACH(laddr, &stcb->sctp_ep->sctp_addr_list, sctp_nxt_addr) {
816 if (sctp_is_addr_restricted(stcb, laddr->ifa) &&
817 (!sctp_is_addr_pending(stcb, laddr->ifa))) {
881 struct sctp_tcb *stcb;
1026 stcb = LIST_FIRST(&inp->sctp_asoc_list);
1027 if (stcb == NULL) {
1031 SCTP_TCB_LOCK(stcb);
1032 if (!sctp_does_stcb_own_this_addr(stcb, to)) {
1033 SCTP_TCB_UNLOCK(stcb);
1037 if (stcb->rport != rport) {
1039 SCTP_TCB_UNLOCK(stcb);
1043 if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {
1044 SCTP_TCB_UNLOCK(stcb);
1048 if (!sctp_does_stcb_own_this_addr(stcb, to)) {
1049 SCTP_TCB_UNLOCK(stcb);
1054 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
1079 return (stcb);
1103 return (stcb);
1113 SCTP_TCB_UNLOCK(stcb);
1123 * stcb, both will be locked (locked_tcb and stcb) but decrement will be done
1134 struct sctp_tcb *stcb = NULL;
1173 stcb = sctp_tcb_special_locate(inp_p, remote, local,
1175 if ((stcb != NULL) && (locked_tcb == NULL)) {
1179 if ((locked_tcb != NULL) && (locked_tcb != stcb)) {
1186 return (stcb);
1192 stcb = LIST_FIRST(&inp->sctp_asoc_list);
1193 if (stcb == NULL) {
1196 SCTP_TCB_LOCK(stcb);
1198 if (stcb->rport != rport) {
1200 SCTP_TCB_UNLOCK(stcb);
1203 if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {
1204 SCTP_TCB_UNLOCK(stcb);
1207 if (local && !sctp_does_stcb_own_this_addr(stcb, local)) {
1208 SCTP_TCB_UNLOCK(stcb);
1212 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
1241 } else if (locked_tcb != stcb) {
1250 return (stcb);
1271 } else if (locked_tcb != stcb) {
1279 return (stcb);
1289 SCTP_TCB_UNLOCK(stcb);
1298 LIST_FOREACH(stcb, head, sctp_tcbhash) {
1299 if (stcb->rport != rport) {
1303 SCTP_TCB_LOCK(stcb);
1304 if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {
1305 SCTP_TCB_UNLOCK(stcb);
1308 if (local && !sctp_does_stcb_own_this_addr(stcb, local)) {
1309 SCTP_TCB_UNLOCK(stcb);
1313 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
1342 } else if (locked_tcb != stcb) {
1350 return (stcb);
1372 } else if (locked_tcb != stcb) {
1380 return (stcb);
1390 SCTP_TCB_UNLOCK(stcb);
1416 struct sctp_tcb *stcb;
1430 LIST_FOREACH(stcb, head, sctp_tcbasocidhash) {
1431 if (stcb->asoc.assoc_id == id) {
1432 if (inp != stcb->sctp_ep) {
1440 if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {
1444 SCTP_TCB_LOCK(stcb);
1446 return (stcb);
1455 struct sctp_tcb *stcb;
1458 stcb = sctp_findasoc_ep_asocid_locked(inp, asoc_id, want_lock);
1460 return (stcb);
1844 struct sctp_tcb *stcb;
1849 stcb = sctp_tcb_special_locate(inp_p, from, to, netp,
1852 stcb = sctp_tcb_special_locate(&inp, from, to, netp,
1855 if (stcb != NULL) {
1857 return (stcb);
1875 stcb = sctp_findassociation_ep_addr(inp_p, from, netp, to,
1878 stcb = sctp_findassociation_ep_addr(&inp, from, netp, to,
1881 return (stcb);
1896 struct sctp_tcb *stcb;
1946 stcb = sctp_findassociation_ep_addr(inp_p,
1948 if (stcb != NULL) {
1949 return (stcb);
1967 stcb = sctp_findassociation_ep_addr(inp_p,
1969 if (stcb != NULL) {
1970 return (stcb);
1993 struct sctp_tcb *stcb;
1998 LIST_FOREACH(stcb, head, sctp_asocs) {
1999 SCTP_INP_RLOCK(stcb->sctp_ep);
2000 if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) {
2001 SCTP_INP_RUNLOCK(stcb->sctp_ep);
2004 if (stcb->sctp_ep->def_vrf_id != vrf_id) {
2005 SCTP_INP_RUNLOCK(stcb->sctp_ep);
2008 SCTP_TCB_LOCK(stcb);
2009 SCTP_INP_RUNLOCK(stcb->sctp_ep);
2010 if (stcb->asoc.my_vtag == vtag) {
2012 if (stcb->rport != rport) {
2013 SCTP_TCB_UNLOCK(stcb);
2016 if (stcb->sctp_ep->sctp_lport != lport) {
2017 SCTP_TCB_UNLOCK(stcb);
2020 if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {
2021 SCTP_TCB_UNLOCK(stcb);
2025 if (sctp_does_stcb_own_this_addr(stcb, to) == 0) {
2027 SCTP_TCB_UNLOCK(stcb);
2035 if (stcb->asoc.peer_vtag == remote_tag) {
2047 *netp = sctp_findnet(stcb, from);
2052 *inp_p = stcb->sctp_ep;
2054 return (stcb);
2056 net = sctp_findnet(stcb, from);
2061 *inp_p = stcb->sctp_ep;
2063 return (stcb);
2072 SCTP_TCB_UNLOCK(stcb);
2088 struct sctp_tcb *stcb;
2093 stcb = sctp_findassoc_by_vtag(src, dst, ntohl(sh->v_tag),
2095 if (stcb) {
2096 return (stcb);
2101 stcb = sctp_findassociation_addr_sa(src, dst, inp_p, netp,
2105 stcb = sctp_findassociation_addr_sa(src, dst, &inp, netp,
2108 SCTPDBG(SCTP_DEBUG_PCB1, "stcb:%p inp:%p\n", (void *)stcb, (void *)inp);
2109 if (stcb == NULL && inp) {
2127 stcb = sctp_findassociation_special_addr(m,
2134 SCTPDBG(SCTP_DEBUG_PCB1, "stcb is %p\n", (void *)stcb);
2135 return (stcb);
2147 struct sctp_tcb *stcb;
2230 stcb = sctp_findassoc_by_vtag(NULL, dst, ntohl(sh->v_tag), inp_p,
2232 if (stcb != NULL) {
2236 stcb = sctp_findassociation_ep_addr(inp_p,
2240 return (stcb);
2482 struct sctp_tcb *stcb)
2489 atomic_add_int(&stcb->asoc.refcnt, 1);
2490 SCTP_TCB_UNLOCK(stcb);
2494 SCTP_TCB_LOCK(stcb);
2495 atomic_subtract_int(&stcb->asoc.refcnt, 1);
2525 stcb->sctp_socket = new_inp->sctp_socket;
2526 stcb->sctp_ep = new_inp;
2530 rport = stcb->rport;
2532 LIST_REMOVE(stcb, sctp_tcbhash);
2533 LIST_REMOVE(stcb, sctp_tcblist);
2534 if (stcb->asoc.in_asocid_hash) {
2535 LIST_REMOVE(stcb, sctp_tcbasocidhash);
2545 LIST_INSERT_HEAD(&new_inp->sctp_asoc_list, stcb, sctp_tcblist);
2551 if (stcb->asoc.in_asocid_hash) {
2554 lhd = &new_inp->sctp_asocidhash[SCTP_PCBHASH_ASOC(stcb->asoc.assoc_id,
2556 LIST_INSERT_HEAD(lhd, stcb, sctp_tcbasocidhash);
2559 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
2561 stcb, net);
2590 if (oladdr == stcb->asoc.last_used_address) {
2591 stcb->asoc.last_used_address = laddr;
2596 if (stcb->asoc.dack_timer.ep == old_inp) {
2598 stcb->asoc.dack_timer.ep = new_inp;
2601 if (stcb->asoc.asconf_timer.ep == old_inp) {
2603 stcb->asoc.asconf_timer.ep = new_inp;
2606 if (stcb->asoc.strreset_timer.ep == old_inp) {
2608 stcb->asoc.strreset_timer.ep = new_inp;
2611 if (stcb->asoc.shut_guard_timer.ep == old_inp) {
2613 stcb->asoc.shut_guard_timer.ep = new_inp;
2616 if (stcb->asoc.autoclose_timer.ep == old_inp) {
2618 stcb->asoc.autoclose_timer.ep = new_inp;
2621 if (stcb->asoc.delete_prim_timer.ep == old_inp) {
2623 stcb->asoc.delete_prim_timer.ep = new_inp;
2627 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
3131 * reference on the stcb and inp. We can mark it and it will
3192 struct sctp_tcb *stcb, *nstcb;
3243 LIST_FOREACH_SAFE(stcb, &inp->sctp_asoc_list, sctp_tcblist, nstcb) {
3244 SCTP_TCB_LOCK(stcb);
3246 stcb->sctp_socket = NULL;
3247 SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_CLOSED_SOCKET);
3248 if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {
3251 if (stcb->asoc.state & SCTP_STATE_IN_ACCEPT_QUEUE) {
3258 SCTP_CLEAR_SUBSTATE(stcb, SCTP_STATE_IN_ACCEPT_QUEUE);
3259 sctp_timer_start(SCTP_TIMER_TYPE_ASOCKILL, inp, stcb, NULL);
3261 SCTP_TCB_UNLOCK(stcb);
3264 if (((SCTP_GET_STATE(stcb) == SCTP_STATE_COOKIE_WAIT) ||
3265 (SCTP_GET_STATE(stcb) == SCTP_STATE_COOKIE_ECHOED)) &&
3266 (stcb->asoc.total_output_queue_size == 0)) {
3274 if (sctp_free_assoc(inp, stcb, SCTP_PCBFREE_NOFORCE,
3280 if ((stcb->asoc.size_on_reasm_queue > 0) ||
3281 (stcb->asoc.size_on_all_streams > 0) ||
3287 stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_PCB + SCTP_LOC_3;
3288 sctp_send_abort_tcb(stcb, op_err, SCTP_SO_LOCKED);
3290 if ((SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) ||
3291 (SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_RECEIVED)) {
3294 if (sctp_free_assoc(inp, stcb,
3299 } else if (TAILQ_EMPTY(&stcb->asoc.send_queue) &&
3300 TAILQ_EMPTY(&stcb->asoc.sent_queue) &&
3301 (stcb->asoc.stream_queue_cnt == 0)) {
3302 if ((*stcb->asoc.ss_functions.sctp_ss_is_user_msgs_incomplete) (stcb, &stcb->asoc)) {
3305 if ((SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_SENT) &&
3306 (SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_ACK_SENT)) {
3313 if ((SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) ||
3314 (SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_RECEIVED)) {
3317 SCTP_SET_STATE(stcb, SCTP_STATE_SHUTDOWN_SENT);
3318 sctp_stop_timers_for_shutdown(stcb);
3319 if (stcb->asoc.alternate) {
3320 netp = stcb->asoc.alternate;
3322 netp = stcb->asoc.primary_destination;
3324 sctp_send_shutdown(stcb, netp);
3325 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN, stcb->sctp_ep, stcb,
3327 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, stcb->sctp_ep, stcb, NULL);
3328 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_SHUT_TMR, SCTP_SO_LOCKED);
3332 SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_SHUTDOWN_PENDING);
3333 if ((*stcb->asoc.ss_functions.sctp_ss_is_user_msgs_incomplete) (stcb, &stcb->asoc)) {
3334 SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_PARTIAL_MSG_LEFT);
3336 if (TAILQ_EMPTY(&stcb->asoc.send_queue) &&
3337 TAILQ_EMPTY(&stcb->asoc.sent_queue) &&
3338 (stcb->asoc.state & SCTP_STATE_PARTIAL_MSG_LEFT)) {
3343 stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_PCB + SCTP_LOC_5;
3344 sctp_send_abort_tcb(stcb, op_err, SCTP_SO_LOCKED);
3346 if ((SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) ||
3347 (SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_RECEIVED)) {
3350 if (sctp_free_assoc(inp, stcb,
3357 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_CLOSING, SCTP_SO_LOCKED);
3361 SCTP_TCB_UNLOCK(stcb);
3390 LIST_FOREACH_SAFE(stcb, &inp->sctp_asoc_list, sctp_tcblist, nstcb) {
3391 SCTP_TCB_LOCK(stcb);
3394 stcb->sctp_socket = NULL;
3395 SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_CLOSED_SOCKET);
3397 if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {
3398 if (stcb->asoc.state & SCTP_STATE_IN_ACCEPT_QUEUE) {
3399 SCTP_CLEAR_SUBSTATE(stcb, SCTP_STATE_IN_ACCEPT_QUEUE);
3400 sctp_timer_start(SCTP_TIMER_TYPE_ASOCKILL, inp, stcb, NULL);
3403 SCTP_TCB_UNLOCK(stcb);
3407 if ((SCTP_GET_STATE(stcb) != SCTP_STATE_COOKIE_WAIT) &&
3408 ((stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) == 0)) {
3412 stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_PCB + SCTP_LOC_7;
3413 sctp_send_abort_tcb(stcb, op_err, SCTP_SO_LOCKED);
3415 } else if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {
3417 SCTP_TCB_UNLOCK(stcb);
3420 if ((SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) ||
3421 (SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_RECEIVED)) {
3424 if (sctp_free_assoc(inp, stcb, SCTP_PCBFREE_FORCE,
3534 LIST_FOREACH_SAFE(stcb, &inp->sctp_asoc_free_list, sctp_tcblist, nstcb) {
3535 LIST_REMOVE(stcb, sctp_tcblist);
3536 SCTP_ZONE_FREE(SCTP_BASE_INFO(ipi_zone_asoc), stcb);
3557 sctp_findnet(struct sctp_tcb *stcb, struct sockaddr *addr)
3562 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
3588 sctp_add_remote_addr(struct sctp_tcb *stcb, struct sockaddr *newaddr,
3603 netfirst = sctp_findnet(stcb, newaddr);
3643 stcb->asoc.scope.ipv4_local_scope = 1;
3648 (stcb->asoc.scope.ipv4_local_scope == 0)) {
3668 if (sctp_is_address_on_local_host(newaddr, stcb->asoc.vrf_id)) {
3669 stcb->asoc.scope.loopback_scope = 1;
3670 stcb->asoc.scope.local_scope = 0;
3671 stcb->asoc.scope.ipv4_local_scope = 1;
3672 stcb->asoc.scope.site_scope = 1;
3684 stcb->asoc.scope.ipv4_local_scope = 1;
3685 stcb->asoc.scope.site_scope = 1;
3692 stcb->asoc.scope.site_scope = 1;
3697 (stcb->asoc.scope.loopback_scope == 0)) {
3700 (stcb->asoc.scope.local_scope == 0)) {
3703 (stcb->asoc.scope.site_scope == 0)) {
3725 ((struct sockaddr_in *)&net->ro._l_addr)->sin_port = stcb->rport;
3730 ((struct sockaddr_in6 *)&net->ro._l_addr)->sin6_port = stcb->rport;
3736 net->addr_is_local = sctp_is_address_on_local_host(newaddr, stcb->asoc.vrf_id);
3738 stcb->asoc.scope.loopback_scope = 1;
3739 stcb->asoc.scope.ipv4_local_scope = 1;
3740 stcb->asoc.scope.local_scope = 0;
3741 stcb->asoc.scope.site_scope = 1;
3744 net->failure_threshold = stcb->asoc.def_net_failure;
3745 net->pf_threshold = stcb->asoc.def_net_pf_threshold;
3764 stcb->asoc.numnets++;
3766 net->cwr_window_tsn = net->last_cwr_tsn = stcb->asoc.sending_seq - 1;
3768 net->dscp = stcb->asoc.default_dscp;
3770 net->flowlabel = stcb->asoc.default_flowlabel;
3772 if (sctp_stcb_is_feature_on(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_DONOT_HEARTBEAT)) {
3777 if (sctp_stcb_is_feature_on(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_DO_NOT_PMTUD)) {
3782 net->heart_beat_delay = stcb->asoc.heart_beat_delay;
3800 stcb->asoc.vrf_id,
3801 stcb->sctp_ep->fibnum);
3806 net->ro._s_addr = sctp_source_address_selection(stcb->sctp_ep,
3807 stcb,
3811 stcb->asoc.vrf_id);
3812 if (stcb->asoc.default_mtu > 0) {
3813 net->mtu = stcb->asoc.default_mtu;
3849 hcmtu = sctp_hc_get_mtu(&net->ro._l_addr, stcb->sctp_ep->fibnum);
3854 if (stcb->asoc.default_mtu > 0) {
3855 net->mtu = stcb->asoc.default_mtu;
3898 stcb->asoc.smallest_mtu = net->mtu;
3900 if (stcb->asoc.smallest_mtu > net->mtu) {
3901 sctp_pathmtu_adjustment(stcb, net->mtu, true);
3913 if (stcb->asoc.cc_functions.sctp_set_initial_cc_param != NULL)
3914 (*stcb->asoc.cc_functions.sctp_set_initial_cc_param) (stcb, net);
3923 net->flowid = stcb->asoc.my_vtag ^
3924 ntohs(stcb->rport) ^
3925 ntohs(stcb->sctp_ep->sctp_lport);
3930 netfirst = TAILQ_FIRST(&stcb->asoc.nets);
3933 TAILQ_INSERT_TAIL(&stcb->asoc.nets, net, sctp_next);
3936 TAILQ_INSERT_HEAD(&stcb->asoc.nets, net, sctp_next);
3942 TAILQ_INSERT_HEAD(&stcb->asoc.nets, net, sctp_next);
3948 TAILQ_INSERT_HEAD(&stcb->asoc.nets, net, sctp_next);
3962 TAILQ_INSERT_TAIL(&stcb->asoc.nets, net, sctp_next);
3969 TAILQ_INSERT_AFTER(&stcb->asoc.nets, netlook,
3979 if (stcb->asoc.primary_destination == 0) {
3980 stcb->asoc.primary_destination = net;
3981 } else if ((stcb->asoc.primary_destination->ro.ro_nh == NULL) &&
3985 stcb->asoc.primary_destination = net;
3988 net = TAILQ_FIRST(&stcb->asoc.nets);
3989 if ((net != stcb->asoc.primary_destination) &&
3990 (stcb->asoc.primary_destination)) {
3996 TAILQ_REMOVE(&stcb->asoc.nets,
3997 stcb->asoc.primary_destination, sctp_next);
3998 TAILQ_INSERT_HEAD(&stcb->asoc.nets,
3999 stcb->asoc.primary_destination, sctp_next);
4005 sctp_aloc_a_assoc_id(struct sctp_inpcb *inp, struct sctp_tcb *stcb)
4030 LIST_INSERT_HEAD(head, stcb, sctp_tcbasocidhash);
4031 stcb->asoc.in_asocid_hash = 1;
4049 struct sctp_tcb *stcb;
4183 stcb = SCTP_ZONE_GET(SCTP_BASE_INFO(ipi_zone_asoc), struct sctp_tcb);
4184 if (stcb == NULL) {
4192 memset(stcb, 0, sizeof(*stcb));
4193 asoc = &stcb->asoc;
4195 SCTP_TCB_LOCK_INIT(stcb);
4196 stcb->rport = rport;
4198 stcb->sctp_ep = inp;
4199 stcb->sctp_socket = inp->sctp_socket;
4200 if ((err = sctp_init_asoc(inp, stcb, override_tag, initial_tsn, vrf_id, o_streams))) {
4202 SCTP_TCB_LOCK_DESTROY(stcb);
4203 SCTP_ZONE_FREE(SCTP_BASE_INFO(ipi_zone_asoc), stcb);
4208 SCTP_TCB_LOCK(stcb);
4210 asoc->assoc_id = sctp_aloc_a_assoc_id(inp, stcb);
4212 head = &SCTP_BASE_INFO(sctp_asochash)[SCTP_PCBHASH_ASOC(stcb->asoc.my_vtag, SCTP_BASE_INFO(hashasocmark))];
4214 LIST_INSERT_HEAD(head, stcb, sctp_asocs);
4216 if (sctp_add_remote_addr(stcb, firstaddr, NULL, port, SCTP_DO_SETSCOPE, SCTP_ALLOC_ASOC)) {
4231 SCTP_TCB_UNLOCK(stcb);
4232 SCTP_TCB_LOCK_DESTROY(stcb);
4233 LIST_REMOVE(stcb, sctp_asocs);
4234 LIST_REMOVE(stcb, sctp_tcbasocidhash);
4235 SCTP_ZONE_FREE(SCTP_BASE_INFO(ipi_zone_asoc), stcb);
4249 LIST_INSERT_HEAD(&inp->sctp_asoc_list, stcb, sctp_tcblist);
4252 head = &inp->sctp_tcbhash[SCTP_PCBHASH_ALLADDR(stcb->rport,
4254 LIST_INSERT_HEAD(head, stcb, sctp_tcbhash);
4257 sctp_initialize_auth_params(inp, stcb);
4259 SCTPDBG(SCTP_DEBUG_PCB1, "Association %p now allocated\n", (void *)stcb);
4260 return (stcb);
4270 struct sctp_tcb *stcb;
4274 stcb = sctp_aloc_assoc_locked(inp, firstaddr, error, override_tag,
4278 return (stcb);
4288 struct sctp_tcb *stcb;
4299 stcb = sctp_aloc_assoc_locked(inp, firstaddr, error, override_tag,
4302 if (stcb != NULL && (inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE)) {
4307 return (stcb);
4311 sctp_remove_net(struct sctp_tcb *stcb, struct sctp_nets *net)
4316 inp = stcb->sctp_ep;
4317 asoc = &stcb->asoc;
4330 if (sctp_is_mobility_feature_on(stcb->sctp_ep,
4332 sctp_is_mobility_feature_on(stcb->sctp_ep,
4343 sctp_mobility_feature_on(stcb->sctp_ep,
4346 stcb->sctp_ep, stcb, NULL);
4350 asoc->primary_destination = sctp_find_alternate_net(stcb, lnet, 0);
4364 if (net == stcb->asoc.alternate) {
4365 sctp_free_remote_addr(stcb->asoc.alternate);
4366 stcb->asoc.alternate = NULL;
4368 sctp_timer_stop(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net,
4370 sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net,
4381 sctp_del_remote_addr(struct sctp_tcb *stcb, struct sockaddr *remaddr)
4393 asoc = &stcb->asoc;
4407 sctp_remove_net(stcb, net);
4505 sctp_clean_up_stream(struct sctp_tcb *stcb, struct sctp_readhead *rh)
4528 sctp_auth_key_release(stcb, chk->auth_keyid, SCTP_SO_LOCKED);
4539 sctp_free_a_readq(stcb, control);
4546 * function ALWAYS returns holding NO LOCK on the stcb. It DOES
4553 sctp_free_assoc(struct sctp_inpcb *inp, struct sctp_tcb *stcb, int from_inpcbfree, int from_location)
4569 SCTP_TCB_LOCK_ASSERT(stcb);
4572 sctp_log_closing(inp, stcb, 6);
4574 if (stcb->asoc.state == 0) {
4581 if (stcb->asoc.alternate) {
4582 sctp_free_remote_addr(stcb->asoc.alternate);
4583 stcb->asoc.alternate = NULL;
4586 if (stcb->freed_from_where == 0) {
4588 stcb->freed_from_where = from_location;
4592 asoc = &stcb->asoc;
4605 if ((stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) &&
4611 if (stcb->asoc.refcnt) {
4613 sctp_timer_start(SCTP_TIMER_TYPE_ASOCKILL, inp, stcb, NULL);
4615 SCTP_TCB_UNLOCK(stcb);
4617 sctp_log_closing(inp, stcb, 8);
4623 sctp_stop_association_timers(stcb, false);
4625 if ((stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) == 0) {
4626 SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_ABOUT_TO_BE_FREED);
4629 if (sq->stcb == stcb) {
4631 sq->sinfo_cumtsn = stcb->asoc.cumulative_tsn;
4640 if (sctp_stcb_is_feature_on(inp, stcb, SCTP_PCB_FLAGS_PDAPIEVNT) && (so != NULL)) {
4642 stcb,
4653 if (stcb->block_entry) {
4654 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_PCB, ECONNRESET);
4655 stcb->block_entry->error = ECONNRESET;
4656 stcb->block_entry = NULL;
4659 if ((stcb->asoc.refcnt) || (stcb->asoc.state & SCTP_STATE_IN_ACCEPT_QUEUE)) {
4664 if ((stcb->asoc.refcnt) ||
4667 SCTP_CLEAR_SUBSTATE(stcb, SCTP_STATE_IN_ACCEPT_QUEUE);
4668 sctp_timer_start(SCTP_TIMER_TYPE_ASOCKILL, inp, stcb, NULL);
4679 SCTP_TCB_UNLOCK(stcb);
4682 sctp_log_closing(inp, stcb, 9);
4688 sctp_log_closing(inp, stcb, 10);
4701 atomic_add_int(&stcb->asoc.refcnt, 1);
4703 SCTP_TCB_UNLOCK(stcb);
4706 SCTP_TCB_LOCK(stcb);
4744 atomic_subtract_int(&stcb->asoc.refcnt, 1);
4746 if (stcb->asoc.refcnt) {
4747 SCTP_CLEAR_SUBSTATE(stcb, SCTP_STATE_IN_ACCEPT_QUEUE);
4748 sctp_timer_start(SCTP_TIMER_TYPE_ASOCKILL, inp, stcb, NULL);
4753 SCTP_TCB_UNLOCK(stcb);
4758 LIST_REMOVE(stcb, sctp_tcbhash);
4760 if (stcb->asoc.in_asocid_hash) {
4761 LIST_REMOVE(stcb, sctp_tcbasocidhash);
4764 stcb->sctp_socket = NULL;
4767 LIST_REMOVE(stcb, sctp_tcblist);
4773 LIST_REMOVE(stcb, sctp_asocs);
4774 sctp_add_vtag_to_timewait(asoc->my_vtag, inp->sctp_lport, stcb->rport);
4779 sctp_stop_association_timers(stcb, true);
4794 stcb->asoc.ss_functions.sctp_ss_remove_from_stream(stcb, asoc, outs, sp);
4795 sctp_free_spbufspace(stcb, asoc, sp);
4799 sctp_ulp_notify(SCTP_NOTIFY_SPECIAL_SP_FAIL, stcb,
4813 sctp_free_a_strmoq(stcb, sp, SCTP_SO_LOCKED);
4829 sq->stcb = NULL;
4831 sctp_free_a_readq(stcb, sq);
4841 sctp_auth_key_release(stcb, chk->auth_keyid, SCTP_SO_LOCKED);
4861 sctp_ulp_notify(SCTP_NOTIFY_UNSENT_DG_FAIL, stcb,
4870 sctp_auth_key_release(stcb, chk->auth_keyid, SCTP_SO_LOCKED);
4894 sctp_ulp_notify(SCTP_NOTIFY_SENT_DG_FAIL, stcb,
4903 sctp_auth_key_release(stcb, chk->auth_keyid, SCTP_SO_LOCKED);
4910 for (i = 0; i < stcb->asoc.streamoutcnt; i++) {
4911 if (stcb->asoc.strmout[i].chunks_on_queues > 0) {
4912 panic("%u chunks left for stream %u.", stcb->asoc.strmout[i].chunks_on_queues, i);
4924 sctp_auth_key_release(stcb, chk->auth_keyid, SCTP_SO_LOCKED);
4938 sctp_auth_key_release(stcb, chk->auth_keyid, SCTP_SO_LOCKED);
4960 sctp_clean_up_stream(stcb, &asoc->strmin[i].inqueue);
4961 sctp_clean_up_stream(stcb, &asoc->strmin[i].uno_inqueue);
5017 SCTP_TCB_UNLOCK(stcb);
5018 SCTP_TCB_LOCK_DESTROY(stcb);
5026 SCTP_ZONE_FREE(SCTP_BASE_INFO(ipi_zone_asoc), stcb);
5029 LIST_INSERT_HEAD(&inp->sctp_asoc_free_list, stcb, sctp_tcblist);
5032 SCTP_ZONE_FREE(SCTP_BASE_INFO(ipi_zone_asoc), stcb);
5076 sctp_destination_is_reachable(struct sctp_tcb *stcb, struct sockaddr *destaddr)
5091 inp = stcb->sctp_ep;
5167 struct sctp_tcb *stcb;
5213 LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
5214 sctp_add_local_addr_restricted(stcb, ifa);
5226 sctp_select_primary_destination(struct sctp_tcb *stcb)
5230 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
5234 if (sctp_destination_is_reachable(stcb,
5237 stcb->asoc.primary_destination = net;
5275 struct sctp_tcb *stcb;
5283 LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
5286 SCTP_TCB_LOCK(stcb);
5287 if (stcb->asoc.last_used_address == laddr)
5289 stcb->asoc.last_used_address = NULL;
5294 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
5303 SCTP_TCB_UNLOCK(stcb);
5320 sctp_add_local_addr_restricted(struct sctp_tcb *stcb, struct sctp_ifa *ifa)
5329 list = &stcb->asoc.sctp_restricted_addrs;
5355 sctp_del_local_addr_restricted(struct sctp_tcb *stcb, struct sctp_ifa *ifa)
5370 inp = stcb->sctp_ep;
5374 if (stcb->sctp_ep->laddr_count < 2) {
5379 LIST_FOREACH(laddr, &stcb->asoc.sctp_restricted_addrs, sctp_nxt_addr) {
5854 sctp_load_addresses_from_init(struct sctp_tcb *stcb, struct mbuf *m,
5907 sin.sin_port = stcb->rport;
5913 sin6.sin6_port = stcb->rport;
5929 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
5934 inp = stcb->sctp_ep;
5935 atomic_add_int(&stcb->asoc.refcnt, 1);
5936 stcb_tmp = sctp_findassociation_ep_addr(&inp, sa, &net_tmp, dst, stcb);
5937 atomic_subtract_int(&stcb->asoc.refcnt, 1);
5939 if ((stcb_tmp == NULL && inp == stcb->sctp_ep) || inp == NULL) {
5945 if (stcb->asoc.scope.ipv4_addr_legal) {
5946 if (sctp_add_remote_addr(stcb, sa, NULL, port, SCTP_DONOT_SETSCOPE, SCTP_LOAD_ADDR_2)) {
5954 if (stcb->asoc.scope.ipv6_addr_legal) {
5955 if (sctp_add_remote_addr(stcb, sa, NULL, port, SCTP_DONOT_SETSCOPE, SCTP_LOAD_ADDR_3)) {
5965 if (net_tmp != NULL && stcb_tmp == stcb) {
5967 } else if (stcb_tmp != stcb) {
5974 if (stcb->asoc.state == 0) {
5995 if (stcb->asoc.scope.ipv4_addr_legal) {
6017 inp = stcb->sctp_ep;
6018 atomic_add_int(&stcb->asoc.refcnt, 1);
6020 dst, stcb);
6021 atomic_subtract_int(&stcb->asoc.refcnt, 1);
6023 if ((stcb_tmp == NULL && inp == stcb->sctp_ep) ||
6036 if (stcb->asoc.state == 0) {
6040 if (sctp_add_remote_addr(stcb, sa, NULL, port, SCTP_DONOT_SETSCOPE, SCTP_LOAD_ADDR_4)) {
6043 } else if (stcb_tmp == stcb) {
6044 if (stcb->asoc.state == 0) {
6079 if (stcb->asoc.state == 0) {
6090 if (stcb->asoc.scope.ipv6_addr_legal) {
6116 inp = stcb->sctp_ep;
6117 atomic_add_int(&stcb->asoc.refcnt, 1);
6119 dst, stcb);
6120 atomic_subtract_int(&stcb->asoc.refcnt, 1);
6122 (inp == stcb->sctp_ep || inp == NULL)) {
6128 if (stcb->asoc.state == 0) {
6136 if (sctp_add_remote_addr(stcb, sa, NULL, port, SCTP_DONOT_SETSCOPE, SCTP_LOAD_ADDR_5)) {
6139 } else if (stcb_tmp == stcb) {
6144 if (stcb->asoc.state == 0) {
6178 if (stcb->asoc.state == 0) {
6190 if (stcb->asoc.state != SCTP_STATE_OPEN) {
6198 stcb->asoc.peers_adaptation = ntohl(aip->indication);
6199 stcb->asoc.adaptation_needed = 1;
6210 if (stcb->asoc.asconf_supported == 0) {
6261 (void)sctp_set_primary_addr(stcb, sa, NULL);
6264 stcb->asoc.peer_supports_nat = 1;
6283 (ntohl(zero_chksum_p->edmid) == stcb->asoc.rcv_edmid)) {
6284 stcb->asoc.snd_edmid = stcb->asoc.rcv_edmid;
6376 if (stcb->asoc.peer_hmacs != NULL)
6377 sctp_free_hmaclist(stcb->asoc.peer_hmacs);
6378 stcb->asoc.peer_hmacs = sctp_alloc_hmaclist(num_hmacs);
6379 if (stcb->asoc.peer_hmacs != NULL) {
6381 (void)sctp_auth_add_hmacid(stcb->asoc.peer_hmacs,
6402 if (stcb->asoc.peer_auth_chunks != NULL)
6403 sctp_clear_chunklist(stcb->asoc.peer_auth_chunks);
6405 stcb->asoc.peer_auth_chunks = sctp_alloc_chunklist();
6408 stcb->asoc.peer_auth_chunks);
6448 TAILQ_FOREACH_SAFE(net, &stcb->asoc.nets, sctp_next, nnet) {
6453 stcb->asoc.numnets--;
6454 TAILQ_REMOVE(&stcb->asoc.nets, net, sctp_next);
6455 if (net == stcb->asoc.alternate) {
6456 sctp_free_remote_addr(stcb->asoc.alternate);
6457 stcb->asoc.alternate = NULL;
6459 if (net == stcb->asoc.primary_destination) {
6460 stcb->asoc.primary_destination = NULL;
6461 sctp_select_primary_destination(stcb);
6466 if ((stcb->asoc.ecn_supported == 1) &&
6468 stcb->asoc.ecn_supported = 0;
6470 if ((stcb->asoc.prsctp_supported == 1) &&
6472 stcb->asoc.prsctp_supported = 0;
6474 if ((stcb->asoc.auth_supported == 1) &&
6477 stcb->asoc.auth_supported = 0;
6479 if ((stcb->asoc.asconf_supported == 1) &&
6481 (stcb->asoc.auth_supported == 0) ||
6483 stcb->asoc.asconf_supported = 0;
6485 if ((stcb->asoc.reconfig_supported == 1) &&
6487 stcb->asoc.reconfig_supported = 0;
6489 if ((stcb->asoc.idata_supported == 1) &&
6491 stcb->asoc.idata_supported = 0;
6493 if ((stcb->asoc.nrsack_supported == 1) &&
6495 stcb->asoc.nrsack_supported = 0;
6497 if ((stcb->asoc.pktdrop_supported == 1) &&
6499 stcb->asoc.pktdrop_supported = 0;
6543 if (stcb->asoc.authinfo.peer_random != NULL)
6544 sctp_free_key(stcb->asoc.authinfo.peer_random);
6545 stcb->asoc.authinfo.peer_random = new_key;
6546 sctp_clear_cachedkeys(stcb, stcb->asoc.authinfo.assoc_keyid);
6547 sctp_clear_cachedkeys(stcb, stcb->asoc.authinfo.recv_keyid);
6553 sctp_set_primary_addr(struct sctp_tcb *stcb, struct sockaddr *sa,
6558 net = sctp_findnet(stcb, sa);
6570 stcb->asoc.primary_destination = net;
6572 (stcb->asoc.alternate != NULL)) {
6573 sctp_free_remote_addr(stcb->asoc.alternate);
6574 stcb->asoc.alternate = NULL;
6576 net = TAILQ_FIRST(&stcb->asoc.nets);
6577 if (net != stcb->asoc.primary_destination) {
6583 TAILQ_REMOVE(&stcb->asoc.nets, stcb->asoc.primary_destination, sctp_next);
6584 TAILQ_INSERT_HEAD(&stcb->asoc.nets, stcb->asoc.primary_destination, sctp_next);
6594 struct sctp_tcb *stcb;
6599 LIST_FOREACH(stcb, head, sctp_asocs) {
6606 if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) {
6609 if (stcb->asoc.my_vtag == tag) {
6611 if (stcb->rport != rport) {
6614 if (stcb->sctp_ep->sctp_lport != lport) {
6625 sctp_drain_mbufs(struct sctp_tcb *stcb)
6641 asoc = &stcb->asoc;
6675 TAILQ_REMOVE(&stcb->sctp_ep->read_queue, control, next);
6706 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED);
6708 sctp_free_a_readq(stcb, control);
6735 TAILQ_REMOVE(&stcb->sctp_ep->read_queue, control, next);
6766 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED);
6768 sctp_free_a_readq(stcb, control);
6810 sctp_timer_stop(SCTP_TIMER_TYPE_RECV, stcb->sctp_ep, stcb, NULL,
6813 sctp_send_sack(stcb, SCTP_SO_NOT_LOCKED);
6814 sctp_chunk_output(stcb->sctp_ep, stcb, SCTP_OUTPUT_FROM_DRAIN, SCTP_SO_NOT_LOCKED);
6844 struct sctp_tcb *stcb;
6859 LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
6861 SCTP_TCB_LOCK(stcb);
6862 sctp_drain_mbufs(stcb);
6863 SCTP_TCB_UNLOCK(stcb);