inet.c

This a separate release of the OpenSS7 X/Open XTI/TLI library, TLI modules (timod, tirdwr) and the I

			}
			if (ss_tst_bit(_T_BIT_TCP_DEFER_ACCEPT, ss->options.flags)) {
				oh->level = T_INET_TCP;
				oh->name = T_TCP_DEFER_ACCEPT;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				if (ss->options.tcp.defer_accept == T_UNSPEC)
					ss->options.tcp.defer_accept = (TCP_TIMEOUT_INIT / HZ) << tp->defer_accept;
				else if (ss->options.tcp.defer_accept != ((TCP_TIMEOUT_INIT / HZ) << tp->defer_accept)) {
					oh->status = T_PARTSUCCESS;
					ss->options.tcp.defer_accept = ((TCP_TIMEOUT_INIT / HZ) << tp->defer_accept);
				}
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.tcp.defer_accept;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_TCP_WINDOW_CLAMP, ss->options.flags)) {
				oh->level = T_INET_TCP;
				oh->name = T_TCP_WINDOW_CLAMP;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				if (ss->options.tcp.window_clamp == T_UNSPEC)
					ss->options.tcp.window_clamp = tp->window_clamp;
				else if (ss->options.tcp.window_clamp != tp->window_clamp) {
					oh->status = T_PARTSUCCESS;
					ss->options.tcp.window_clamp = tp->window_clamp;
				}
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.tcp.window_clamp;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_TCP_INFO, ss->options.flags)) {
				// read-only
			}
			if (ss_tst_bit(_T_BIT_TCP_QUICKACK, ss->options.flags)) {
				oh->level = T_INET_TCP;
				oh->name = T_TCP_QUICKACK;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.tcp.quickack;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			break;
		}
