inet.c

7号信令功能代码,为开源代码

				ops->bcast = (void *) _T_OPT_DATA_OFS(oh, 0);
				ops->flags |= TF_IP_BROADCAST;
				continue;
			}
			break;
		case T_INET_TCP:
			if (ss->p.prot.protocol == T_INET_TCP)
				switch (oh->name) {
				case T_TCP_NODELAY:
					ops->nodly = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_TCP_NODELAY;
					continue;
				case T_TCP_MAXSEG:
					ops->mss = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_TCP_MAXSEG;
					continue;
				case T_TCP_KEEPALIVE:
					ops->alive = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_TCP_KEEPALIVE;
					continue;
				}
			break;
		case T_INET_UDP:
			if (ss->p.prot.protocol == T_INET_UDP)
				switch (oh->name) {
				case T_UDP_CHECKSUM:
					ops->csum = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_UDP_CHECKSUM;
					continue;
				}
			break;
#if defined CONFIG_SCTP || defined CONFIG_SCTP_MODULE
		case T_INET_SCTP:
			if (ss->p.prot.protocol == T_INET_SCTP)
				switch (oh->name) {
				case T_SCTP_NODELAY:
					ops->nodly = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_NODELAY;
					continue;
				case T_SCTP_CORK:
					ops->cork = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_CORK;
					continue;
				case T_SCTP_PPI:
					ops->ppi = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_PPI;
					continue;
				case T_SCTP_SID:
					ops->sid = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_SID;
					continue;
				case T_SCTP_SSN:
					ops->ssn = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_SSN;
					continue;
				case T_SCTP_TSN:
					ops->tsn = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_TSN;
					continue;
				case T_SCTP_RECVOPT:
					ops->recvopt = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_RECVOPT;
					continue;
				case T_SCTP_COOKIE_LIFE:
					ops->clife = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_COOKIE_LIFE;
					continue;
				case T_SCTP_SACK_DELAY:
					ops->sack = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_SACK_DELAY;
					continue;
				case T_SCTP_PATH_MAX_RETRANS:
					ops->prtx = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_MAX_RETRANS;
					continue;
				case T_SCTP_ASSOC_MAX_RETRANS:
					ops->artx = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_ASSOC_MAX_RETRANS;
					continue;
				case T_SCTP_MAX_INIT_RETRIES:
					ops->irtx = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_MAX_INIT_RETRIES;
					continue;
				case T_SCTP_HEARTBEAT_ITVL:
					ops->hitvl = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_HEARTBEAT_ITVL;
					continue;
				case T_SCTP_RTO_INITIAL:
					ops->rtoinit = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_RTO_INITIAL;
					continue;
				case T_SCTP_RTO_MIN:
					ops->rtomin = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_RTO_MIN;
					continue;
				case T_SCTP_RTO_MAX:
					ops->rtomax = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_RTO_MAX;
					continue;
				case T_SCTP_OSTREAMS:
					ops->ostr = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_OSTREAMS;
					continue;
				case T_SCTP_ISTREAMS:
					ops->istr = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_ISTREAMS;
					continue;
				case T_SCTP_COOKIE_INC:
					ops->cinc = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_COOKIE_INC;
					continue;
				case T_SCTP_THROTTLE_ITVL:
					ops->titvl = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_THROTTLE_ITVL;
					continue;
				case T_SCTP_MAC_TYPE:
					ops->mac = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_MAC_TYPE;
					continue;
				case T_SCTP_HB:
					ops->hb = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_HB;
					continue;
				case T_SCTP_RTO:
					ops->rto = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_RTO;
					continue;
				case T_SCTP_MAXSEG:
					ops->mss = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_MAXSEG;
					continue;
				case T_SCTP_STATUS:
					ops->stat = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_STATUS;
					continue;
				case T_SCTP_DEBUG:
					ops->debug = (void *) _T_OPT_DATA_OFS(oh, 0);
					ops->flags |= TF_SCTP_DEBUG;
					continue;
				}
			break;
#endif
		}
	}
	if (oh)
		return (TBADOPT);
	return (0);
}

