Lines Matching defs:stcb
2024 sctp_add_addresses_to_i_ia(struct sctp_inpcb *inp, struct sctp_tcb *stcb,
2074 if (sctp_is_addr_restricted(stcb, sctp_ifap)) {
2117 if (sctp_is_addr_restricted(stcb, sctp_ifap)) {
2404 sctp_is_addr_restricted(struct sctp_tcb *stcb, struct sctp_ifa *ifa)
2408 if (stcb == NULL) {
2412 LIST_FOREACH(laddr, &stcb->asoc.sctp_restricted_addrs, sctp_nxt_addr) {
2580 struct sctp_tcb *stcb,
2637 (sctp_is_addr_restricted(stcb, sifa))) ||
2639 (sctp_is_addr_restricted(stcb, sifa)) &&
2640 (!sctp_is_addr_pending(stcb, sifa)))) {
2671 (sctp_is_addr_restricted(stcb, sifa))) ||
2673 (sctp_is_addr_restricted(stcb, sifa)) &&
2674 (!sctp_is_addr_pending(stcb, sifa)))) {
2687 starting_point = stcb->asoc.last_used_address;
2689 if (stcb->asoc.last_used_address == NULL) {
2691 stcb->asoc.last_used_address = LIST_FIRST(&inp->sctp_addr_list);
2694 for (laddr = stcb->asoc.last_used_address; laddr;
2708 (sctp_is_addr_restricted(stcb, sifa))) ||
2710 (sctp_is_addr_restricted(stcb, sifa)) &&
2711 (!sctp_is_addr_pending(stcb, sifa)))) {
2715 stcb->asoc.last_used_address = laddr;
2720 stcb->asoc.last_used_address = NULL;
2724 stcb->asoc.last_used_address = starting_point;
2727 if (stcb->asoc.last_used_address == NULL) {
2729 stcb->asoc.last_used_address = LIST_FIRST(&inp->sctp_addr_list);
2732 for (laddr = stcb->asoc.last_used_address; laddr;
2747 (sctp_is_addr_restricted(stcb, sifa))) ||
2749 (sctp_is_addr_restricted(stcb, sifa)) &&
2750 (!sctp_is_addr_pending(stcb, sifa)))) {
2754 stcb->asoc.last_used_address = laddr;
2759 stcb->asoc.last_used_address = NULL;
2768 struct sctp_tcb *stcb,
2842 if (stcb && fam == AF_INET6 &&
2843 sctp_is_mobility_feature_on(stcb->sctp_ep, SCTP_MOBILITY_BASE)) {
2851 if (stcb && fam == AF_INET &&
2852 sctp_is_mobility_feature_on(stcb->sctp_ep, SCTP_MOBILITY_BASE)) {
2858 if (stcb) {
2859 if (sctp_is_address_in_scope(ifa, &stcb->asoc.scope, 0) == 0) {
2863 (sctp_is_addr_restricted(stcb, sifa))) ||
2865 (sctp_is_addr_restricted(stcb, sifa)) &&
2866 (!sctp_is_addr_pending(stcb, sifa)))) {
2885 struct sctp_tcb *stcb,
2904 (stcb != NULL) &&
2919 if (stcb) {
2920 if (sctp_is_address_in_scope(ifa, &stcb->asoc.scope, 0) == 0) {
2924 (sctp_is_addr_restricted(stcb, sifa))) ||
2926 (sctp_is_addr_restricted(stcb, sifa)) &&
2927 (!sctp_is_addr_pending(stcb, sifa)))) {
2942 struct sctp_tcb *stcb,
2995 inp, stcb,
3022 sctp_ifa = sctp_select_nth_preferred_addr_from_ifn_boundall(sctp_ifn, inp, stcb, non_asoc_addr_ok, dest_is_loop,
3053 num_preferred = sctp_count_num_preferred_boundall(sctp_ifn, inp, stcb, non_asoc_addr_ok,
3075 sifa = sctp_select_nth_preferred_addr_from_ifn_boundall(sctp_ifn, inp, stcb, non_asoc_addr_ok, dest_is_loop,
3130 if (stcb) {
3131 if (sctp_is_address_in_scope(sifa, &stcb->asoc.scope, 0) == 0) {
3137 (sctp_is_addr_restricted(stcb, sifa))) ||
3139 (sctp_is_addr_restricted(stcb, sifa)) &&
3140 (!sctp_is_addr_pending(stcb, sifa)))) {
3189 if (stcb) {
3190 if (sctp_is_address_in_scope(sifa, &stcb->asoc.scope, 0) == 0) {
3195 (sctp_is_addr_restricted(stcb, sifa))) ||
3197 (sctp_is_addr_restricted(stcb, sifa)) &&
3198 (!sctp_is_addr_pending(stcb, sifa)))) {
3211 if (stcb) {
3212 if ((retried == 0) && (stcb->asoc.scope.ipv4_local_scope == 0)) {
3213 stcb->asoc.scope.ipv4_local_scope = 1;
3217 stcb->asoc.scope.ipv4_local_scope = 0;
3259 if (stcb) {
3261 &stcb->asoc.scope, 0) == 0) {
3265 (sctp_is_addr_restricted(stcb, tmp_sifa))) ||
3267 (sctp_is_addr_restricted(stcb, tmp_sifa)) &&
3268 (!sctp_is_addr_pending(stcb, tmp_sifa)))) {
3280 sctp_add_local_addr_restricted(stcb, tmp_sifa);
3294 struct sctp_tcb *stcb,
3428 answer = sctp_choose_boundall(inp, stcb, net, ro, vrf_id,
3437 if (stcb) {
3438 answer = sctp_choose_boundspecific_stcb(inp, stcb, ro,
3554 sctp_process_cmsgs_for_init(struct sctp_tcb *stcb, struct mbuf *control, int *error)
3596 stcb->asoc.max_init_times = initmsg.sinit_max_attempts;
3598 stcb->asoc.pre_open_streams = initmsg.sinit_num_ostreams;
3600 stcb->asoc.max_inbound_streams = initmsg.sinit_max_instreams;
3602 stcb->asoc.initial_init_rto_max = initmsg.sinit_max_init_timeo;
3603 if (stcb->asoc.streamoutcnt < stcb->asoc.pre_open_streams) {
3612 stcb->asoc.streamoutcnt, stcb->asoc.pre_open_streams);
3613 SCTP_TCB_UNLOCK(stcb);
3616 (stcb->asoc.pre_open_streams * sizeof(struct sctp_stream_out)),
3618 SCTP_TCB_LOCK(stcb);
3620 SCTP_FREE(stcb->asoc.strmout, SCTP_M_STRMO);
3621 stcb->asoc.strmout = tmp_str;
3622 stcb->asoc.strm_realoutsize = stcb->asoc.streamoutcnt = stcb->asoc.pre_open_streams;
3624 stcb->asoc.pre_open_streams = stcb->asoc.streamoutcnt;
3626 for (i = 0; i < stcb->asoc.streamoutcnt; i++) {
3627 TAILQ_INIT(&stcb->asoc.strmout[i].outqueue);
3628 stcb->asoc.ss_functions.sctp_ss_init_stream(stcb, &stcb->asoc.strmout[i], NULL);
3629 stcb->asoc.strmout[i].chunks_on_queues = 0;
3632 stcb->asoc.strmout[i].abandoned_sent[j] = 0;
3633 stcb->asoc.strmout[i].abandoned_unsent[j] = 0;
3636 stcb->asoc.strmout[i].abandoned_sent[0] = 0;
3637 stcb->asoc.strmout[i].abandoned_unsent[0] = 0;
3639 stcb->asoc.strmout[i].next_mid_ordered = 0;
3640 stcb->asoc.strmout[i].next_mid_unordered = 0;
3641 stcb->asoc.strmout[i].sid = i;
3642 stcb->asoc.strmout[i].last_msg_incomplete = 0;
3643 stcb->asoc.strmout[i].state = SCTP_STREAM_OPENING;
3656 sin.sin_port = stcb->rport;
3664 if (sctp_add_remote_addr(stcb, (struct sockaddr *)&sin, NULL, stcb->asoc.port,
3680 sin6.sin6_port = stcb->rport;
3696 if (sctp_add_remote_addr(stcb, (struct sockaddr *)&sin, NULL, stcb->asoc.port,
3703 if (sctp_add_remote_addr(stcb, (struct sockaddr *)&sin6, NULL, stcb->asoc.port,
3727 struct sctp_tcb *stcb;
3799 stcb = sctp_findassociation_ep_addr(inp_p, addr, net_p, NULL, NULL);
3800 if (stcb != NULL) {
3801 return (stcb);
3896 sctp_get_ect(struct sctp_tcb *stcb)
3898 if ((stcb != NULL) && (stcb->asoc.ecn_supported == 1)) {
3907 sctp_handle_no_route(struct sctp_tcb *stcb,
3917 if ((net->dest_state & SCTP_ADDR_REACHABLE) && stcb) {
3920 stcb, 0,
3927 if (stcb) {
3928 if (net == stcb->asoc.primary_destination) {
3932 alt = sctp_find_alternate_net(stcb, net, 0);
3934 if (stcb->asoc.alternate) {
3935 sctp_free_remote_addr(stcb->asoc.alternate);
3937 stcb->asoc.alternate = alt;
3938 atomic_add_int(&stcb->asoc.alternate->ref_count, 1);
3953 struct sctp_tcb *stcb, /* may be NULL */
4001 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EFAULT);
4006 if (stcb) {
4007 vrf_id = stcb->asoc.vrf_id;
4013 if ((auth != NULL) && (stcb != NULL)) {
4014 sctp_fill_hmac_digest_m(m, auth_offset, auth, stcb, auth_keyid);
4019 } else if (stcb) {
4020 tos_value = stcb->asoc.default_dscp;
4040 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
4068 tos_value |= sctp_get_ect(stcb);
4107 net->ro._s_addr = sctp_source_address_selection(inp, stcb,
4115 sctp_handle_no_route(stcb, net, so_locked);
4116 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EHOSTUNREACH);
4125 _lsrc = sctp_source_address_selection(inp, stcb, ro,
4130 sctp_handle_no_route(stcb, net, so_locked);
4131 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EHOSTUNREACH);
4144 sctp_handle_no_route(stcb, net, so_locked);
4145 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EHOSTUNREACH);
4181 sctp_handle_no_route(stcb, net, so_locked);
4182 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EHOSTUNREACH);
4198 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
4226 /* send it out. table id is taken from stcb */
4227 SCTP_PROBE5(send, NULL, stcb, ip, stcb, sctphdr);
4253 if ((stcb != NULL) && (stcb->asoc.smallest_mtu > mtu)) {
4254 sctp_pathmtu_adjustment(stcb, mtu, true);
4287 } else if (stcb) {
4288 flowlabel = stcb->asoc.default_flowlabel;
4308 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
4332 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL);
4357 tos_value |= sctp_get_ect(stcb);
4394 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL);
4400 stcb,
4411 sctp_handle_no_route(stcb, net, so_locked);
4412 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EHOSTUNREACH);
4421 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL);
4428 _lsrc = sctp_source_address_selection(inp, stcb, ro,
4433 sctp_handle_no_route(stcb, net, so_locked);
4434 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EHOSTUNREACH);
4454 sctp_handle_no_route(stcb, net, so_locked);
4455 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EHOSTUNREACH);
4480 sctp_handle_no_route(stcb, net, so_locked);
4481 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EHOSTUNREACH);
4531 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
4546 /* send it out. table id is taken from stcb */
4551 SCTP_PROBE5(send, NULL, stcb, ip6h, stcb, sctphdr);
4595 if ((stcb != NULL) && (stcb->asoc.smallest_mtu > mtu)) {
4596 sctp_pathmtu_adjustment(stcb, mtu, false);
4602 (stcb->asoc.smallest_mtu > ND_IFINFO(ifp)->linkmtu)) {
4603 sctp_pathmtu_adjustment(stcb, ND_IFINFO(ifp)->linkmtu, false);
4614 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EFAULT);
4620 sctp_send_initiate(struct sctp_inpcb *inp, struct sctp_tcb *stcb, int so_locked)
4635 net = stcb->asoc.primary_destination;
4637 net = TAILQ_FIRST(&stcb->asoc.nets);
4644 (void)sctp_set_primary_addr(stcb, NULL, net);
4666 sctp_timer_start(SCTP_TIMER_TYPE_INIT, inp, stcb, net);
4684 init->init.initiate_tag = htonl(stcb->asoc.my_vtag);
4688 init->init.num_outbound_streams = htons(stcb->asoc.pre_open_streams);
4689 init->init.num_inbound_streams = htons(stcb->asoc.max_inbound_streams);
4690 init->init.initial_tsn = htonl(stcb->asoc.init_seq_number);
4703 if (stcb->asoc.ecn_supported == 1) {
4712 if (stcb->asoc.prsctp_supported == 1) {
4721 if (stcb->asoc.rcv_edmid != SCTP_EDMID_NONE) {
4726 zero_chksum->edmid = htonl(stcb->asoc.rcv_edmid);
4742 if (stcb->asoc.prsctp_supported == 1) {
4744 if (stcb->asoc.idata_supported) {
4748 if (stcb->asoc.auth_supported == 1) {
4751 if (stcb->asoc.asconf_supported == 1) {
4755 if (stcb->asoc.reconfig_supported == 1) {
4758 if (stcb->asoc.idata_supported) {
4761 if (stcb->asoc.nrsack_supported == 1) {
4764 if (stcb->asoc.pktdrop_supported == 1) {
4775 if (stcb->asoc.auth_supported) {
4777 if (stcb->asoc.authinfo.random != NULL) {
4786 parameter_len = (uint16_t)sizeof(struct sctp_auth_random) + stcb->asoc.authinfo.random_len;
4788 memcpy(randp, stcb->asoc.authinfo.random->key, parameter_len);
4793 if (stcb->asoc.local_hmacs != NULL) {
4803 stcb->asoc.local_hmacs->num_algo * sizeof(uint16_t));
4806 sctp_serialize_hmaclist(stcb->asoc.local_hmacs, (uint8_t *)hmacs->hmac_ids);
4811 if (stcb->asoc.local_auth_chunks != NULL) {
4821 sctp_auth_get_chklist_size(stcb->asoc.local_auth_chunks));
4824 sctp_serialize_auth_chunks(stcb->asoc.local_auth_chunks, chunks->chunk_types);
4831 if (stcb->asoc.cookie_preserve_req > 0) {
4843 cookie_preserve->time = htonl(stcb->asoc.cookie_preserve_req);
4844 stcb->asoc.cookie_preserve_req = 0;
4848 if (stcb->asoc.scope.ipv4_addr_legal || stcb->asoc.scope.ipv6_addr_legal) {
4857 if (stcb->asoc.scope.ipv4_addr_legal) {
4860 if (stcb->asoc.scope.ipv6_addr_legal) {
4867 if (stcb->asoc.scope.ipv4_addr_legal) {
4870 if (stcb->asoc.scope.ipv6_addr_legal) {
4882 * we could just sifa in the address within the stcb. But for now
4885 m_last = sctp_add_addresses_to_i_ia(inp, stcb, &stcb->asoc.scope,
4897 if ((error = sctp_lowlevel_chunk_output(inp, stcb, net,
4900 inp->sctp_lport, stcb->rport, htonl(0),
4906 stcb->asoc.ifp_had_enobuf = 1;
4910 stcb->asoc.ifp_had_enobuf = 0;
5498 sctp_send_initiate_ack(struct sctp_inpcb *inp, struct sctp_tcb *stcb,
5540 if (stcb) {
5541 asoc = &stcb->asoc;
5546 (SCTP_GET_STATE(stcb) != SCTP_STATE_COOKIE_WAIT)) {
5785 stcb, (sctp_route_t *)&net->ro,
5817 stcb, (sctp_route_t *)&net->ro,
5854 ((SCTP_GET_STATE(stcb) == SCTP_STATE_COOKIE_WAIT) ||
5855 (SCTP_GET_STATE(stcb) == SCTP_STATE_INUSE) ||
5856 (SCTP_GET_STATE(stcb) == SCTP_STATE_COOKIE_ECHOED))) {
5865 SCTP_TCB_UNLOCK(stcb);
5881 SCTP_TCB_LOCK(stcb);
6097 m_last = sctp_add_addresses_to_i_ia(inp, stcb, &scp, m_last,
6209 sctp_prune_prsctp(struct sctp_tcb *stcb,
6217 SCTP_TCB_LOCK_ASSERT(stcb);
6252 ret_spc = sctp_release_pr_sctp_chunk(stcb, chk,
6275 ret_spc = sctp_release_pr_sctp_chunk(stcb, chk,
6290 sctp_get_frag_point(struct sctp_tcb *stcb)
6295 asoc = &stcb->asoc;
6297 if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
6389 sctp_msg_append(struct sctp_tcb *stcb,
6399 SCTP_TCB_LOCK_ASSERT(stcb);
6405 if (srcv->sinfo_stream >= stcb->asoc.streamoutcnt) {
6407 SCTP_LTRACE_ERR_RET_PKT(m, NULL, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL);
6411 if ((stcb->asoc.stream_locked) &&
6412 (stcb->asoc.stream_locked_on != srcv->sinfo_stream)) {
6413 SCTP_LTRACE_ERR_RET_PKT(m, NULL, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL);
6417 if ((stcb->asoc.strmout[srcv->sinfo_stream].state != SCTP_STREAM_OPEN) &&
6418 (stcb->asoc.strmout[srcv->sinfo_stream].state != SCTP_STREAM_OPENING)) {
6422 if (stcb->asoc.strmout[srcv->sinfo_stream].state > SCTP_STREAM_OPEN) {
6430 if ((SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_SENT) ||
6431 (SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_ACK_SENT) ||
6432 (SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_RECEIVED) ||
6433 (stcb->asoc.state & SCTP_STATE_SHUTDOWN_PENDING)) {
6435 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EPIPE);
6439 sctp_alloc_a_strmoq(stcb, sp);
6441 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
6478 sp->auth_keyid = stcb->asoc.authinfo.active_keyid;
6480 if (sctp_auth_is_required_chunk(SCTP_DATA, stcb->asoc.peer_auth_chunks)) {
6481 sctp_auth_key_acquire(stcb, sp->auth_keyid);
6484 strm = &stcb->asoc.strmout[srcv->sinfo_stream];
6485 sctp_snd_sb_alloc(stcb, sp->length);
6486 atomic_add_int(&stcb->asoc.stream_queue_cnt, 1);
6488 stcb->asoc.ss_functions.sctp_ss_add_to_stream(stcb, &stcb->asoc, strm, sp);
6652 struct sctp_tcb *stcb,
6661 sctp_sendall_iterator(struct sctp_inpcb *inp, struct sctp_tcb *stcb, void *ptr,
6695 SCTP_TCB_LOCK_ASSERT(stcb);
6696 if (stcb->asoc.alternate) {
6697 net = stcb->asoc.alternate;
6699 net = stcb->asoc.primary_destination;
6723 atomic_add_int(&stcb->asoc.refcnt, 1);
6724 sctp_abort_an_association(inp, stcb, m, false, SCTP_SO_NOT_LOCKED);
6732 * stcb will return to us un-locked.. since free_asoc
6736 SCTP_TCB_LOCK(stcb);
6737 atomic_subtract_int(&stcb->asoc.refcnt, 1);
6741 ret = sctp_msg_append(stcb, net, m, &ca->sndrcv);
6743 asoc = &stcb->asoc;
6748 sctp_is_there_unsent_data(stcb, SCTP_SO_NOT_LOCKED) == 0) {
6749 if ((*asoc->ss_functions.sctp_ss_is_user_msgs_incomplete) (stcb, asoc)) {
6756 if ((SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_SENT) &&
6757 (SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_RECEIVED) &&
6758 (SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_ACK_SENT)) {
6763 if (SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) {
6766 SCTP_SET_STATE(stcb, SCTP_STATE_SHUTDOWN_SENT);
6767 sctp_stop_timers_for_shutdown(stcb);
6768 sctp_send_shutdown(stcb, net);
6769 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN, stcb->sctp_ep, stcb,
6771 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, stcb->sctp_ep, stcb,
6787 if ((SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_SENT) &&
6788 (SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_RECEIVED) &&
6789 (SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_ACK_SENT)) {
6790 if ((*asoc->ss_functions.sctp_ss_is_user_msgs_incomplete) (stcb, asoc)) {
6791 SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_PARTIAL_MSG_LEFT);
6793 SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_SHUTDOWN_PENDING);
6805 atomic_add_int(&stcb->asoc.refcnt, 1);
6806 sctp_abort_an_association(stcb->sctp_ep, stcb,
6808 atomic_subtract_int(&stcb->asoc.refcnt, 1);
6815 un_sent = ((stcb->asoc.total_output_queue_size - stcb->asoc.total_flight) +
6816 (stcb->asoc.stream_queue_cnt * SCTP_DATA_CHUNK_OVERHEAD(stcb)));
6819 (stcb->asoc.total_flight > 0) &&
6820 (un_sent < (int)(stcb->asoc.smallest_mtu - SCTP_MIN_OVERHEAD))) {
6824 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_USR_SEND, SCTP_SO_NOT_LOCKED);
6829 (void)sctp_med_chunk_output(inp, stcb, &stcb->asoc, &num_out,
6831 sctp_get_frag_point(stcb),
6991 sctp_toss_old_cookies(struct sctp_tcb *stcb, struct sctp_association *asoc)
7003 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED);
7009 sctp_toss_old_asconf(struct sctp_tcb *stcb)
7015 asoc = &stcb->asoc;
7032 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED);
7038 sctp_clean_up_datalist(struct sctp_tcb *stcb,
7112 sctp_total_flight_increase(stcb, data_list[i]);
7119 if (asoc->peers_rwnd < stcb->sctp_ep->sctp_ep.sctp_sws_sender) {
7125 (*asoc->cc_functions.sctp_cwnd_update_packet_transmitted) (stcb, net);
7130 sctp_clean_up_ctl(struct sctp_tcb *stcb, struct sctp_association *asoc, int so_locked)
7158 sctp_free_a_chunk(stcb, chk, so_locked);
7169 sctp_can_we_split_this(struct sctp_tcb *stcb, uint32_t length,
7188 if (stcb->asoc.total_flight == 0) {
7207 if (SCTP_SB_LIMIT_SND(stcb->sctp_socket) < frag_point) {
7228 sctp_move_to_outqueue(struct sctp_tcb *stcb,
7249 SCTP_TCB_LOCK_ASSERT(stcb);
7250 asoc = &stcb->asoc;
7259 if ((sctp_is_feature_on(stcb->sctp_ep, SCTP_PCB_FLAGS_EXPLICIT_EOR) == 0) &&
7260 (stcb->asoc.idata_supported == 0) &&
7287 stcb->asoc.ss_functions.sctp_ss_remove_from_stream(stcb, asoc, strq, sp);
7291 stcb->asoc.trigger_reset = 1;
7301 sctp_free_a_strmoq(stcb, sp, so_locked);
7322 atomic_subtract_int(&stcb->asoc.total_output_queue_size, sp->length);
7323 if ((stcb->sctp_socket != NULL) &&
7324 ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
7325 (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL))) {
7326 SCTP_SB_DECR(&stcb->sctp_socket->so_snd, sp->length);
7364 to_move = sctp_can_we_split_this(stcb, length, space_left, frag_point, eeor_mode);
7382 sctp_alloc_a_chunk(stcb, chk);
7422 sctp_free_a_chunk(stcb, chk, so_locked);
7487 leading = SCTP_DATA_CHUNK_OVERHEAD(stcb);
7515 sctp_free_a_chunk(stcb, chk, so_locked);
7525 SCTP_BUF_PREPEND(chk->data, SCTP_DATA_CHUNK_OVERHEAD(stcb), M_NOWAIT);
7532 sctp_free_a_chunk(stcb, chk, so_locked);
7538 sctp_snd_sb_alloc(stcb, SCTP_DATA_CHUNK_OVERHEAD(stcb));
7539 chk->book_size = chk->send_size = (uint16_t)(to_move + SCTP_DATA_CHUNK_OVERHEAD(stcb));
7544 chk->asoc = &stcb->asoc;
7547 if (stcb->asoc.idata_supported == 0) {
7586 sctp_auth_key_acquire(stcb, chk->auth_keyid);
7589 stcb->asoc.ss_functions.sctp_ss_scheduled(stcb, net, asoc, strq, to_move);
7593 (uint32_t)(uintptr_t)stcb, sp->length,
7597 if (stcb->asoc.idata_supported == 0) {
7607 SCTP_TCB_LOCK_ASSERT(stcb);
7618 asoc->out_tsnlog[asoc->tsn_out_at].stcb = (void *)stcb;
7623 if (stcb->asoc.idata_supported == 0) {
7674 stcb->asoc.ss_functions.sctp_ss_remove_from_stream(stcb, asoc, strq, sp);
7678 stcb->asoc.trigger_reset = 1;
7688 sctp_free_a_strmoq(stcb, sp, so_locked);
7699 sctp_fill_outqueue(struct sctp_tcb *stcb, struct sctp_nets *net,
7708 SCTP_TCB_LOCK_ASSERT(stcb);
7709 asoc = &stcb->asoc;
7728 space_left -= SCTP_DATA_CHUNK_OVERHEAD(stcb);
7732 strq = stcb->asoc.ss_functions.sctp_ss_select_stream(stcb, net, asoc);
7736 moved = sctp_move_to_outqueue(stcb, net, strq, space_left,
7742 strq = stcb->asoc.ss_functions.sctp_ss_select_stream(stcb, net, asoc);
7749 if (space_left >= SCTP_DATA_CHUNK_OVERHEAD(stcb)) {
7750 space_left -= SCTP_DATA_CHUNK_OVERHEAD(stcb);
7759 stcb->asoc.ss_functions.sctp_ss_packet_done(stcb, net, asoc);
7762 if ((stcb->asoc.sctp_cmt_on_off == 0) &&
7763 (net == stcb->asoc.primary_destination)) {
7766 } else if (stcb->asoc.sctp_cmt_on_off > 0) {
7786 sctp_move_chunks_from_net(struct sctp_tcb *stcb, struct sctp_nets *net)
7796 asoc = &stcb->asoc;
7797 for (i = 0; i < stcb->asoc.streamoutcnt; i++) {
7798 TAILQ_FOREACH(sp, &stcb->asoc.strmout[i].outqueue, next) {
7815 struct sctp_tcb *stcb,
7864 auth_keyid = stcb->asoc.authinfo.active_keyid;
7866 (SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_RECEIVED) ||
7881 SCTP_TCB_LOCK_ASSERT(stcb);
7890 (asoc->ctrl_queue_cnt == stcb->asoc.ecn_echo_cnt_onq)) &&
7893 sctp_is_there_unsent_data(stcb, so_locked) == 0) {
7906 if (stcb->asoc.ecn_echo_cnt_onq) {
7909 (asoc->ctrl_queue_cnt == stcb->asoc.ecn_echo_cnt_onq)) {
7922 if (stcb->sctp_socket)
7923 max_send_per_dest = SCTP_SB_LIMIT_SND(stcb->sctp_socket) / asoc->numnets;
7941 (!stcb->asoc.ss_functions.sctp_ss_is_empty(stcb, asoc))) {
7955 if ((net != stcb->asoc.alternate) &&
7960 sctp_log_cwnd(stcb, net, 1,
7965 if ((stcb->asoc.cc_functions.sctp_cwnd_new_transmission_begins) &&
7967 (*stcb->asoc.cc_functions.sctp_cwnd_new_transmission_begins) (stcb, net);
7972 sctp_log_cwnd(stcb, net, 3,
7978 sctp_log_cwnd(stcb, net, 4, SCTP_CWND_LOG_FILL_OUTQ_CALLED);
7980 sctp_fill_outqueue(stcb, net, frag_point, eeor_mode, &quit_now, so_locked);
8124 stcb->asoc.peer_auth_chunks)) {
8125 omtu = sctp_get_auth_chunk_len(stcb->asoc.peer_hmac_id);
8147 stcb->asoc.peer_auth_chunks))) {
8152 stcb,
8161 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
8201 sctp_timer_start(SCTP_TIMER_TYPE_ASCONF, inp, stcb, net);
8213 if ((error = sctp_lowlevel_chunk_output(inp, stcb, net,
8216 stcb->asoc.authinfo.active_keyid,
8218 inp->sctp_lport, stcb->rport,
8219 htonl(stcb->asoc.peer_vtag),
8242 sctp_move_chunks_from_net(stcb, net);
8351 stcb->asoc.peer_auth_chunks)) {
8352 omtu = sctp_get_auth_chunk_len(stcb->asoc.peer_hmac_id);
8374 stcb->asoc.peer_auth_chunks))) {
8379 stcb,
8388 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
8423 if (SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) {
8425 inp, stcb, NULL,
8479 sctp_timer_start(SCTP_TIMER_TYPE_ASCONF, inp, stcb, net);
8489 sctp_timer_start(SCTP_TIMER_TYPE_COOKIE, inp, stcb, net);
8502 if ((error = sctp_lowlevel_chunk_output(inp, stcb, net,
8506 stcb->asoc.authinfo.active_keyid,
8508 inp->sctp_lport, stcb->rport,
8509 htonl(stcb->asoc.peer_vtag),
8531 sctp_move_chunks_from_net(stcb, net);
8578 (net != stcb->asoc.alternate) &&
8612 stcb->asoc.peer_auth_chunks);
8614 mtu -= sctp_get_auth_chunk_len(stcb->asoc.peer_hmac_id);
8639 if ((((SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) ||
8640 (SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_RECEIVED)) &&
8710 stcb,
8735 sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, net);
8738 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
8791 if ((one_chunk) && (stcb->asoc.total_flight == 0)) {
8820 stcb, net);
8829 sctp_timer_start(SCTP_TIMER_TYPE_COOKIE, inp, stcb, net);
8839 sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, net);
8851 stcb,
8861 inp->sctp_lport, stcb->rport,
8862 htonl(stcb->asoc.peer_vtag),
8881 sctp_move_chunks_from_net(stcb, net);
8920 sctp_clean_up_datalist(stcb, asoc, data_list, bundle_at, net);
8927 sctp_log_cwnd(stcb, net, tsns_sent, SCTP_CWND_LOG_FROM_SEND);
8942 sctp_log_cwnd(stcb, net, *num_out, SCTP_CWND_LOG_FROM_SEND);
8949 sctp_clean_up_ctl(stcb, asoc, so_locked);
8954 sctp_queue_op_err(struct sctp_tcb *stcb, struct mbuf *op_err)
8966 SCTP_TCB_LOCK_ASSERT(stcb);
8993 sctp_alloc_a_chunk(stcb, chk);
9006 chk->asoc = &stcb->asoc;
9020 struct sctp_tcb *stcb,
9034 SCTP_TCB_LOCK_ASSERT(stcb);
9083 sctp_alloc_a_chunk(stcb, chk);
9096 chk->asoc = &stcb->asoc;
9106 sctp_send_heartbeat_ack(struct sctp_tcb *stcb,
9139 sctp_alloc_a_chunk(stcb, chk);
9152 chk->asoc = &stcb->asoc;
9161 sctp_send_cookie_ack(struct sctp_tcb *stcb)
9168 SCTP_TCB_LOCK_ASSERT(stcb);
9176 sctp_alloc_a_chunk(stcb, chk);
9189 chk->asoc = &stcb->asoc;
9208 sctp_send_shutdown_ack(struct sctp_tcb *stcb, struct sctp_nets *net)
9221 sctp_alloc_a_chunk(stcb, chk);
9234 chk->asoc = &stcb->asoc;
9251 sctp_send_shutdown(struct sctp_tcb *stcb, struct sctp_nets *net)
9258 TAILQ_FOREACH(chk, &stcb->asoc.control_send_queue, sctp_next) {
9275 sctp_alloc_a_chunk(stcb, chk);
9288 chk->asoc = &stcb->asoc;
9298 shutdown_cp->cumulative_tsn_ack = htonl(stcb->asoc.cumulative_tsn);
9303 TAILQ_REMOVE(&stcb->asoc.control_send_queue, chk, sctp_next);
9309 shutdown_cp->cumulative_tsn_ack = htonl(stcb->asoc.cumulative_tsn);
9310 TAILQ_INSERT_TAIL(&stcb->asoc.control_send_queue, chk, sctp_next);
9316 sctp_send_asconf(struct sctp_tcb *stcb, struct sctp_nets *net, int addr_locked)
9326 SCTP_TCB_LOCK_ASSERT(stcb);
9328 if ((!TAILQ_EMPTY(&stcb->asoc.asconf_send_queue)) &&
9329 (!sctp_is_feature_on(stcb->sctp_ep, SCTP_PCB_FLAGS_MULTIPLE_ASCONFS))) {
9335 m_asconf = sctp_compose_asconf(stcb, &len, addr_locked);
9340 sctp_alloc_a_chunk(stcb, chk);
9355 chk->asoc = &stcb->asoc;
9366 sctp_send_asconf_ack(struct sctp_tcb *stcb)
9377 SCTP_TCB_LOCK_ASSERT(stcb);
9379 latest_ack = TAILQ_LAST(&stcb->asoc.asconf_ack_sent, sctp_asconf_ackhead);
9384 latest_ack->last_sent_to == stcb->asoc.last_control_chunk_from) {
9386 net = sctp_find_alternate_net(stcb, stcb->asoc.last_control_chunk_from, 0);
9389 if (stcb->asoc.last_control_chunk_from == NULL) {
9390 if (stcb->asoc.alternate) {
9391 net = stcb->asoc.alternate;
9393 net = stcb->asoc.primary_destination;
9396 net = stcb->asoc.last_control_chunk_from;
9401 if (stcb->asoc.last_control_chunk_from == NULL) {
9402 if (stcb->asoc.alternate) {
9403 net = stcb->asoc.alternate;
9405 net = stcb->asoc.primary_destination;
9408 net = stcb->asoc.last_control_chunk_from;
9413 TAILQ_FOREACH(ack, &stcb->asoc.asconf_ack_sent, next) {
9430 sctp_alloc_a_chunk(stcb, chk);
9449 chk->asoc = &stcb->asoc;
9459 struct sctp_tcb *stcb,
9491 SCTP_TCB_LOCK_ASSERT(stcb);
9498 auth_keyid = stcb->asoc.authinfo.active_keyid;
9538 stcb->asoc.peer_auth_chunks))) {
9541 stcb,
9562 sctp_timer_start(SCTP_TIMER_TYPE_COOKIE, inp, stcb, chk->whoTo);
9566 sctp_timer_start(SCTP_TIMER_TYPE_ASCONF, inp, stcb, chk->whoTo);
9570 if ((error = sctp_lowlevel_chunk_output(inp, stcb, chk->whoTo,
9572 auth_offset, auth, stcb->asoc.authinfo.active_keyid,
9574 inp->sctp_lport, stcb->rport, htonl(stcb->asoc.peer_vtag),
9598 sctp_ucount_decr(stcb->asoc.sent_queue_retran_cnt);
9603 sctp_clean_up_ctl(stcb, asoc, so_locked);
9614 if ((SCTP_GET_STATE(stcb) == SCTP_STATE_COOKIE_ECHOED) ||
9615 (SCTP_GET_STATE(stcb) == SCTP_STATE_COOKIE_WAIT)) {
9620 sctp_auditing(20, inp, stcb, NULL);
9622 data_auth_reqd = sctp_auth_is_required_chunk(SCTP_DATA, stcb->asoc.peer_auth_chunks);
9642 atomic_add_int(&stcb->asoc.refcnt, 1);
9643 sctp_abort_an_association(stcb->sctp_ep, stcb, op_err,
9645 SCTP_TCB_LOCK(stcb);
9646 atomic_subtract_int(&stcb->asoc.refcnt, 1);
9723 dmtu = sctp_get_auth_chunk_len(stcb->asoc.peer_hmac_id);
9736 stcb,
9751 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
9783 dmtu = sctp_get_auth_chunk_len(stcb->asoc.peer_hmac_id);
9793 stcb,
9811 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
9844 sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, net);
9856 if ((error = sctp_lowlevel_chunk_output(inp, stcb, net,
9860 inp->sctp_lport, stcb->rport, htonl(stcb->asoc.peer_vtag),
9950 sctp_total_flight_increase(stcb, data_list[i]);
9951 if (asoc->peers_rwnd < stcb->sctp_ep->sctp_ep.sctp_sws_sender) {
9969 sctp_timer_stop(SCTP_TIMER_TYPE_SEND, inp, stcb, net,
9971 sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, net);
9976 sctp_log_cwnd(stcb, net, tsns_sent, SCTP_CWND_LOG_FROM_RESEND);
9979 sctp_auditing(21, inp, stcb, NULL);
10002 struct sctp_tcb *stcb,
10014 SCTP_TCB_LOCK_ASSERT(stcb);
10018 sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, asoc->alternate);
10020 sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, asoc->primary_destination);
10027 struct sctp_tcb *stcb,
10051 uint32_t frag_point = sctp_get_frag_point(stcb);
10056 asoc = &stcb->asoc;
10068 SCTP_TCB_LOCK_ASSERT(stcb);
10070 un_sent = (stcb->asoc.total_output_queue_size - stcb->asoc.total_flight);
10084 if (SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) {
10085 sctp_send_sack(stcb, so_locked);
10086 sctp_timer_stop(SCTP_TIMER_TYPE_RECV, stcb->sctp_ep, stcb, NULL,
10100 (void)sctp_med_chunk_output(inp, stcb, asoc, &num_out, &reason_code, 1,
10107 ret = sctp_chunk_retransmission(inp, stcb, asoc, &num_out, &now, &now_filled, &fr_done, so_locked);
10125 (void)sctp_med_chunk_output(inp, stcb, asoc, &num_out, &reason_code, 1,
10129 sctp_auditing(8, inp, stcb, NULL);
10131 sctp_timer_validation(inp, stcb, asoc);
10140 sctp_auditing(9, inp, stcb, NULL);
10150 sctp_auditing(10, inp, stcb, NULL);
10153 (void)sctp_med_chunk_output(inp, stcb, asoc, &num_out, &reason_code, 1, from_where,
10167 sctp_auditing(12, inp, stcb, NULL);
10180 sctp_move_chunks_from_net(stcb, net);
10195 asoc->cc_functions.sctp_cwnd_update_after_output(stcb, net, asoc->max_burst);
10197 sctp_log_maxburst(stcb, net, 0, asoc->max_burst, SCTP_MAX_BURST_APPLIED);
10216 error = sctp_med_chunk_output(inp, stcb, asoc, &num_out,
10222 sctp_log_maxburst(stcb, asoc->primary_destination, error, burst_cnt, SCTP_MAX_BURST_ERROR_STOP);
10225 sctp_log_cwnd(stcb, NULL, error, SCTP_SEND_NOW_COMPLETES);
10226 sctp_log_cwnd(stcb, NULL, 0xdeadbeef, SCTP_SEND_NOW_COMPLETES);
10235 sctp_log_cwnd(stcb, NULL, num_out, SCTP_SEND_NOW_COMPLETES);
10237 sctp_log_cwnd(stcb, NULL, reason_code, SCTP_SEND_NOW_COMPLETES);
10247 un_sent = stcb->asoc.total_output_queue_size - stcb->asoc.total_flight;
10248 if ((un_sent < (int)(stcb->asoc.smallest_mtu - SCTP_MIN_OVERHEAD)) &&
10249 (stcb->asoc.total_flight > 0)) {
10256 sctp_is_there_unsent_data(stcb, so_locked) == 0) {
10260 if ((stcb->asoc.total_output_queue_size - stcb->asoc.total_flight) <= 0) {
10274 sctp_log_maxburst(stcb, asoc->primary_destination, 0, burst_cnt, SCTP_MAX_BURST_APPLIED);
10281 sctp_log_cwnd(stcb, NULL, tot_out, SCTP_SEND_NOW_COMPLETES);
10291 if (stcb->asoc.ecn_echo_cnt_onq)
10294 if (stcb->asoc.trigger_reset) {
10295 if (sctp_send_stream_reset_out_if_possible(stcb, so_locked) == 0) {
10330 send_forward_tsn(struct sctp_tcb *stcb,
10342 SCTP_TCB_LOCK_ASSERT(stcb);
10357 sctp_alloc_a_chunk(stcb, chk);
10375 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED);
10410 if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
10544 sctp_send_sack(struct sctp_tcb *stcb, int so_locked)
10572 if (stcb->asoc.nrsack_supported == 1) {
10578 asoc = &stcb->asoc;
10579 SCTP_TCB_LOCK_ASSERT(stcb);
10584 sctp_slide_mapping_arrays(stcb);
10585 sctp_set_rwnd(stcb, asoc);
10604 sctp_alloc_a_chunk(stcb, a_chk);
10607 if (stcb->asoc.delayed_ack) {
10609 stcb->sctp_ep, stcb, NULL,
10612 stcb->sctp_ep, stcb, NULL);
10614 stcb->asoc.send_sack = 1;
10637 a_chk->whoTo = sctp_find_alternate_net(stcb, asoc->last_data_chunk_from, 0);
10674 sctp_free_a_chunk(stcb, a_chk, so_locked);
10676 if (stcb->asoc.delayed_ack) {
10678 stcb->sctp_ep, stcb, NULL,
10681 stcb->sctp_ep, stcb, NULL);
10683 stcb->asoc.send_sack = 1;
10709 stcb->asoc.cumack_logsnt[stcb->asoc.cumack_log_atsnt] = asoc->cumulative_tsn;
10710 stcb->asoc.cumack_log_atsnt++;
10711 if (stcb->asoc.cumack_log_atsnt >= SCTP_TSN_LOG_SIZE) {
10712 stcb->asoc.cumack_log_atsnt = 0;
10716 stcb->freed_by_sorcv_sincelast = 0;
10937 sctp_send_abort_tcb(struct sctp_tcb *stcb, struct mbuf *operr, int so_locked)
10950 SCTP_TCB_LOCK_ASSERT(stcb);
10956 stcb->asoc.peer_auth_chunks)) {
10958 stcb, SCTP_ABORT_ASSOCIATION);
10963 switch (stcb->asoc.snd_edmid) {
11002 if (stcb->asoc.alternate) {
11003 net = stcb->asoc.alternate;
11005 net = stcb->asoc.primary_destination;
11010 if (stcb->asoc.peer_vtag == 0) {
11012 vtag = stcb->asoc.my_vtag;
11015 vtag = stcb->asoc.peer_vtag;
11027 if ((error = sctp_lowlevel_chunk_output(stcb->sctp_ep, stcb, net,
11029 m_out, auth_offset, auth, stcb->asoc.authinfo.active_keyid, 1, 0, 0,
11030 stcb->sctp_ep->sctp_lport, stcb->rport, htonl(vtag),
11031 stcb->asoc.primary_destination->port, NULL,
11037 stcb->asoc.ifp_had_enobuf = 1;
11041 stcb->asoc.ifp_had_enobuf = 0;
11047 sctp_send_shutdown_complete(struct sctp_tcb *stcb,
11066 vtag = stcb->asoc.my_vtag;
11069 vtag = stcb->asoc.peer_vtag;
11071 switch (stcb->asoc.snd_edmid) {
11084 if ((error = sctp_lowlevel_chunk_output(stcb->sctp_ep, stcb, net,
11087 stcb->sctp_ep->sctp_lport, stcb->rport,
11095 stcb->asoc.ifp_had_enobuf = 1;
11099 stcb->asoc.ifp_had_enobuf = 0;
11373 sctp_send_hb(struct sctp_tcb *stcb, struct sctp_nets *net, int so_locked)
11379 SCTP_TCB_LOCK_ASSERT(stcb);
11396 sctp_alloc_a_chunk(stcb, chk);
11406 chk->asoc = &stcb->asoc;
11411 sctp_free_a_chunk(stcb, chk, so_locked);
11440 net->heartbeat_random1 = hb->heartbeat.hb_info.random_value1 = sctp_select_initial_TSN(&stcb->sctp_ep->sctp_ep);
11441 net->heartbeat_random2 = hb->heartbeat.hb_info.random_value2 = sctp_select_initial_TSN(&stcb->sctp_ep->sctp_ep);
11466 sctp_free_a_chunk(stcb, chk, so_locked);
11471 TAILQ_INSERT_TAIL(&stcb->asoc.control_send_queue, chk, sctp_next);
11472 stcb->asoc.ctrl_queue_cnt++;
11478 sctp_send_ecn_echo(struct sctp_tcb *stcb, struct sctp_nets *net,
11488 asoc = &stcb->asoc;
11489 SCTP_TCB_LOCK_ASSERT(stcb);
11508 sctp_alloc_a_chunk(stcb, chk);
11517 chk->asoc = &stcb->asoc;
11521 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED);
11531 stcb->asoc.ecn_echo_cnt_onq++;
11538 TAILQ_INSERT_HEAD(&stcb->asoc.control_send_queue, chk, sctp_next);
11543 sctp_send_packet_dropped(struct sctp_tcb *stcb, struct sctp_nets *net,
11557 if (!stcb) {
11560 asoc = &stcb->asoc;
11561 SCTP_TCB_LOCK_ASSERT(stcb);
11568 if (stcb->sctp_socket == NULL) {
11571 sctp_alloc_a_chunk(stcb, chk);
11601 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED);
11612 min(stcb->asoc.smallest_mtu, MCLBYTES)) {
11617 len = min(stcb->asoc.smallest_mtu, MCLBYTES) - SCTP_MAX_OVERHEAD;
11620 chk->asoc = &stcb->asoc;
11624 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED);
11667 spc = SCTP_SB_LIMIT_RCV(stcb->sctp_socket);
11676 SCTP_SBAVAIL(&stcb->sctp_socket->so_rcv));
11687 TAILQ_INSERT_TAIL(&stcb->asoc.control_send_queue, chk, sctp_next);
11692 sctp_send_cwr(struct sctp_tcb *stcb, struct sctp_nets *net, uint32_t high_tsn, uint8_t override)
11698 SCTP_TCB_LOCK_ASSERT(stcb);
11702 asoc = &stcb->asoc;
11723 sctp_alloc_a_chunk(stcb, chk);
11735 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED);
11754 sctp_add_stream_reset_out(struct sctp_tcb *stcb, struct sctp_tmit_chunk *chk,
11768 for (i = 0; i < stcb->asoc.streamoutcnt; i++) {
11769 if ((stcb->asoc.strmout[i].state == SCTP_STREAM_RESET_PENDING) &&
11770 (stcb->asoc.strmout[i].chunks_on_queues == 0) &&
11771 TAILQ_EMPTY(&stcb->asoc.strmout[i].outqueue)) {
11778 if (number_entries == stcb->asoc.streamoutcnt) {
11792 for (i = 0; i < stcb->asoc.streamoutcnt; i++) {
11793 if ((stcb->asoc.strmout[i].state == SCTP_STREAM_RESET_PENDING) &&
11794 (stcb->asoc.strmout[i].chunks_on_queues == 0) &&
11795 TAILQ_EMPTY(&stcb->asoc.strmout[i].outqueue)) {
11798 stcb->asoc.strmout[i].state = SCTP_STREAM_RESET_IN_FLIGHT;
11805 for (i = 0; i < stcb->asoc.streamoutcnt; i++) {
11806 stcb->asoc.strmout[i].state = SCTP_STREAM_RESET_IN_FLIGHT;
11925 sctp_send_deferred_reset_response(struct sctp_tcb *stcb,
11933 asoc = &stcb->asoc;
11944 sctp_alloc_a_chunk(stcb, chk);
11946 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
11953 chk->asoc = &stcb->asoc;
11959 sctp_free_a_chunk(stcb, chk, SCTP_SO_LOCKED);
11960 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
11967 if (stcb->asoc.alternate) {
11968 chk->whoTo = stcb->asoc.alternate;
11970 chk->whoTo = stcb->asoc.primary_destination;
12084 sctp_send_stream_reset_out_if_possible(struct sctp_tcb *stcb, int so_locked)
12091 asoc = &stcb->asoc;
12096 sctp_alloc_a_chunk(stcb, chk);
12098 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
12105 chk->asoc = &stcb->asoc;
12111 sctp_free_a_chunk(stcb, chk, so_locked);
12112 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
12120 if (stcb->asoc.alternate) {
12121 chk->whoTo = stcb->asoc.alternate;
12123 chk->whoTo = stcb->asoc.primary_destination;
12131 seq = stcb->asoc.str_reset_seq_out;
12132 if (sctp_add_stream_reset_out(stcb, chk, seq, (stcb->asoc.str_reset_seq_in - 1), (stcb->asoc.sending_seq - 1))) {
12138 sctp_free_a_chunk(stcb, chk, so_locked);
12148 if (stcb->asoc.send_sack) {
12149 sctp_send_sack(stcb, so_locked);
12151 sctp_timer_start(SCTP_TIMER_TYPE_STRRESET, stcb->sctp_ep, stcb, chk->whoTo);
12156 sctp_send_str_reset_req(struct sctp_tcb *stcb,
12170 SCTP_TCB_LOCK_ASSERT(stcb);
12172 asoc = &stcb->asoc;
12177 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EBUSY);
12183 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EINVAL);
12188 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EINVAL);
12198 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
12201 sctp_alloc_a_chunk(stcb, chk);
12203 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
12210 chk->asoc = &stcb->asoc;
12216 sctp_free_a_chunk(stcb, chk, SCTP_SO_LOCKED);
12217 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
12225 if (stcb->asoc.alternate) {
12226 chk->whoTo = stcb->asoc.alternate;
12228 chk->whoTo = stcb->asoc.primary_destination;
12237 seq = stcb->asoc.str_reset_seq_out;
12241 ret = sctp_add_stream_reset_out(stcb, chk, seq, (stcb->asoc.str_reset_seq_in - 1), (stcb->asoc.sending_seq - 1));
12248 ((stcb->asoc.strm_realoutsize - stcb->asoc.streamoutcnt) < adding_o)) {
12257 oldstream = stcb->asoc.strmout;
12259 SCTP_MALLOC(stcb->asoc.strmout, struct sctp_stream_out *,
12260 (stcb->asoc.streamoutcnt + adding_o) * sizeof(struct sctp_stream_out),
12262 if (stcb->asoc.strmout == NULL) {
12265 stcb->asoc.strmout = oldstream;
12275 stcb->asoc.ss_functions.sctp_ss_clear(stcb, &stcb->asoc, false);
12276 for (i = 0; i < stcb->asoc.streamoutcnt; i++) {
12277 TAILQ_INIT(&stcb->asoc.strmout[i].outqueue);
12283 stcb->asoc.ss_functions.sctp_ss_init_stream(stcb, &stcb->asoc.strmout[i], &oldstream[i]);
12284 stcb->asoc.strmout[i].chunks_on_queues = oldstream[i].chunks_on_queues;
12287 stcb->asoc.strmout[i].abandoned_sent[j] = oldstream[i].abandoned_sent[j];
12288 stcb->asoc.strmout[i].abandoned_unsent[j] = oldstream[i].abandoned_unsent[j];
12291 stcb->asoc.strmout[i].abandoned_sent[0] = oldstream[i].abandoned_sent[0];
12292 stcb->asoc.strmout[i].abandoned_unsent[0] = oldstream[i].abandoned_unsent[0];
12294 stcb->asoc.strmout[i].next_mid_ordered = oldstream[i].next_mid_ordered;
12295 stcb->asoc.strmout[i].next_mid_unordered = oldstream[i].next_mid_unordered;
12296 stcb->asoc.strmout[i].last_msg_incomplete = oldstream[i].last_msg_incomplete;
12297 stcb->asoc.strmout[i].sid = i;
12298 stcb->asoc.strmout[i].state = oldstream[i].state;
12302 TAILQ_INSERT_TAIL(&stcb->asoc.strmout[i].outqueue, sp, next);
12306 stcb->asoc.ss_functions.sctp_ss_init(stcb, &stcb->asoc);
12307 for (i = stcb->asoc.streamoutcnt; i < (stcb->asoc.streamoutcnt + adding_o); i++) {
12308 TAILQ_INIT(&stcb->asoc.strmout[i].outqueue);
12309 stcb->asoc.strmout[i].chunks_on_queues = 0;
12312 stcb->asoc.strmout[i].abandoned_sent[j] = 0;
12313 stcb->asoc.strmout[i].abandoned_unsent[j] = 0;
12316 stcb->asoc.strmout[i].abandoned_sent[0] = 0;
12317 stcb->asoc.strmout[i].abandoned_unsent[0] = 0;
12319 stcb->asoc.strmout[i].next_mid_ordered = 0;
12320 stcb->asoc.strmout[i].next_mid_unordered = 0;
12321 stcb->asoc.strmout[i].sid = i;
12322 stcb->asoc.strmout[i].last_msg_incomplete = 0;
12323 stcb->asoc.ss_functions.sctp_ss_init_stream(stcb, &stcb->asoc.strmout[i], NULL);
12324 stcb->asoc.strmout[i].state = SCTP_STREAM_CLOSED;
12326 stcb->asoc.strm_realoutsize = stcb->asoc.streamoutcnt + adding_o;
12357 if (stcb->asoc.send_sack) {
12358 sctp_send_sack(stcb, SCTP_SO_LOCKED);
12360 sctp_timer_start(SCTP_TIMER_TYPE_STRRESET, stcb->sctp_ep, stcb, chk->whoTo);
12433 sctp_copy_it_in(struct sctp_tcb *stcb,
12446 * when you need to do something that may effect the stcb/asoc. The
12454 sctp_alloc_a_strmoq(stcb, sp);
12456 SCTP_LTRACE_ERR_RET(NULL, stcb, net, SCTP_FROM_SCTP_OUTPUT, ENOMEM);
12481 resv_in_first = SCTP_DATA_CHUNK_OVERHEAD(stcb);
12489 sp->auth_keyid = stcb->asoc.authinfo.active_keyid;
12491 if (sctp_auth_is_required_chunk(SCTP_DATA, stcb->asoc.peer_auth_chunks)) {
12492 sctp_auth_key_acquire(stcb, sp->auth_keyid);
12498 sctp_free_a_strmoq(stcb, sp, SCTP_SO_LOCKED);
12577 struct sctp_tcb *stcb = NULL;
12603 stcb = NULL;
12710 stcb = LIST_FIRST(&inp->sctp_asoc_list);
12711 if (stcb != NULL) {
12712 SCTP_TCB_LOCK(stcb);
12716 stcb = sctp_findasoc_ep_asocid_locked(inp, sinfo_assoc_id, 1);
12718 if (stcb != NULL) {
12719 SCTP_TCB_LOCK_ASSERT(stcb);
12729 stcb = sctp_findassociation_ep_addr(&t_inp, addr, &net, NULL, NULL);
12730 if (stcb == NULL) {
12735 SCTP_TCB_LOCK_ASSERT(stcb);
12742 if (stcb != NULL) {
12743 SCTP_TCB_LOCK_ASSERT(stcb);
12747 if ((stcb == NULL) && (addr != NULL)) {
12765 stcb = sctp_findassociation_ep_addr(&t_inp, addr, &net, NULL, NULL);
12767 if ((stcb == NULL) && (control != NULL) && (port > 0)) {
12768 stcb = sctp_findassociation_cmsgs(&t_inp, port, control, &net, &error);
12771 if (stcb == NULL) {
12776 SCTP_TCB_LOCK_ASSERT(stcb);
12788 if (stcb == NULL) {
12805 /* get an asoc/stcb struct */
12808 stcb = sctp_aloc_assoc_connected(inp, addr, &error, 0, 0, vrf_id,
12813 if (stcb == NULL) {
12815 KASSERT(error != 0, ("error is 0 although stcb is NULL"));
12818 SCTP_TCB_LOCK_ASSERT(stcb);
12826 SCTP_SET_STATE(stcb, SCTP_STATE_COOKIE_WAIT);
12827 (void)SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered);
12829 if (sctp_process_cmsgs_for_init(stcb, control, &error)) {
12830 sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC,
12832 stcb = NULL;
12850 KASSERT(stcb != NULL, ("stcb is NULL"));
12851 SCTP_TCB_LOCK_ASSERT(stcb);
12853 asoc = &stcb->asoc;
12864 if ((SCTP_GET_STATE(stcb) == SCTP_STATE_COOKIE_WAIT) ||
12865 (SCTP_GET_STATE(stcb) == SCTP_STATE_COOKIE_ECHOED)) {
12868 /* Keep the stcb from being freed under our feet. */
12890 if ((SCTP_GET_STATE(stcb) == SCTP_STATE_COOKIE_WAIT) ||
12891 (SCTP_GET_STATE(stcb) == SCTP_STATE_COOKIE_ECHOED)) {
12931 SCTP_TCB_UNLOCK(stcb);
12933 SCTP_TCB_LOCK(stcb);
12967 sctp_abort_an_association(stcb->sctp_ep, stcb, mm, false, SCTP_SO_LOCKED);
12969 stcb = NULL;
12981 KASSERT(stcb != NULL, ("stcb is NULL"));
12982 SCTP_TCB_LOCK_ASSERT(stcb);
12990 net = sctp_findnet(stcb, addr);
12995 ((port != 0) && (port != stcb->rport))) {
13040 atomic_add_int(&stcb->total_sends, 1);
13047 inqueue_bytes = asoc->total_output_queue_size - (asoc->chunks_on_out_queue * SCTP_DATA_CHUNK_OVERHEAD(stcb));
13067 KASSERT(stcb != NULL, ("stcb is NULL"));
13068 SCTP_TCB_LOCK_ASSERT(stcb);
13079 inqueue_bytes = asoc->total_output_queue_size - (asoc->chunks_on_out_queue * SCTP_DATA_CHUNK_OVERHEAD(stcb));
13087 (sndlen > (ssize_t)SCTP_SB_LIMIT_SND(stcb->sctp_socket))) {
13108 inqueue_bytes = asoc->total_output_queue_size - (asoc->chunks_on_out_queue * SCTP_DATA_CHUNK_OVERHEAD(stcb));
13123 stcb->block_entry = &be;
13124 SCTP_TCB_UNLOCK(stcb);
13135 SCTP_TCB_LOCK(stcb);
13136 stcb->block_entry = NULL;
13157 inqueue_bytes = asoc->total_output_queue_size - (asoc->chunks_on_out_queue * SCTP_DATA_CHUNK_OVERHEAD(stcb));
13169 KASSERT(stcb != NULL, ("stcb is NULL"));
13170 SCTP_TCB_LOCK_ASSERT(stcb);
13193 SCTP_TCB_UNLOCK(stcb);
13194 sp = sctp_copy_it_in(stcb, asoc, sndrcvninfo, uio, net, max_len, user_marks_eor, &error);
13195 SCTP_TCB_LOCK(stcb);
13216 if ((SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_SENT) ||
13217 (SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_RECEIVED) ||
13218 (SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_ACK_SENT) ||
13230 sctp_free_a_strmoq(stcb, sp, SCTP_SO_LOCKED);
13251 sctp_snd_sb_alloc(stcb, sp->length);
13258 asoc->ss_functions.sctp_ss_add_to_stream(stcb, asoc, strm, sp);
13279 KASSERT(stcb != NULL, ("stcb is NULL"));
13280 SCTP_TCB_LOCK_ASSERT(stcb);
13290 inqueue_bytes = asoc->total_output_queue_size - (asoc->chunks_on_out_queue * SCTP_DATA_CHUNK_OVERHEAD(stcb));
13299 SCTP_TCB_UNLOCK(stcb);
13303 SCTP_TCB_LOCK(stcb);
13341 sctp_snd_sb_alloc(stcb, sndout);
13358 KASSERT(stcb != NULL, ("stcb is NULL"));
13359 SCTP_TCB_LOCK_ASSERT(stcb);
13375 sctp_prune_prsctp(stcb, asoc, sndrcvninfo, (int)sndlen);
13376 inqueue_bytes = asoc->total_output_queue_size - (asoc->chunks_on_out_queue * SCTP_DATA_CHUNK_OVERHEAD(stcb));
13395 if (SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) {
13400 sctp_send_initiate(inp, stcb, SCTP_SO_LOCKED);
13402 SCTP_SET_STATE(stcb, SCTP_STATE_COOKIE_WAIT);
13428 sctp_log_nagle_event(stcb, SCTP_NAGLE_APPLIED);
13435 sctp_log_nagle_event(stcb, SCTP_NAGLE_SKIPPED);
13459 sctp_chunk_output(inp, stcb,
13477 inqueue_bytes = asoc->total_output_queue_size - (asoc->chunks_on_out_queue * SCTP_DATA_CHUNK_OVERHEAD(stcb));
13486 stcb->block_entry = &be;
13487 SCTP_TCB_UNLOCK(stcb);
13497 SCTP_TCB_LOCK(stcb);
13498 stcb->block_entry = NULL;
13528 KASSERT(stcb != NULL, ("stcb is NULL"));
13529 SCTP_TCB_LOCK_ASSERT(stcb);
13559 error = sctp_msg_append(stcb, net, top, sndrcvninfo);
13570 KASSERT(stcb != NULL, ("stcb is NULL"));
13571 SCTP_TCB_LOCK_ASSERT(stcb);
13583 sctp_is_there_unsent_data(stcb, SCTP_SO_LOCKED) == 0) {
13584 if ((*asoc->ss_functions.sctp_ss_is_user_msgs_incomplete) (stcb, asoc)) {
13588 if ((SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_SENT) &&
13589 (SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_RECEIVED) &&
13590 (SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_ACK_SENT)) {
13594 if (SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) {
13597 SCTP_SET_STATE(stcb, SCTP_STATE_SHUTDOWN_SENT);
13598 sctp_stop_timers_for_shutdown(stcb);
13604 sctp_send_shutdown(stcb, netp);
13605 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN, stcb->sctp_ep, stcb,
13607 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, stcb->sctp_ep, stcb,
13621 if ((SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_SENT) &&
13622 (SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_RECEIVED) &&
13623 (SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_ACK_SENT)) {
13624 if ((*asoc->ss_functions.sctp_ss_is_user_msgs_incomplete) (stcb, asoc)) {
13625 SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_PARTIAL_MSG_LEFT);
13627 SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_SHUTDOWN_PENDING);
13644 sctp_abort_an_association(stcb->sctp_ep, stcb,
13647 stcb = NULL;
13657 KASSERT(stcb != NULL, ("stcb is NULL"));
13658 SCTP_TCB_LOCK_ASSERT(stcb);
13666 if (SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) {
13671 sctp_send_initiate(inp, stcb, SCTP_SO_LOCKED);
13673 SCTP_SET_STATE(stcb, SCTP_STATE_COOKIE_WAIT);
13678 KASSERT(stcb != NULL, ("stcb is NULL"));
13679 SCTP_TCB_LOCK_ASSERT(stcb);
13707 sctp_log_nagle_event(stcb, SCTP_NAGLE_APPLIED);
13714 sctp_log_nagle_event(stcb, SCTP_NAGLE_SKIPPED);
13727 KASSERT(stcb != NULL, ("stcb is NULL"));
13728 SCTP_TCB_LOCK_ASSERT(stcb);
13736 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_USR_SEND, SCTP_SO_LOCKED);
13741 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_USR_SEND, SCTP_SO_LOCKED);
13746 (void)sctp_med_chunk_output(inp, stcb, asoc, &num_out,
13748 sctp_get_frag_point(stcb),
13757 KASSERT(stcb != NULL, ("stcb is NULL"));
13758 SCTP_TCB_LOCK_ASSERT(stcb);
13769 if (stcb != NULL) {
13776 SCTP_TCB_UNLOCK(stcb);
13784 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, error);
13794 struct sctp_tcb *stcb, uint8_t chunk)
13802 (stcb == NULL))
13805 if (stcb->asoc.auth_supported == 0) {
13809 if (!sctp_auth_is_required_chunk(chunk, stcb->asoc.peer_auth_chunks)) {
13826 sctp_get_hmac_digest_len(stcb->asoc.peer_hmac_id);
13828 auth->hmac_id = htons(stcb->asoc.peer_hmac_id);