#if defined HAVE_OPENSS7_SCTP
		case T_INET_SCTP:
		{
			struct sctp_opt *sp = &sk->tp_pinfo.af_sctp;
			if (ss_tst_bit(_T_BIT_SCTP_NODELAY, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_NODELAY;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				if ((ss->options.sctp.nodelay != T_NO) != (sp->nonagle != 0)) {
					oh->status = T_PARTSUCCESS;
					ss->options.sctp.nodelay = sp->nonagle ? T_YES : T_NO;
				}
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.nodelay;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_MAXSEG, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_MAXSEG;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				if (ss->options.sctp.maxseg != sp->user_amps) {
					if (ss->options.sctp.maxseg > sp->user_amps)
						oh->status = T_PARTSUCCESS;
					ss->options.sctp.maxseg = sp->user_amps;
				}
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.maxseg;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_CORK, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_CORK;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.cork;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_PPI, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_PPI;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				ss->options.sctp.ppi = sp->ppi;
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.ppi;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_SID, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_SID;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				ss->options.sctp.sid = sp->sid;
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.sid;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_SSN, ss->options.flags)) {
				// only per-packet
			}
			if (ss_tst_bit(_T_BIT_SCTP_TSN, ss->options.flags)) {
				// only per-packet
			}
			if (ss_tst_bit(_T_BIT_SCTP_RECVOPT, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_RECVOPT;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				// absolute requirement
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.recvopt;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_COOKIE_LIFE, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_COOKIE_LIFE;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				if (ss->options.sctp.cookie_life != sp->ck_life / HZ * 1000) {
					if (ss->options.sctp.cookie_life < sp->ck_life / HZ * 1000)
						oh->status = T_PARTSUCCESS;
					ss->options.sctp.cookie_life = sp->ck_life / HZ * 1000;
				}
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.cookie_life;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_SACK_DELAY, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_SACK_DELAY;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				if (ss->options.sctp.sack_delay != sp->max_sack / HZ * 1000) {
					if (ss->options.sctp.sack_delay < sp->max_sack / HZ * 1000)
						oh->status = T_PARTSUCCESS;
					ss->options.sctp.sack_delay = sp->max_sack / HZ * 1000;
				}
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.sack_delay;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_PATH_MAX_RETRANS, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_PATH_MAX_RETRANS;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				// absolute requirement
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.path_max_retrans;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_ASSOC_MAX_RETRANS, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_ASSOC_MAX_RETRANS;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				// absolute requirement
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.assoc_max_retrans;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_MAX_INIT_RETRIES, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_MAX_INIT_RETRIES;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				// absolute requirement
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.max_init_retries;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_HEARTBEAT_ITVL, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_HEARTBEAT_ITVL;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				if (ss->options.sctp.heartbeat_itvl != sp->hb_itvl / HZ * 1000) {
					if (ss->options.sctp.heartbeat_itvl < sp->hb_itvl / HZ * 1000)
						oh->status = T_PARTSUCCESS;
					ss->options.sctp.heartbeat_itvl = sp->hb_itvl / HZ * 1000;
				}
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.heartbeat_itvl;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_RTO_INITIAL, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_RTO_INITIAL;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				if (ss->options.sctp.rto_initial != sp->rto_ini / HZ * 1000) {
					if (ss->options.sctp.rto_initial < sp->rto_ini / HZ * 1000)
						oh->status = T_PARTSUCCESS;
					ss->options.sctp.rto_initial = sp->rto_ini / HZ * 1000;
				}
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.rto_initial;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_RTO_MIN, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_RTO_MIN;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				if (ss->options.sctp.rto_min != sp->rto_min / HZ * 1000) {
					if (ss->options.sctp.rto_min < sp->rto_min / HZ * 1000)
						oh->status = T_PARTSUCCESS;
					ss->options.sctp.rto_min = sp->rto_min / HZ * 1000;
				}
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.rto_min;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_RTO_MAX, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_RTO_MAX;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				if (ss->options.sctp.rto_max != sp->rto_max / HZ * 1000) {
					if (ss->options.sctp.rto_max < sp->rto_max / HZ * 1000)
						oh->status = T_PARTSUCCESS;
					ss->options.sctp.rto_max = sp->rto_max / HZ * 1000;
				}
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.rto_max;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			// if (ss_tst_bit(_T_BIT_SCTP_OSTREAMS, ss->options.flags))
			{
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_OSTREAMS;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				if (ss->options.sctp.ostreams != sp->req_ostr) {
					if (ss->options.sctp.ostreams > sp->req_ostr)
						oh->status = T_PARTSUCCESS;
					ss->options.sctp.ostreams = sp->req_ostr;
				}
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.ostreams;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			// if (ss_tst_bit(_T_BIT_SCTP_ISTREAMS, ss->options.flags))
			{
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_ISTREAMS;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				if (ss->options.sctp.istreams != sp->max_istr) {
					if (ss->options.sctp.istreams > sp->max_istr)
						oh->status = T_PARTSUCCESS;
					ss->options.sctp.istreams = sp->max_istr;
				}
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.istreams;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_COOKIE_INC, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_COOKIE_INC;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				if (ss->options.sctp.cookie_inc != sp->ck_inc / HZ * 1000) {
					if (ss->options.sctp.cookie_inc < sp->ck_inc / HZ * 1000)
						oh->status = T_PARTSUCCESS;
					ss->options.sctp.cookie_inc = sp->ck_inc / HZ * 1000;
				}
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.cookie_inc;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_THROTTLE_ITVL, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_THROTTLE_ITVL;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				if (ss->options.sctp.throttle_itvl != sp->throttle / HZ * 1000) {
					if (ss->options.sctp.throttle_itvl < sp->throttle / HZ * 1000)
						oh->status = T_PARTSUCCESS;
					ss->options.sctp.throttle_itvl = sp->throttle / HZ * 1000;
				}
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.throttle_itvl;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_MAC_TYPE, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_MAC_TYPE;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.mac_type;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_CKSUM_TYPE, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_CKSUM_TYPE;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.cksum_type;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_HB, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_HB;
				oh->len = _T_LENGTH_SIZEOF(struct t_sctp_hb);
				oh->status = T_SUCCESS;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_RTO, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_RTO;
				oh->len = _T_LENGTH_SIZEOF(struct t_sctp_rto);
				oh->status = T_SUCCESS;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_STATUS, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_STATUS;
				oh->len = T_SPACE(sizeof(struct t_sctp_status) + sizeof(struct t_sctp_dest_status));
				oh->status = T_SUCCESS;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_DEBUG, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_DEBUG;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.debug;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
#if defined CONFIG_SCTP_ECN
			if (ss_tst_bit(_T_BIT_SCTP_ECN, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_ECN;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.ecn;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
#endif				/* defined CONFIG_SCTP_ECN */
#if defined CONFIG_SCTP_ADD_IP || defined CONFIG_SCTP_ADAPTATION_LAYER_INFO
			if (ss_tst_bit(_T_BIT_SCTP_ALI, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_ALI;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.ali;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
#endif				/* defined CONFIG_SCTP_ADD_IP || defined
				   CONFIG_SCTP_ADAPTATION_LAYER_INFO */
#if defined CONFIG_SCTP_ADD_IP
			if (ss_tst_bit(_T_BIT_SCTP_ADD, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_ADD;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				// absolute requirement
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.add;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_SET, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_SET;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				// absolute requirement
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.set;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_ADD_IP, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_ADD_IP;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				// absolute requirement
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.add_ip;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_DEL_IP, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_DEL_IP;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				// absolute requirement
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.del_ip;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
			if (ss_tst_bit(_T_BIT_SCTP_SET_IP, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_SET_IP;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				// absolute requirement
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->options.sctp.set_ip;
				oh = _T_OPT_NEXTHDR_OFS(op, olen, oh, 0);
			}
#endif				/* defined CONFIG_SCTP_ADD_IP */
#if defined CONFIG_SCTP_PARTIAL_RELIABILITY
			if (ss_tst_bit(_T_BIT_SCTP_PR, ss->options.flags)) {
				oh->level = T_INET_SCTP;
				oh->name = T_SCTP_PR;
				oh->len = _T_LENGTH_SIZEOF(t_uscalar_t);
				oh->status = T_SUCCESS;
				// absolute requirement
				*((t_uscalar_t *) T_OPT_DATA(oh)) = ss->o