STATIC size_t
ss_cmsg_size(ss_opts_t * ops, int flags)
{
	size_t len = 0;
	const size_t hlen = CMSG_ALIGN(sizeof(struct cmsghdr));
	if (ops) {
		if (ops->opt && flags & TF_IP_OPTIONS)
			len += hlen + CMSG_ALIGN(sizeof(*(ops->opt)));
		if (ops->tos && flags & TF_IP_TOS)
			len += hlen + CMSG_ALIGN(sizeof(*(ops->tos)));
		if (ops->ttl && flags & TF_IP_TTL)
			len += hlen + CMSG_ALIGN(sizeof(*(ops->ttl)));
		if (ops->reuse && flags & TF_IP_REUSEADDR)
			len += hlen + CMSG_ALIGN(sizeof(*(ops->reuse)));
		if (ops->norte && flags & TF_IP_DONTROUTE)
			len += hlen + CMSG_ALIGN(sizeof(*(ops->norte)));
		if (ops->bcast && flags & TF_IP_BROADCAST)
			len += hlen + CMSG_ALIGN(sizeof(*(ops->bcast)));
		if (ops->nodly && flags & TF_TCP_NODELAY)
			len += hlen + CMSG_ALIGN(sizeof(*(ops->nodly)));
		if (ops->mss && flags & TF_TCP_MAXSEG)
			len += hlen + CMSG_ALIGN(sizeof(*(ops->mss)));
		if (ops->alive && flags & TF_TCP_KEEPALIVE)
			len += hlen + CMSG_ALIGN(sizeof(*(ops->alive)));
#ifdef LINUX_2_4
#endif
#ifdef UDP_CHECKSUM
		if (ops->csum && flags & TF_UDP_CHECKSUM)
			len += hlen + CMSG_ALIGN(sizeof(*(ops->csum)));
#endif
#if defined CONFIG_SCTP || defined CONFIG_SCTP_MODULE
#endif
	}
	return (len);
}
STATIC void
ss_build_cmsg(ss_opts_t * ops, struct msghdr *msg, int flags)
{
	struct cmsghdr *ch;
	unsigned char *p = msg->msg_control;
	const size_t hlen = CMSG_ALIGN(sizeof(struct cmsghdr));
	if (ops) {
		if (ops->opt && flags & TF_IP_OPTIONS) {
			ch = ((typeof(ch)) p)++;
			ch->cmsg_len = hlen + CMSG_ALIGN(sizeof(*ops->opt));
			ch->cmsg_level = SOL_IP;
			ch->cmsg_type = IP_OPTIONS;
			*((typeof(ops->opt)) p) = *(ops->opt);
			p += CMSG_ALIGN(sizeof(*ops->opt));
		}
		if (ops->tos && flags & TF_IP_TOS) {
			ch = ((typeof(ch)) p)++;
			ch->cmsg_len = hlen + CMSG_ALIGN(sizeof(*ops->tos));
			ch->cmsg_level = SOL_IP;
			ch->cmsg_type = IP_TOS;
			*((typeof(ops->tos)) p) = *(ops->tos);
			p += CMSG_ALIGN(sizeof(*ops->tos));
		}
		if (ops->ttl && flags & TF_IP_TTL) {
			ch = ((typeof(ch)) p)++;
			ch->cmsg_len = hlen + CMSG_ALIGN(sizeof(*ops->ttl));
			ch->cmsg_level = SOL_IP;
			ch->cmsg_type = IP_TTL;
			*((typeof(ops->ttl)) p) = *(ops->ttl);
			p += CMSG_ALIGN(sizeof(*ops->ttl));
		}
		if (ops->reuse && flags & TF_IP_REUSEADDR) {
			ch = ((typeof(ch)) p)++;
			ch->cmsg_len = hlen + CMSG_ALIGN(sizeof(*ops->reuse));
			ch->cmsg_level = SOL_SOCKET;
			ch->cmsg_type = SO_REUSEADDR;
			*((typeof(ops->reuse)) p) = *(ops->reuse);
			p += CMSG_ALIGN(sizeof(*ops->reuse));
		}
		if (ops->norte && flags & TF_IP_DONTROUTE) {
			ch = ((typeof(ch)) p)++;
			ch->cmsg_len = hlen + CMSG_ALIGN(sizeof(*ops->norte));
			ch->cmsg_level = SOL_SOCKET;
			ch->cmsg_type = SO_DONTROUTE;
			*((typeof(ops->norte)) p) = *(ops->norte);
			p += CMSG_ALIGN(sizeof(*ops->norte));
		}
		if (ops->bcast && flags & TF_IP_BROADCAST) {
			ch = ((typeof(ch)) p)++;
			ch->cmsg_len = hlen + CMSG_ALIGN(sizeof(*ops->bcast));
			ch->cmsg_level = SOL_SOCKET;
			ch->cmsg_type = SO_BROADCAST;
			*((typeof(ops->bcast)) p) = *(ops->bcast);
			p += CMSG_ALIGN(sizeof(*ops->bcast));
		}
		if (ops->nodly && flags & TF_TCP_NODELAY) {
			ch = ((typeof(ch)) p)++;
			ch->cmsg_len = hlen + CMSG_ALIGN(sizeof(*ops->nodly));
			ch->cmsg_level = SOL_TCP;
			ch->cmsg_type = TCP_NODELAY;
			*((typeof(ops->nodly)) p) = *(ops->nodly);
			p += CMSG_ALIGN(sizeof(*ops->nodly));
		}
		if (ops->mss && flags & TF_TCP_MAXSEG) {
			ch = ((typeof(ch)) p)++;
			ch->cmsg_len = hlen + CMSG_ALIGN(sizeof(*ops->mss));
			ch->cmsg_level = SOL_TCP;
			ch->cmsg_type = TCP_MAXSEG;
			*((typeof(ops->mss)) p) = *(ops->mss);
			p += CMSG_ALIGN(sizeof(*ops->mss));
		}
		if (ops->alive && flags & TF_TCP_KEEPALIVE) {
			ch = ((typeof(ch)) p)++;
			ch->cmsg_len = hlen + CMSG_ALIGN(sizeof(*ops->alive));
			ch->cmsg_level = SOL_SOCKET;
			ch->cmsg_type = SO_KEEPALIVE;
			*((typeof(ops->alive)) p) = *(ops->alive);
			p += CMSG_ALIGN(sizeof(*ops->alive));
		}
#ifdef UDP_CHECKSUM
		if (ops->csum && flags & TF_UDP_CHECKSUM) {
			ch = ((typeof(ch)) p)++;
			ch->cmsg_len = hlen + CMSG_ALIGN(sizeof(*ops->csum));
			ch->cmsg_level = SOL_UDP;
			ch->cmsg_type = UDP_CHECKSUM;
			*((typeof(ops->csum)) p) = *(ops->csum);
			p += CMSG_ALIGN(sizeof(*ops->csum));
		}
#endif
	}
}
STATIC int
ss_parse_cmsg(struct msghdr *msg, ss_opts_t * opts)
{
	struct cmsghdr *cmsg;
	for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
		if (cmsg->cmsg_len < sizeof(struct cmsghdr)
		    || (unsigned long) (((char *) cmsg - (char *) msg->msg_control)
					+ cmsg->cmsg_len) > msg->msg_controllen) {
			return -EINVAL;
		}
		switch (cmsg->cmsg_level) {
		case SOL_IP:
			switch (cmsg->cmsg_type) {
			case IP_OPTIONS:
				if (cmsg->cmsg_len <= 40) {
					opts->opt = (typeof(opts->opt))
					    CMSG_DATA(cmsg);
					opts->flags |= TF_IP_OPTIONS;
				}
				break;
			case IP_TTL:
				if (cmsg->cmsg_len == sizeof(*opts->ttl)) {
					opts->ttl = (typeof(opts->ttl))
					    CMSG_DATA(cmsg);
					opts->flags |= TF_IP_TTL;
				}
				break;
			case IP_TOS:
				if (cmsg->cmsg_len == sizeof(*opts->tos)) {
					opts->tos = (typeof(opts->tos))
					    CMSG_DATA(cmsg);
					opts->flags |= TF_IP_TOS;
				}
				break;
			case IP_RETOPTS:
				if (cmsg->cmsg_len == sizeof(*opts->ropt)) {
					opts->ropt = (typeof(opts->ropt))
					    CMSG_DATA(cmsg);
					opts->flags |= TF_IP_RETOPTS;
				}
				break;
			case IP_PKTINFO:
				if (cmsg->cmsg_len == sizeof(*opts->pkinfo)) {
					opts->pkinfo = (typeof(opts->pkinfo))
					    CMSG_DATA(cmsg);
					opts->flags |= TF_IP_PKTINFO;
				}
				break;
			case IP_HDRINCL:
			case IP_ROUTER_ALERT:
			case IP_RECVOPTS:
			case IP_PKTOPTIONS:
			case IP_MTU_DISCOVER:
			case IP_RECVERR:
			case IP_RECVTTL:
			case IP_RECVTOS:
			case IP_MTU:
				break;
			}
			break;
		case SOL_TCP:
			switch (cmsg->cmsg_type) {
			case TCP_NODELAY:
			case TCP_MAXSEG:
			case TCP_CORK:
#ifdef LINUX_2_4
			case TCP_KEEPIDLE:
			case TCP_KEEPINTVL:
			case TCP_KEEPCNT:
			case TCP_SYNCNT:
			case TCP_LINGER2:
			case TCP_DEFER_ACCEPT:
			case TCP_WINDOW_CLAMP:
			case TCP_INFO:
			case TCP_QUICKACK:
#endif
				break;
			}
			break;
		case SOL_UDP:
			switch (cmsg->cmsg_type) {
			}
			break;
#if defined CONFIG_SCTP || defined CONFIG_SCTP_MODULE
		case SOL_SCTP:
			switch (cmsg->cmsg_type) {
			case SCTP_NODELAY:
			case SCTP_MAXSEG:
			case SCTP_CORK:
			case SCTP_RECVSID:
			case SCTP_RECVPPI:
			case SCTP_RECVTSN:
			case SCTP_SID:
			case SCTP_PPI:
			case SCTP_SSN:
			case SCTP_TSN:
			case SCTP_HB:
			case SCTP_RTO:
			case SCTP_COOKIE_LIFE:
			case SCTP_SACK_DELAY:
			case SCTP_PATH_MAX_RETRANS:
			case SCTP_ASSOC_MAX_RETRANS:
			case SCTP_MAX_INIT_RETRIES:
			case SCTP_HEARTBEAT_ITVL:
			case SCTP_RTO_INITIAL:
			case SCTP_RTO_MIN:
			case SCTP_RTO_MAX:
			case SCTP_OSTREAMS:
			case SCTP_ISTREAMS:
			case SCTP_COOKIE_INC:
			case SCTP_THROTTLE_ITVL:
			case SCTP_MAC_TYPE:
			case SCTP_CKSUM_TYPE:
			case SCTP_DEBUG_OPTIONS:
			case SCTP_STATUS:
			case SCTP_ALI:
			case SCTP_PR:
			case SCTP_DISPOSITION:
			case SCTP_LIFETIME:
			case SCTP_ADD:
			case SCTP_ADD_IP:
			case SCTP_DEL_IP:
			case SCTP_SET:
			case SCTP_SET_IP:
			case SCTP_ECN:
			case SCTP_MAX_BURST:
				break;
			}
			break;
#endif
		default:
			break;
		}
	}
	return (0);
}

