m->m_pkthdr.rcvif = (struct ifnet *)0;		mhip->ip_off = htons((u_short)mhip->ip_off);                mhip->ip_sum = 0;                if (_ipCfgFlags & IP_DO_CHECKSUM_SND)                    mhip->ip_sum = in_cksum(m, mhlen);		*mnext = m;		mnext = &m->m_nextpkt;		ipstat.ips_ofragments++;	}	/*	 * Update first fragment by trimming what's been copied out	 * and updating header, then send each fragment (in order).	 */	m = m0;	m_adj(m, hlen + firstlen - (u_short)ip->ip_len);	m->m_pkthdr.len = hlen + firstlen;	ip->ip_len = htons((u_short)m->m_pkthdr.len);	ip->ip_off = htons((u_short)(ip->ip_off | IP_MF));        ip->ip_sum = 0;        if (_ipCfgFlags & IP_DO_CHECKSUM_SND)            ip->ip_sum = in_cksum(m, hlen);sendorfree:	for (m = m0; m; m = m0) {		m0 = m->m_nextpkt;		m->m_nextpkt = 0;		if (error == 0)			error = (*ifp->if_output)(ifp, m,			    (struct sockaddr *)dst, ro->ro_rt);		else			m_freem(m);	}	if (error == 0)		ipstat.ips_fragmented++;    }done:	if (ro == &iproute && (flags & IP_ROUTETOIF) == 0 && ro->ro_rt)		RTFREE(ro->ro_rt);	return (error);bad:	m_freem(m0);	goto done;}/* * Insert IP options into preformed packet. * Adjust IP destination as required for IP source routing, * as indicated by a non-zero in_addr at the start of the options. */static struct mbuf *ip_insertoptions(m, opt, phlen)	register struct mbuf *m;	struct mbuf *opt;	int *phlen;{	register struct ipoption *p = mtod(opt, struct ipoption *);	struct mbuf *n;	register struct ip *ip = mtod(m, struct ip *);	unsigned optlen;	optlen = opt->m_len - sizeof(p->ipopt_dst);	if (optlen + (u_short)ip->ip_len > IP_MAXPACKET)		return (m);		/* XXX should fail */	if (p->ipopt_dst.s_addr)		ip->ip_dst = p->ipopt_dst;#if 0	/* XXX changed for default cluster support vinai         * The reason why always new clusters are allocted,         * is that, data could be overwritten since clusters are shared.         */	if (m->m_flags & M_EXT || m->m_data - optlen < m->m_pktdat) {#endif		n = mHdrClGet(M_DONTWAIT, MT_HEADER, CL_SIZE_128, TRUE);		if (n == 0)			return (m);		n->m_pkthdr.len = m->m_pkthdr.len + optlen;		m->m_len -= sizeof(struct ip);		m->m_data += sizeof(struct ip);		n->m_next = m;		m = n;		m->m_len = optlen + sizeof(struct ip);		m->m_data += max_linkhdr;		bcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));#if 0 	/* XXX changed for default cluster support vinai */               	} else {		m->m_data -= optlen;		m->m_len += optlen;		m->m_pkthdr.len += optlen;		ovbcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));	}#endif        	ip = mtod(m, struct ip *);	bcopy((caddr_t)p->ipopt_list, (caddr_t)(ip + 1), (unsigned)optlen);	*phlen = sizeof(struct ip) + optlen;	ip->ip_len += optlen;	return (m);}/* * Copy options from ip to jp, * omitting those not copied during fragmentation. */intip_optcopy(ip, jp)	struct ip *ip, *jp;{	register u_char *cp, *dp;	int opt, optlen, cnt;	cp = (u_char *)(ip + 1);	dp = (u_char *)(jp + 1);	cnt = (ip->ip_hl << 2) - sizeof (struct ip);	for (; cnt > 0; cnt -= optlen, cp += optlen) {		opt = cp[0];		if (opt == IPOPT_EOL)			break;		if (opt == IPOPT_NOP) {			/* Preserve for IP mcast tunnel's LSRR alignment. */			*dp++ = IPOPT_NOP;			optlen = 1;			continue;		} else			optlen = cp[IPOPT_OLEN];		/* bogus lengths should have been caught by ip_dooptions */		if (optlen > cnt)			optlen = cnt;		if (IPOPT_COPIED(opt)) {			bcopy((caddr_t)cp, (caddr_t)dp, (unsigned)optlen);			dp += optlen;		}	}	for (optlen = dp - (u_char *)(jp+1); optlen & 0x3; optlen++)		*dp++ = IPOPT_EOL;	return (optlen);}/* * IP socket option processing. */intip_ctloutput(op, so, level, optname, mp)	int op;	struct socket *so;	int level, optname;	struct mbuf **mp;{	register struct inpcb *inp = sotoinpcb(so);	register struct mbuf *m = *mp;	register int optval;	int error = 0;	if (level != IPPROTO_IP) {		error = EINVAL;		if (op == PRCO_SETOPT && *mp)			(void) m_free(*mp);	} else switch (op) {	case PRCO_SETOPT:		switch (optname) {		case IP_OPTIONS:#ifdef notyet		case IP_RETOPTS:			return (ip_pcbopts(optname, &inp->inp_options, m));#else			return (ip_pcbopts(&inp->inp_options, m));#endif		case IP_TOS:		case IP_TTL:		case IP_RECVOPTS:		case IP_RECVRETOPTS:		case IP_RECVDSTADDR:			if (m->m_len != sizeof(int))				error = EINVAL;			else {				optval = *mtod(m, int *);				switch (optname) {				case IP_TOS:					inp->inp_ip.ip_tos = optval;					break;				case IP_TTL:					inp->inp_ip.ip_ttl = optval;					break;#define	OPTSET(bit) \	if (optval) \		inp->inp_flags |= bit; \	else \		inp->inp_flags &= ~bit;				case IP_RECVOPTS:					OPTSET(INP_RECVOPTS);					break;				case IP_RECVRETOPTS:					OPTSET(INP_RECVRETOPTS);					break;				case IP_RECVDSTADDR:					OPTSET(INP_RECVDSTADDR);					break;				}			}			break;#undef OPTSET		case IP_MULTICAST_IF:		case IP_MULTICAST_TTL:		case IP_MULTICAST_LOOP:		case IP_ADD_MEMBERSHIP:		case IP_DROP_MEMBERSHIP:			error = ip_setmoptions(optname, inp, m);			break;		default:			error = ENOPROTOOPT;			break;		}		if (m)			(void)m_free(m);		break;	case PRCO_GETOPT:		switch (optname) {		case IP_OPTIONS:		case IP_RETOPTS:			*mp = m = mBufClGet(M_WAIT, MT_SOOPTS, CL_SIZE_128,					    TRUE);			if (m == NULL)			    {			    error = ENOBUFS;			    break;			    }			if (inp->inp_options) {				m->m_len = inp->inp_options->m_len;				bcopy(mtod(inp->inp_options, caddr_t),				    mtod(m, caddr_t), (unsigned)m->m_len);			} else				m->m_len = 0;			break;		case IP_TOS:		case IP_TTL:		case IP_RECVOPTS:		case IP_RECVRETOPTS:		case IP_RECVDSTADDR:			*mp = m = mBufClGet(M_WAIT, MT_SOOPTS, CL_SIZE_128,					    TRUE);			if (m == NULL)			    {			    error = ENOBUFS;			    break;			    }			m->m_len = sizeof(int);			switch (optname) {			case IP_TOS:				optval = inp->inp_ip.ip_tos;				break;			case IP_TTL:				optval = inp->inp_ip.ip_ttl;				break;#define	OPTBIT(bit)	(inp->inp_flags & bit ? 1 : 0)			case IP_RECVOPTS:				optval = OPTBIT(INP_RECVOPTS);				break;			case IP_RECVRETOPTS:				optval = OPTBIT(INP_RECVRETOPTS);				break;			case IP_RECVDSTADDR:				optval = OPTBIT(INP_RECVDSTADDR);				break;			}			*mtod(m, int *) = optval;			break;		case IP_MULTICAST_IF:		case IP_MULTICAST_TTL:		case IP_MULTICAST_LOOP:		case IP_ADD_MEMBERSHIP:		case IP_DROP_MEMBERSHIP:			error = ip_getmoptions(optname, inp->inp_moptions, mp);			break;		default:			error = ENOPROTOOPT;			break;		}		break;	}	return (error);}/* * Set up IP options in pcb for insertion in output packets. * Store in mbuf with pointer in pcbopt, adding pseudo-option * with destination address if source routed. */int#ifdef notyetip_pcbopts(optname, pcbopt, m)	int optname;#elseip_pcbopts(pcbopt, m)#endif	struct mbuf **pcbopt;	register struct mbuf *m;{	register cnt, optlen;	register u_char *cp;	u_char opt;	/* turn off any old options */	if (*pcbopt)		(void)m_free(*pcbopt);	*pcbopt = 0;	if (m == (struct mbuf *)0 || m->m_len == 0) {		/*		 * Only turning off any previous options.		 */		if (m)			(void)m_free(m);		return (0);	}#ifndef	vax	if (m->m_len % sizeof(long))		goto bad;#endif	/*	 * IP first-hop destination address will be stored before	 * actual options; move other options back	 * and clear it when none present.	 */#if 0 /*XXX changed for default cluster support vinai*/	if (m->m_data + m->m_len + sizeof(struct in_addr) >= &m->m_dat[MLEN])		goto bad;#else	if (m->m_data + m->m_len + sizeof(struct in_addr) >= 	    (m->m_extBuf + m->m_extSize))		goto bad;#endif	cnt = m->m_len;	m->m_len += sizeof(struct in_addr);	cp = mtod(m, u_char *) + sizeof(struct in_addr);	ovbcopy(mtod(m, caddr_t), (caddr_t)cp, (unsigned)cnt);	bzero(mtod(m, caddr_t), sizeof(struct in_addr));	for (; cnt > 0; cnt -= optlen, cp += optlen) {		opt = cp[IPOPT_OPTVAL];		if (opt == IPOPT_EOL)			break;		if (opt == IPOPT_NOP)			optlen = 1;		else {			optlen = cp[IPOPT_OLEN];			if (optlen <= IPOPT_OLEN || optlen > cnt)				goto bad;		}		switch (opt) {		default:			break;		case IPOPT_LSRR:		case IPOPT_SSRR:			/*			 * user process specifies route as:			 *	->A->B->C->D			 * D must be our final destination (but we can't			 * check that since we may not have connected yet).			 * A is first hop destination, which doesn't appear in			 * actual IP option, but is stored before the options.			 */			if (optlen < IPOPT_MINOFF - 1 + sizeof(struct in_addr))				goto bad;			m->m_len -= sizeof(struct in_addr);			cnt -= sizeof(struct in_addr);			optlen -= sizeof(struct in_addr);			cp[IPOPT_OLEN] = optlen;			/*			 * Move first hop before start of options.			 */			bcopy((caddr_t)&cp[IPOPT_OFFSET+1], mtod(m, caddr_t),			    sizeof(struct in_addr));			/*			 * Then copy rest of options back			 * to close up the deleted entry.			 */			ovbcopy((caddr_t)(&cp[IPOPT_OFFSET+1] +			    sizeof(struct in_addr)),			    (caddr_t)&cp[IPOPT_OFFSET+1],			    (unsigned)cnt + sizeof(struct in_addr));			break;