/* 
 *  =========================================================================
 *
 *  OPTIONS Handling
 *
 *  =========================================================================
 */
STATIC ss_dflt_t opt_defaults = {
	ip_default_opt,
	ip_default_tos,
	ip_default_ttl,
	ip_default_reuse,
	ip_default_norte,
	ip_default_bcast,
	tcp_default_nodly,
	tcp_default_mss,
	tcp_default_alive,
	udp_default_csum
};
/* 
 *  CHECK Options
 *  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 */
STATIC int
ss_opt_check(ss_t * ss, ss_opts_t * opt)
{
	if (opt->flags) {
		opt->flags = 0;
		if (opt->opt)
			opt->flags |= TF_IP_OPTIONS;
		if (opt->tos && !(*(opt->tos) & 0x1e))
			opt->flags |= TF_IP_TOS;
		if (opt->ttl && !(*(opt->ttl) & 0xff))
			opt->flags |= TF_IP_TTL;
		if (opt->reuse)
			opt->flags |= TF_IP_REUSEADDR;
		if (opt->norte)
			opt->flags |= TF_IP_DONTROUTE;
		if (opt->bcast)
			opt->flags |= TF_IP_BROADCAST;
		if (ss->p.prot.protocol == T_INET_TCP) {
			if (opt->nodly)
				opt->flags |= TF_TCP_NODELAY;
			if (opt->mss)
				opt->flags |= TF_TCP_MAXSEG;
			if (opt->alive)
				opt->flags |= TF_TCP_KEEPALIVE;
		}
		if (ss->p.prot.protocol == T_INET_UDP) {
			if (opt->csum)
				opt->flags |= TF_UDP_CHECKSUM;
		}
	}
	return (0);
}

/* 
 *  DEFAULT Options
 *  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 */
STATIC int
ss_opt_default(ss_t * ss, ss_opts_t * opt)
{
	int flags = opt->flags;
	opt->flags = 0;
	if (!flags || opt->tos) {
		opt->tos = &opt_defaults.tos;
		opt->flags |= TF_IP_TOS;
	}
	if (!flags || opt->ttl) {
		opt->ttl = &opt_defaults.ttl;
		opt->flags |= TF_IP_TTL;