开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
ip_output.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：43k
源码类别：

VxWorks

开发平台：

C/C++

ip_output.c：源码内容
  1. /* ip_output.c - internet output routines */
  3. /* Copyright 1984 - 2001 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1982, 1986, 1988, 1990, 1993
  8.  * The Regents of the University of California.  All rights reserved.
  9.  *
  10.  * Redistribution and use in source and binary forms, with or without
  11.  * modification, are permitted provided that the following conditions
  12.  * are met:
  13.  * 1. Redistributions of source code must retain the above copyright
  14.  *    notice, this list of conditions and the following disclaimer.
  15.  * 2. Redistributions in binary form must reproduce the above copyright
  16.  *    notice, this list of conditions and the following disclaimer in the
  17.  *    documentation and/or other materials provided with the distribution.
  18.  * 3. All advertising materials mentioning features or use of this software
  19.  *    must display the following acknowledgement:
  20.  * This product includes software developed by the University of
  21.  * California, Berkeley and its contributors.
  22.  * 4. Neither the name of the University nor the names of its contributors
  23.  *    may be used to endorse or promote products derived from this software
  24.  *    without specific prior written permission.
  25.  *
  26.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36.  * SUCH DAMAGE.
  37.  *
  38.  * @(#)ip_output.c 8.3 (Berkeley) 1/21/94
  39.  */
  41. /*
  42. modification history
  43. --------------------
  44. 01t,22mar02,wap  export ip_mloopback() so that ipOutput() can use it (SPR
  45.                  #72246)
  46. 01s,29oct01,wap  Fixed mbuf leak in ip_output() (SPR #67966)
  47. 01r,12oct01,rae  merge from truestack ver 01w, base 01o (SPR #69683 etc.)
  48. 01q,07dec00,rae  Add IPsec output hook
  49. 01p,17nov00,rae  allow IP_DROP_MEMBERSHIP with INADDR_ANY (SPR# 33093)
  50. 01o,03sep98,n_s  fixed fragmentation problem for mcast and bcast. spr #21071.
  51. 01n,26aug98,n_s  added return val check for mBufClGet in ip_ctloutput and
  52.                  ip_getmoptions. spr #22238.
  53. 01m,09jan98,vin  changed IP_CKSUM_SEND_MASK to IP_DO_CHECKSUM_SND
  54. 01l,08dec97,vin  fixed ip_freemoptions() SPR 9970. 
  55. 01k,19nov97,vin  changed extern declaration of _ipCfgFlags to int from UCHAR.
  56. 01j,13nov97,vin  provided an additional flag for sending large BCAST pkts.
  57. 01i,05oct97,vin  added fast multicasting.
  58. 01h,15jul97,spm  made IP checksum calculation configurable (SPR #7836)
  59. 01g,08mar97,vin  added mCastRouteFwdHook to access mcast routing code.
  60. 01f,24mar97,vin  bug fixed in ip_mloopback() ip hdr being shared, SPR8252
  61. 01e,13feb97,rjc  fixed bad parameter to TOS_SET
  62. 01d,05feb97,rjc  changes for tos routing and fix for multicast bug.
  63. 01c,05dec96,vin  changed malloc(..) to MALLOC(..) to use only network buffers,
  64.  changed free(..) to FREE(..).
  65. 01b,22nov96,vin  added cluster support replaced m_get(..) with mBufClGet(..)
  66.  replaced m_gethdr with mHdrClGet(..)
  67. 01a,03mar96,vin  created from BSD4.4 stuff,integrated with 02n of ip_output.c
  68. */
  70. #include "vxWorks.h"
  71. #include "netLib.h"
  72. #include "net/mbuf.h"
  73. #include "errno.h"
  74. #include "net/protosw.h"
  75. #include "sys/socket.h"
  76. #include "sys/ioctl.h"
  77. #include "net/socketvar.h"
  79. #include "net/if.h"
  80. #include "net/if_types.h"
  81. #include "net/route.h"
  83. #include "netinet/in.h"
  84. #include "netinet/in_pcb.h"
  85. #include "netinet/in_systm.h"
  86. #include "netinet/in_var.h"
  87. #include "netinet/ip.h"
  88. #include "netinet/ip_var.h"
  89. #include "net/systm.h"
  91. #ifdef WV_INSTRUMENTATION
  92. #ifdef INCLUDE_WVNET
  93. #include "wvNetLib.h"
  94. #endif
  95. #endif
  98. /*IPsec output hook defined in /target/src/wrn/ipsec/ipsec_io.c */
  99. typedef int (*IPSEC_OUTPUT_FUNCPTR) (struct mbuf** m0,
  100.                                      struct mbuf* opt,
  101.                                      struct route* ro, int flags,
  102.                                      struct ip_moptions* imo,struct sockaddr_in* dst,
  103.                                      struct in_ifaddr* ia);
  105. IPSEC_OUTPUT_FUNCPTR    _func_ipsecOutput;
  107. #ifdef VIRTUAL_STACK
  108. #include "netinet/vsLib.h"
  109. #include "netinet/vsMcast.h"
  110. #endif
  112. /* externs */
  114. #ifndef VIRTUAL_STACK
  115. IMPORT int  _ipCfgFlags;  /* Calculate IP checksum? */
  117. extern FUNCPTR _mCastRouteFwdHook; /* WRS mcast forward command hook */
  118. #endif /* VIRTUAL_STACK */
  120. extern int looutput();
  122. static struct mbuf *ip_insertoptions (struct mbuf *, struct mbuf *, int *);
  123. void ip_mloopback (struct ifnet *, struct mbuf *, struct sockaddr_in *,
  124.                    struct rtentry *rt);
  126. static int  ip_setmoptions (int, struct inpcb *, struct mbuf *);
  128. /* locals */
  130. #ifdef WV_INSTRUMENTATION
  131. #ifdef INCLUDE_WVNET
  132.     /* Set common fields of event identifiers for this module. */
  134. LOCAL UCHAR wvNetModuleId = WV_NET_IPOUTPUT_MODULE; /* Value for ip_output.c */
  135. LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */
  137. LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */
  138. #endif    /* INCLUDE_WVNET */
  139. #endif
  141. /*
  142.  * IP output.  The packet in mbuf chain m contains a skeletal IP
  143.  * header (with len, off, ttl, proto, tos, src, dst).
  144.  * The mbuf chain containing the packet will be freed.
  145.  * The mbuf opt, if present, will not be freed.
  146.  */
  147. int
  148. ip_output(m0, opt, ro, flags, imo)
  149. struct mbuf *m0;
  150. struct mbuf *opt;
  151. struct route *ro;
  152. int flags;
  153. struct ip_moptions *imo;
  154. {
  155. register struct ip *ip, *mhip;
  156. register struct ifnet *ifp = NULL;
  157. register struct mbuf *m = m0;
  158. register int hlen = sizeof (struct ip);
  159. int len, off, error = 0;
  160. struct route iproute;
  161. struct sockaddr_in *dst;
  162.         MTU_QUERY mtuQuery;
  163.         int mtu = 0;
  164. struct in_ifaddr *ia = NULL;
  166. #ifdef WV_INSTRUMENTATION
  167. #ifdef INCLUDE_WVNET
  168.         u_long srcAddr; /* Source IP address, unavailable when finished */
  169.         u_long dstAddr; /* Dest. IP address, unavailable when finished */
  170. #endif
  171. #endif
  173. #ifdef DIAGNOSTIC
  174. if ((m->m_flags & M_PKTHDR) == 0)
  175. panic("ip_output no HDR");
  176. #endif
  177. if (opt) {
  178. m = ip_insertoptions(m, opt, &len);
  179. hlen = len;
  180. }
  181. ip = mtod(m, struct ip *);
  182. /*
  183.  * Fill in IP header.
  184.  */
  185. if ((flags & (IP_FORWARDING|IP_RAWOUTPUT)) == 0) {
  186. ip->ip_v = IPVERSION;
  187. ip->ip_off &= IP_DF;
  188. #ifdef VIRTUAL_STACK
  189. ip->ip_id = htons(_ip_id++);
  190. #else
  191. ip->ip_id = htons(ip_id++);
  192. #endif /* VIRTUAL_STACK */
  193. ip->ip_hl = hlen >> 2;
  194. #ifdef VIRTUAL_STACK
  195. _ipstat.ips_localout++;
  196. #else
  197. ipstat.ips_localout++;
  198. #endif /* VIRTUAL_STACK */
  199. } else {
  200. hlen = ip->ip_hl << 2;
  201. }
  203. #ifdef WV_INSTRUMENTATION
  204. #ifdef INCLUDE_WVNET
  205.         /*
  206.          * Save the source and destination address from the original packet,
  207.          * since they will be unavailable at the "done:" label.
  208.          */
  210.         srcAddr = ip->ip_src.s_addr;
  211.         dstAddr = ip->ip_dst.s_addr;
  212. #endif
  213. #endif
  215. /*
  216.  * Route packet.
  217.  */
  218. if (ro == 0) {
  219. ro = &iproute;
  220. bzero((caddr_t)ro, sizeof (*ro));
  221. }
  222. dst = (struct sockaddr_in *)&ro->ro_dst;
  223. /*
  224.  * If there is a cached route,
  225.  * check that it is to the same destination
  226.  * and is still up.  If not, free it and try again.
  227.  */
  228. if (ro->ro_rt && ((ro->ro_rt->rt_flags & RTF_UP) == 0 ||
  229.    dst->sin_addr.s_addr != ip->ip_dst.s_addr)) {
  230. #ifdef WV_INSTRUMENTATION
  231. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  232.         WV_NET_DSTADDROUT_EVENT_2 (NET_CORE_EVENT, WV_NET_VERBOSE, 57, 8,
  233.                                    ip->ip_dst.s_addr,
  234.                                    WV_NETEVENT_IPOUT_CACHEMISS, WV_NET_SEND,
  235.                                    ip->ip_dst.s_addr, dst->sin_addr.s_addr)
  236. #endif  /* INCLUDE_WVNET */
  237. #endif
  239. RTFREE(ro->ro_rt);
  240. ro->ro_rt = (struct rtentry *)0;
  241. }
  242. if (ro->ro_rt == 0) {
  243. dst->sin_family = AF_INET;
  244. dst->sin_len = sizeof(*dst);
  245. dst->sin_addr = ip->ip_dst;
  246. TOS_SET (dst, ip->ip_tos);
  247. }
  248. /*
  249.  * If routing to interface only,
  250.  * short circuit routing lookup.
  251.  */
  252. #define ifatoia(ifa) ((struct in_ifaddr *)(ifa))
  253. #define sintosa(sin) ((struct sockaddr *)(sin))
  254. if (flags & IP_ROUTETOIF ) {
  255. if ((ia = ifatoia(ifa_ifwithdstaddr(sintosa(dst)))) == 0 &&
  256.     (ia = ifatoia(ifa_ifwithnet(sintosa(dst)))) == 0) {
  257. #ifdef WV_INSTRUMENTATION
  258. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  259.         WV_NET_DSTADDROUT_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 20, 1,
  260.                                    ip->ip_dst.s_addr,
  261.                                    WV_NETEVENT_IPOUT_BADADDR, WV_NET_SEND,
  262.                                    dst->sin_addr.s_addr)
  263. #endif  /* INCLUDE_WVNET */
  264. #endif
  266. #ifdef VIRTUAL_STACK
  267. _ipstat.ips_noroute++;
  268. #else
  269. ipstat.ips_noroute++;
  270. #endif /* VIRTUAL_STACK */
  271. error = ENETUNREACH;
  272. goto bad;
  273. }
  274. ifp = ia->ia_ifp;
  275. ip->ip_ttl = 1;
  276. } else if (! (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) && imo &&
  277.               ((imo->imo_multicast_ifp != NULL)))) {
  278. if (ro->ro_rt == 0)
  279. rtalloc(ro);
  280. if (ro->ro_rt == 0) {
  281. #ifdef WV_INSTRUMENTATION
  282. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  283.         WV_NET_DSTADDROUT_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 20, 1,
  284.                                    ip->ip_dst.s_addr,
  285.                                    WV_NETEVENT_IPOUT_BADADDR, WV_NET_SEND,
  286.                                    dst->sin_addr.s_addr)
  287. #endif  /* INCLUDE_WVNET */
  288. #endif
  290. #ifdef VIRTUAL_STACK
  291. _ipstat.ips_noroute++;
  292. #else
  293. ipstat.ips_noroute++;
  294. #endif /* VIRTUAL_STACK */
  295. error = EHOSTUNREACH;
  296. goto bad;
  297. }
  298. ia = ifatoia(ro->ro_rt->rt_ifa);
  299. ifp = ro->ro_rt->rt_ifp;
  300. ro->ro_rt->rt_use++;
  301. if (ro->ro_rt->rt_flags & RTF_GATEWAY)
  302. dst = (struct sockaddr_in *)ro->ro_rt->rt_gateway;
  303. }
  304. if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr))) {
  305. struct in_multi *inm;
  306. #ifndef VIRTUAL_STACK
  307. extern struct ifnet loif[];
  308. #endif /* VIRTUAL_STACK */
  310. m->m_flags |= M_MCAST;
  311. /*
  312.  * IP destination address is multicast.  Make sure "dst"
  313.  * still points to the address in "ro".  (It may have been
  314.  * changed to point to a gateway address, above.)
  315.  */
  316. dst = (struct sockaddr_in *)&ro->ro_dst;
  318.                if (imo && imo->imo_multicast_ifp != NULL) 
  319.                    {
  321.                    register struct in_ifaddr *ia;
  323. #ifdef VIRTUAL_STACK
  324.                    for (ia = _in_ifaddr; ia; ia = ia->ia_next)
  325. #else
  326.                    for (ia = in_ifaddr; ia; ia = ia->ia_next)
  327. #endif /* VIRTUAL_STACK */
  328.                        if (ia->ia_ifp == ifp) 
  329.                            {
  330.            dst->sin_addr.s_addr = IA_SIN(ia)->sin_addr.s_addr;
  331.                    break;
  332.    }
  334.                    if (ro->ro_rt)
  335.                        {
  336.                        RTFREE(ro->ro_rt);
  337.                        ro->ro_rt = (struct rtentry *)0;
  338.                        }
  339.                    }
  341. /*
  342.  * See if the caller provided any multicast options
  343.  */
  344. if (imo != NULL) {
  345. ip->ip_ttl = imo->imo_multicast_ttl;
  346. if (imo->imo_multicast_ifp != NULL)
  347. ifp = imo->imo_multicast_ifp;
  348. } else
  349. ip->ip_ttl = IP_DEFAULT_MULTICAST_TTL;
  350. /*
  351.  * Confirm that the outgoing interface supports multicast.
  352.  */
  353. if ((ifp->if_flags & IFF_MULTICAST) == 0) {
  354. #ifdef WV_INSTRUMENTATION
  355. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  356.         WV_NET_DSTADDROUT_EVENT_2 (NET_CORE_EVENT, WV_NET_CRITICAL, 21, 2,
  357.                                    ip->ip_dst.s_addr,
  358.                                    WV_NETEVENT_IPOUT_BADFLAGS, WV_NET_SEND,
  359.                                    dst->sin_addr.s_addr, ifp)
  360. #endif  /* INCLUDE_WVNET */
  361. #endif
  363. #ifdef VIRTUAL_STACK
  364. _ipstat.ips_noroute++;
  365. #else
  366. ipstat.ips_noroute++;
  367. #endif /* VIRTUAL_STACK */
  368. error = ENETUNREACH;
  369. goto bad;
  370. }
  371. /*
  372.  * If source address not specified yet, use address
  373.  * of outgoing interface.
  374.  */
  375. if (ip->ip_src.s_addr == INADDR_ANY) {
  376. register struct in_ifaddr *ia;
  378. #ifdef VIRTUAL_STACK
  379. for (ia = _in_ifaddr; ia; ia = ia->ia_next)
  380. #else
  381. for (ia = in_ifaddr; ia; ia = ia->ia_next)
  382. #endif /* VIRTUAL_STACK */
  383. if (ia->ia_ifp == ifp) {
  384. ip->ip_src = IA_SIN(ia)->sin_addr;
  385. break;
  386. }
  387. #ifdef WV_INSTRUMENTATION
  388. #ifdef INCLUDE_WVNET
  389.         /*
  390.          * Update the source destination address if not previously
  391.          * specified, since it will be unavailable at the "done:" label.
  392.          */
  394.         srcAddr = ip->ip_src.s_addr;
  395. #endif
  396. #endif
  397. }
  399. IN_LOOKUP_MULTI(ip->ip_dst, ifp, inm);
  400. if (inm != NULL &&
  401.    (imo == NULL || imo->imo_multicast_loop)) {
  402. /*
  403.  * If we belong to the destination multicast group
  404.  * on the outgoing interface, and the caller did not
  405.  * forbid loopback, loop back a copy.
  406.  */
  407. ip_mloopback(ifp, m, dst, NULL);
  408. }
  409. else {
  410. /*
  411.  * If we are acting as a multicast router, perform
  412.  * multicast forwarding as if the packet had just
  413.  * arrived on the interface to which we are about
  414.  * to send.  The multicast forwarding function
  415.  * recursively calls this function, using the
  416.  * IP_FORWARDING flag to prevent infinite recursion.
  417.  *
  418.  * Multicasts that are looped back by ip_mloopback(),
  419.  * above, will be forwarded by the ip_input() routine,
  420.  * if necessary.
  421.  */
  422.                  if ((_mCastRouteFwdHook != NULL) &&
  423.                             ((flags & IP_FORWARDING) == 0)) {
  424. if ((*_mCastRouteFwdHook)(m, ifp, ip, NULL) != 0) {
  425. m_freem(m);
  426. goto done;
  427. }
  428. }
  429. }
  430. /*
  431.  * Multicasts with a time-to-live of zero may be looped-
  432.  * back, above, but must not be transmitted on a network.
  433.  * Also, multicasts addressed to the loopback interface
  434.  * are not sent -- the above call to ip_mloopback() will
  435.  * loop back a copy if this host actually belongs to the
  436.  * destination group on the loopback interface.
  437.  */
  438. if (ip->ip_ttl == 0 || ifp == loif) {
  439. m_freem(m);
  440. goto done;
  441. }
  443.                 /*
  444.                  * Use the predefined MTU size for outgoing packets. The
  445.                  * point-to-multipoint devices which permit a different
  446.                  * value do not support multicast addresses.
  447.                  */
  449.                 mtu = ifp->if_mtu;
  451. goto sendit;
  452. }
  453. #ifndef notdef
  454. /*
  455.  * If source address not specified yet, use address
  456.  * of outgoing interface.
  457.  */
  458. if (ip->ip_src.s_addr == INADDR_ANY)
  459. ip->ip_src = IA_SIN(ia)->sin_addr;
  461. #ifdef WV_INSTRUMENTATION
  462. #ifdef INCLUDE_WVNET
  463.         /*
  464.          * Update the source destination address if not previously 
  465.          * specified, since it will be unavailable at the "done:" label.
  466.          */
  468.         srcAddr = ip->ip_src.s_addr;
  469. #endif
  470. #endif
  472. #endif
  474.         /*
  475.          * Get the MTU size. Point-to-multipoint devices allow a separate
  476.          * MTU for each destination address. All other devices use a
  477.          * predefined size.
  478.          */
  480.         if (ifp->if_type == IFT_PMP)
  481.             {
  482.             /*
  483.              * The SIOCGMTU operation reads the address from the
  484.              * argument and returns the corresponding MTU size.
  485.              */
  487.             mtuQuery.family = AF_INET;
  488.             mtuQuery.dstIpAddr = dst->sin_addr.s_addr;
  489.             error = ifp->if_ioctl (ifp, SIOCGMTU, (caddr_t)&mtuQuery);
  490.             if (error)
  491.                 {
  492.                 error = EHOSTUNREACH;
  493.                 goto bad;
  494.                 }
  495.             mtu = mtuQuery.mtu;
  496.             }
  497.         else
  498.             mtu = ifp->if_mtu;
  500. /*
  501.  * Look for broadcast address and
  502.  * and verify user is allowed to send
  503.  * such a packet.
  504.  */
  505. if (in_broadcast(dst->sin_addr, ifp)) {
  506. if ((ifp->if_flags & IFF_BROADCAST) == 0) {
  507. #ifdef WV_INSTRUMENTATION
  508. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  509.             WV_NET_ADDROUT_EVENT_2 (NET_CORE_EVENT, WV_NET_CRITICAL, 21, 2,
  510.                                     ip->ip_src.s_addr, ip->ip_dst.s_addr,
  511.                                     WV_NETEVENT_IPOUT_BADFLAGS, WV_NET_SEND,
  512.                                     dst->sin_addr.s_addr, ifp)
  513. #endif  /* INCLUDE_WVNET */
  514. #endif
  516. error = EADDRNOTAVAIL;
  517. goto bad;
  518. }
  519. if ((flags & IP_ALLOWBROADCAST) == 0) {
  520. #ifdef WV_INSTRUMENTATION
  521. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  522.             WV_NET_ADDROUT_EVENT_2 (NET_CORE_EVENT, WV_NET_CRITICAL, 21, 2,
  523.                                     ip->ip_src.s_addr, ip->ip_dst.s_addr,
  524.                                     WV_NETEVENT_IPOUT_BADFLAGS, WV_NET_SEND,
  525.                                     dst->sin_addr.s_addr, 0)
  526. #endif  /* INCLUDE_WVNET */
  527. #endif
  529. error = EACCES;
  530. goto bad;
  531. }
  532. /* allow broadcast messages to be fragmented if flag set */
  533. if (((u_short)ip->ip_len > mtu) &&
  534.                     !(_ipCfgFlags & IP_DO_LARGE_BCAST)) {
  535. #ifdef WV_INSTRUMENTATION
  536. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  537.             WV_NET_ADDROUT_EVENT_2 (NET_CORE_EVENT, WV_NET_CRITICAL, 22, 3,
  538.                                     ip->ip_src.s_addr, ip->ip_dst.s_addr,
  539.                                     WV_NETEVENT_IPOUT_CANTFRAG, WV_NET_SEND,
  540.                                     dst->sin_addr.s_addr, ifp)
  541. #endif  /* INCLUDE_WVNET */
  542. #endif
  544. error = EMSGSIZE;
  545. goto bad;
  546. }
  547. m->m_flags |= M_BCAST;
  548. } else
  549. m->m_flags &= ~M_BCAST;
  551. sendit:
  552.         if (_func_ipsecOutput != NULL)
  553.             {
  554.             /* Deliver the packet to ipsec for further processing/filtering. */
  555.             error = _func_ipsecOutput (&m0, opt, ro, flags, imo, dst, ia);
  556.             m = m0;
  557.             ip = mtod(m, struct ip *);
  558.             if (error != 0)
  559.                 {
  560.                 /* If there is an error we should have already freed the packet */
  561.                 if (error == ERROR)
  562.                     {
  563.                     /* Unless the error is very specific we do not propagate the error; so we reset it */
  564.                     error = OK;
  565.                     }
  566.                 goto done;
  567.                 }
  568.             }
  569. /*
  570.  * If small enough for interface, can just send directly.
  571.  */
  572. if ((u_short)ip->ip_len <= mtu) {
  573. #ifdef WV_INSTRUMENTATION
  574. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  575.             WV_NET_ADDROUT_EVENT_4 (NET_CORE_EVENT, WV_NET_INFO, 54, 10,
  576.                                     ip->ip_src.s_addr, ip->ip_dst.s_addr,
  577.                                     WV_NETEVENT_IPOUT_SENDALL, WV_NET_SEND,
  578.                                     ip->ip_src.s_addr, ip->ip_dst.s_addr,
  579.                                     (u_long)ip->ip_len, mtu)
  580. #endif  /* INCLUDE_WVNET */
  581. #endif
  582. ip->ip_len = htons((u_short)ip->ip_len);
  583. ip->ip_off = htons((u_short)ip->ip_off);
  585. ip->ip_sum = 0;
  586.                 if (_ipCfgFlags & IP_DO_CHECKSUM_SND)
  587.                     ip->ip_sum = in_cksum(m, hlen);
  589. error = (*ifp->if_output)(ifp, m,
  590. (struct sockaddr *)dst, ro->ro_rt);
  591. goto done;
  592. }
  593. /*
  594.  * Too large for interface; fragment if possible.
  595.  * Must be able to put at least 8 bytes per fragment.
  596.  */
  597. if (ip->ip_off & IP_DF) {
  598. #ifdef WV_INSTRUMENTATION
  599. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  600.             WV_NET_ADDROUT_EVENT_2 (NET_CORE_EVENT, WV_NET_CRITICAL, 22, 3,
  601.                                     ip->ip_src.s_addr, ip->ip_dst.s_addr,
  602.                                     WV_NETEVENT_IPOUT_CANTFRAG, WV_NET_SEND,
  603.                                     dst->sin_addr.s_addr, ifp)
  604. #endif  /* INCLUDE_WVNET */
  605. #endif
  607. error = EMSGSIZE;
  609.             /*
  610.              * If the interface is using a new (smaller) MTU size than
  611.              * originally assigned, update the current path MTU estimate
  612.              * (if any) to the new (largest possible) value.
  613.              */
  615.             if (ro->ro_rt && (ro->ro_rt->rt_flags & (RTF_UP | RTF_HOST))
  616.                 && !(ro->ro_rt->rt_rmx.rmx_locks & RTV_MTU)
  617.                 && (ro->ro_rt->rt_rmx.rmx_mtu > mtu))
  618.                 {
  619.                 ro->ro_rt->rt_rmx.rmx_mtu = mtu;
  620.                 }
  622. #ifdef VIRTUAL_STACK
  623. _ipstat.ips_cantfrag++;
  624. #else
  625. ipstat.ips_cantfrag++;
  626. #endif /* VIRTUAL_STACK */
  627. goto bad;
  628. }
  629. len = (mtu - hlen) &~ 7;
  630. if (len < 8) {
  631. #ifdef WV_INSTRUMENTATION
  632. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  633.             WV_NET_ADDROUT_EVENT_2 (NET_CORE_EVENT, WV_NET_CRITICAL, 23, 4,
  634.                                     ip->ip_src.s_addr, ip->ip_dst.s_addr,
  635.                                     WV_NETEVENT_IPOUT_SHORTMSG, WV_NET_SEND,
  636.                                     dst->sin_addr.s_addr, ifp)
  637. #endif  /* INCLUDE_WVNET */
  638. #endif
  640. error = EMSGSIZE;
  641. goto bad;
  642. }
  644.     {
  645. int mhlen, firstlen = len;
  646. struct mbuf **mnext = &m->m_nextpkt;
  648. #ifdef WV_INSTRUMENTATION
  649. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  650.         WV_NET_ADDROUT_EVENT_4 (NET_CORE_EVENT, WV_NET_INFO, 55, 11,
  651.                                 ip->ip_src.s_addr, ip->ip_dst.s_addr,
  652.                                 WV_NETEVENT_IPOUT_SENDFRAG, WV_NET_SEND,
  653.                                 dst->sin_addr.s_addr, (u_long)ip->ip_len,
  654.                                 hlen, mtu);
  655. #endif  /* INCLUDE_WVNET */
  656. #endif
  658. /*
  659.  * Loop through length of segment after first fragment,
  660.  * make new header and copy data of each part and link onto chain.
  661.  */
  662. m0 = m;
  663. mhlen = sizeof (struct ip);
  664. for (off = hlen + len; off < (u_short)ip->ip_len; off += len) {
  665. m= mHdrClGet(M_DONTWAIT, MT_HEADER, CL_SIZE_128, TRUE);
  666. if (m == 0) {
  667. error = ENOBUFS;
  668. #ifdef VIRTUAL_STACK
  669. _ipstat.ips_odropped++;
  670. #else
  671. ipstat.ips_odropped++;
  672. #endif /* VIRTUAL_STACK */
  673. goto sendorfree;
  674. }
  675. m->m_flags = m0->m_flags;
  676. m->m_data += max_linkhdr;
  677. mhip = mtod(m, struct ip *);
  678. *mhip = *ip;
  679. if (hlen > sizeof (struct ip)) {
  680. mhlen = ip_optcopy(ip, mhip) + sizeof (struct ip);
  681. mhip->ip_hl = mhlen >> 2;
  682. }
  683. m->m_len = mhlen;
  684. mhip->ip_off = ((off - hlen) >> 3) + (ip->ip_off & ~IP_MF);
  685. if (ip->ip_off & IP_MF)
  686. mhip->ip_off |= IP_MF;
  687. if (off + len >= (u_short)ip->ip_len)
  688. len = (u_short)ip->ip_len - off;
  689. else
  690. mhip->ip_off |= IP_MF;
  691. mhip->ip_len = htons((u_short)(len + mhlen));
  692. m->m_next = m_copy(m0, off, len);
  693. if (m->m_next == 0) {
  694. (void) m_free(m);
  695. error = ENOBUFS; /* ??? */
  696. #ifdef VIRTUAL_STACK
  697. _ipstat.ips_odropped++;
  698. #else
  699. ipstat.ips_odropped++;
  700. #endif /* VIRTUAL_STACK */
  701. goto sendorfree;
  702. }
  703. m->m_pkthdr.len = mhlen + len;
  704. m->m_pkthdr.rcvif = (struct ifnet *)0;
  705. mhip->ip_off = htons((u_short)mhip->ip_off);
  707.                 mhip->ip_sum = 0;
  708.                 if (_ipCfgFlags & IP_DO_CHECKSUM_SND)
  709.                     mhip->ip_sum = in_cksum(m, mhlen);
  711. *mnext = m;
  712. mnext = &m->m_nextpkt;
  713. #ifdef VIRTUAL_STACK
  714. _ipstat.ips_ofragments++;
  715. #else
  716. ipstat.ips_ofragments++;
  717. #endif /* VIRTUAL_STACK */
  718. }
  719. /*
  720.  * Update first fragment by trimming what's been copied out
  721.  * and updating header, then send each fragment (in order).
  722.  */
  723. m = m0;
  724. m_adj(m, hlen + firstlen - (u_short)ip->ip_len);
  725. m->m_pkthdr.len = hlen + firstlen;
  726. ip->ip_len = htons((u_short)m->m_pkthdr.len);
  727. ip->ip_off = htons((u_short)(ip->ip_off | IP_MF));
  729.         ip->ip_sum = 0;
  730.         if (_ipCfgFlags & IP_DO_CHECKSUM_SND)
  731.             ip->ip_sum = in_cksum(m, hlen);
  732. sendorfree:
  733. for (m = m0; m; m = m0) {
  734. m0 = m->m_nextpkt;
  735. m->m_nextpkt = 0;
  736. if (error == 0)
  737. error = (*ifp->if_output)(ifp, m,
  738.     (struct sockaddr *)dst, ro->ro_rt);
  739. else
  740. m_freem(m);
  741. }
  743. if (error == 0)
  744. #ifdef VIRTUAL_STACK
  745. _ipstat.ips_fragmented++;
  746. #else
  747. ipstat.ips_fragmented++;
  748. #endif /* VIRTUAL_STACK */
  749.     }
  750. done:
  752. #ifdef WV_INSTRUMENTATION
  753. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  754.     WV_NET_ADDROUT_EVENT_4 (NET_CORE_EVENT, WV_NET_ERROR, 31, 9,
  755.                             srcAddr, dstAddr,
  756.                             WV_NETEVENT_IPOUT_FINISH, WV_NET_SEND,
  757.                             error, ifp, srcAddr, dstAddr)
  758. #endif  /* INCLUDE_WVNET */
  759. #endif
  761. if ((ro == &iproute) && ((flags & IP_ROUTETOIF) == 0) && ro->ro_rt) {
  762. RTFREE(ro->ro_rt);
  763. }
  764. return (error);
  765. bad:
  766. m_freem(m);
  767. goto done;
  768. }
  770. /*
  771.  * Insert IP options into preformed packet.
  772.  * Adjust IP destination as required for IP source routing,
  773.  * as indicated by a non-zero in_addr at the start of the options.
  774.  */
  775. static struct mbuf *
  776. ip_insertoptions(m, opt, phlen)
  777. register struct mbuf *m;
  778. struct mbuf *opt;
  779. int *phlen;
  780. {
  781. register struct ipoption *p = mtod(opt, struct ipoption *);
  782. struct mbuf *n;
  783. register struct ip *ip = mtod(m, struct ip *);
  784. unsigned optlen;
  786. optlen = opt->m_len - sizeof(p->ipopt_dst);
  787. if (optlen + (u_short)ip->ip_len > IP_MAXPACKET)
  788. return (m); /* XXX should fail */
  789. if (p->ipopt_dst.s_addr)
  790. ip->ip_dst = p->ipopt_dst;
  791. #if 0 /* XXX changed for default cluster support vinai
  792.          * The reason why always new clusters are allocted,
  793.          * is that, data could be overwritten since clusters are shared.
  794.          */
  795. if (m->m_flags & M_EXT || m->m_data - optlen < m->m_pktdat) {
  796. #endif
  797. n = mHdrClGet(M_DONTWAIT, MT_HEADER, CL_SIZE_128, TRUE);
  798. if (n == 0)
  799. return (m);
  800. n->m_pkthdr.len = m->m_pkthdr.len + optlen;
  801. m->m_len -= sizeof(struct ip);
  802. m->m_data += sizeof(struct ip);
  803. n->m_next = m;
  804. m = n;
  805. m->m_len = optlen + sizeof(struct ip);
  806. m->m_data += max_linkhdr;
  807. bcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
  808. #if 0  /* XXX changed for default cluster support vinai */               
  809. } else {
  810. m->m_data -= optlen;
  811. m->m_len += optlen;
  812. m->m_pkthdr.len += optlen;
  813. ovbcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
  814. }
  815. #endif        
  816. ip = mtod(m, struct ip *);
  817. bcopy((caddr_t)p->ipopt_list, (caddr_t)(ip + 1), (unsigned)optlen);
  818. *phlen = sizeof(struct ip) + optlen;
  819. ip->ip_len += optlen;
  820. return (m);
  821. }
  823. /*
  824.  * Copy options from ip to jp,
  825.  * omitting those not copied during fragmentation.
  826.  */
  827. int
  828. ip_optcopy(ip, jp)
  829. struct ip *ip, *jp;
  830. {
  831. register u_char *cp, *dp;
  832. int opt, optlen, cnt;
  834. cp = (u_char *)(ip + 1);
  835. dp = (u_char *)(jp + 1);
  836. cnt = (ip->ip_hl << 2) - sizeof (struct ip);
  837. for (; cnt > 0; cnt -= optlen, cp += optlen) {
  838. opt = cp[0];
  839. if (opt == IPOPT_EOL)
  840. break;
  841. if (opt == IPOPT_NOP) {
  842. /* Preserve for IP mcast tunnel's LSRR alignment. */
  843. *dp++ = IPOPT_NOP;
  844. optlen = 1;
  845. continue;
  846. } else
  847. optlen = cp[IPOPT_OLEN];
  848. /* bogus lengths should have been caught by ip_dooptions */
  849. if (optlen > cnt)
  850. optlen = cnt;
  851. if (IPOPT_COPIED(opt)) {
  852. bcopy((caddr_t)cp, (caddr_t)dp, (unsigned)optlen);
  853. dp += optlen;
  854. }
  855. }
  856. for (optlen = dp - (u_char *)(jp+1); optlen & 0x3; optlen++)
  857. *dp++ = IPOPT_EOL;
  858. return (optlen);
  859. }
  861. /*
  862.  * IP socket option processing.
  863.  */
  864. int
  865. ip_ctloutput(op, so, level, optname, mp)
  866. int op;
  867. struct socket *so;
  868. int level, optname;
  869. struct mbuf **mp;
  870. {
  871. register struct inpcb *inp = sotoinpcb(so);
  872. register struct mbuf *m = *mp;
  873. register int optval = 0;
  874. int error = 0;
  876. #ifdef WV_INSTRUMENTATION
  877. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  878.     WV_NET_MARKER_4 (NET_AUX_EVENT, WV_NET_INFO, 11, 6,
  879.                      WV_NETEVENT_IPOUTCTRL_START,
  880.                      so->so_fd, op, level, optname)
  881. #endif  /* INCLUDE_WVNET */
  882. #endif
  884. if (level != IPPROTO_IP) {
  885. error = EINVAL;
  886. if (op == PRCO_SETOPT && *mp)
  887. (void) m_free(*mp);
  888. } else switch (op) {
  890. case PRCO_SETOPT:
  891. switch (optname) {
  892. case IP_OPTIONS:
  893. #ifdef notyet
  894. case IP_RETOPTS:
  895. return (ip_pcbopts(optname, &inp->inp_options, m));
  896. #else
  897. return (ip_pcbopts(&inp->inp_options, m));
  898. #endif
  900. case IP_TOS:
  901. case IP_TTL:
  902. case IP_RECVOPTS:
  903. case IP_RECVRETOPTS:
  904. case IP_RECVDSTADDR:
  905. if (m->m_len != sizeof(int))
  906. error = EINVAL;
  907. else {
  908. optval = *mtod(m, int *);
  909. switch (optname) {
  911. case IP_TOS:
  912. inp->inp_ip.ip_tos = optval;
  913. break;
  915. case IP_TTL:
  916. inp->inp_ip.ip_ttl = optval;
  917. break;
  918. #define OPTSET(bit) 
  919. if (optval) 
  920. inp->inp_flags |= bit; 
  921. else 
  922. inp->inp_flags &= ~bit;
  924. case IP_RECVOPTS:
  925. OPTSET(INP_RECVOPTS);
  926. break;
  928. case IP_RECVRETOPTS:
  929. OPTSET(INP_RECVRETOPTS);
  930. break;
  932. case IP_RECVDSTADDR:
  933. OPTSET(INP_RECVDSTADDR);
  934. break;
  935. }
  936. }
  937. break;
  938. #undef OPTSET
  940. case IP_MULTICAST_IF:
  941. case IP_MULTICAST_TTL:
  942. case IP_MULTICAST_LOOP:
  943. case IP_ADD_MEMBERSHIP:
  944. case IP_DROP_MEMBERSHIP:
  945. error = ip_setmoptions(optname, inp, m);
  946. break;
  948. default:
  949. #ifdef WV_INSTRUMENTATION
  950. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  951.                     WV_NET_MARKER_4 (NET_AUX_EVENT, WV_NET_ERROR, 30, 5,
  952.                                      WV_NETEVENT_IPOUTCTRL_BADCMD,
  953.                                      so->so_fd, op, level, optname)
  954. #endif  /* INCLUDE_WVNET */
  955. #endif
  957. error = ENOPROTOOPT;
  958. break;
  959. }
  960. if (m)
  961. (void)m_free(m);
  962. break;
  964. case PRCO_GETOPT:
  965. switch (optname) {
  966. case IP_OPTIONS:
  967. case IP_RETOPTS:
  968. *mp = m = mBufClGet(M_WAIT, MT_SOOPTS, CL_SIZE_128,
  969.     TRUE);
  970. if (m == NULL)
  971.     {
  972.     error = ENOBUFS;
  973.     break;
  974.     }
  976. if (inp->inp_options) {
  977. m->m_len = inp->inp_options->m_len;
  978. bcopy(mtod(inp->inp_options, caddr_t),
  979.     mtod(m, caddr_t), (unsigned)m->m_len);
  980. } else
  981. m->m_len = 0;
  982. break;
  984. case IP_TOS:
  985. case IP_TTL:
  986. case IP_RECVOPTS:
  987. case IP_RECVRETOPTS:
  988. case IP_RECVDSTADDR:
  989. *mp = m = mBufClGet(M_WAIT, MT_SOOPTS, CL_SIZE_128,
  990.     TRUE);
  991. if (m == NULL)
  992.     {
  993.     error = ENOBUFS;
  994.     break;
  995.     }
  997. m->m_len = sizeof(int);
  998. switch (optname) {
  1000. case IP_TOS:
  1001. optval = inp->inp_ip.ip_tos;
  1002. break;
  1004. case IP_TTL:
  1005. optval = inp->inp_ip.ip_ttl;
  1006. break;
  1008. #define OPTBIT(bit) (inp->inp_flags & bit ? 1 : 0)
  1010. case IP_RECVOPTS:
  1011. optval = OPTBIT(INP_RECVOPTS);
  1012. break;
  1014. case IP_RECVRETOPTS:
  1015. optval = OPTBIT(INP_RECVRETOPTS);
  1016. break;
  1018. case IP_RECVDSTADDR:
  1019. optval = OPTBIT(INP_RECVDSTADDR);
  1020. break;
  1021. }
  1022. *mtod(m, int *) = optval;
  1023. break;
  1025. case IP_MULTICAST_IF:
  1026. case IP_MULTICAST_TTL:
  1027. case IP_MULTICAST_LOOP:
  1028. case IP_ADD_MEMBERSHIP:
  1029. case IP_DROP_MEMBERSHIP:
  1030. error = ip_getmoptions(optname, inp->inp_moptions, mp);
  1031. break;
  1033. default:
  1034. #ifdef WV_INSTRUMENTATION
  1035. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  1036.                     WV_NET_MARKER_4 (NET_AUX_EVENT, WV_NET_ERROR, 30, 5,
  1037.                                      WV_NETEVENT_IPOUTCTRL_BADCMD,
  1038.                                      so->so_fd, op, level, optname)
  1039. #endif  /* INCLUDE_WVNET */
  1040. #endif
  1042. error = ENOPROTOOPT;
  1043. break;
  1044. }
  1045. break;
  1046. }
  1047. return (error);
  1048. }
  1050. /*
  1051.  * Set up IP options in pcb for insertion in output packets.
  1052.  * Store in mbuf with pointer in pcbopt, adding pseudo-option
  1053.  * with destination address if source routed.
  1054.  */
  1055. int
  1056. #ifdef notyet
  1057. ip_pcbopts(optname, pcbopt, m)
  1058. int optname;
  1059. #else
  1060. ip_pcbopts(pcbopt, m)
  1061. #endif
  1062. struct mbuf **pcbopt;
  1063. register struct mbuf *m;
  1064. {
  1065. register int cnt, optlen;
  1066. register u_char *cp;
  1067. u_char opt;
  1069. /* turn off any old options */
  1070. if (*pcbopt)
  1071. (void)m_free(*pcbopt);
  1072. *pcbopt = 0;
  1073. if (m == (struct mbuf *)0 || m->m_len == 0) {
  1074. /*
  1075.  * Only turning off any previous options.
  1076.  */
  1077. if (m)
  1078. (void)m_free(m);
  1079. return (0);
  1080. }
  1082. #ifndef vax
  1083. if (m->m_len % sizeof(long))
  1084. goto bad;
  1085. #endif
  1086. /*
  1087.  * IP first-hop destination address will be stored before
  1088.  * actual options; move other options back
  1089.  * and clear it when none present.
  1090.  */
  1091. #if 0 /*XXX changed for default cluster support vinai*/
  1092. if (m->m_data + m->m_len + sizeof(struct in_addr) >= &m->m_dat[MLEN])
  1093. goto bad;
  1094. #else
  1095. if (m->m_data + m->m_len + sizeof(struct in_addr) >= 
  1096.     (m->m_extBuf + m->m_extSize))
  1097. goto bad;
  1098. #endif
  1099. cnt = m->m_len;
  1100. m->m_len += sizeof(struct in_addr);
  1101. cp = mtod(m, u_char *) + sizeof(struct in_addr);
  1102. ovbcopy(mtod(m, caddr_t), (caddr_t)cp, (unsigned)cnt);
  1103. bzero(mtod(m, caddr_t), sizeof(struct in_addr));
  1105. for (; cnt > 0; cnt -= optlen, cp += optlen) {
  1106. opt = cp[IPOPT_OPTVAL];
  1107. if (opt == IPOPT_EOL)
  1108. break;
  1109. if (opt == IPOPT_NOP)
  1110. optlen = 1;
  1111. else {
  1112. optlen = cp[IPOPT_OLEN];
  1113. if (optlen <= IPOPT_OLEN || optlen > cnt)
  1114. goto bad;
  1115. }
  1116. switch (opt) {
  1118. default:
  1119. break;
  1121. case IPOPT_LSRR:
  1122. case IPOPT_SSRR:
  1123. /*
  1124.  * user process specifies route as:
  1125.  * ->A->B->C->D
  1126.  * D must be our final destination (but we can't
  1127.  * check that since we may not have connected yet).
  1128.  * A is first hop destination, which doesn't appear in
  1129.  * actual IP option, but is stored before the options.
  1130.  */
  1131. if (optlen < IPOPT_MINOFF - 1 + sizeof(struct in_addr))
  1132. goto bad;
  1133. m->m_len -= sizeof(struct in_addr);
  1134. cnt -= sizeof(struct in_addr);
  1135. optlen -= sizeof(struct in_addr);
  1136. cp[IPOPT_OLEN] = optlen;
  1137. /*
  1138.  * Move first hop before start of options.
  1139.  */
  1140. bcopy((caddr_t)&cp[IPOPT_OFFSET+1], mtod(m, caddr_t),
  1141.     sizeof(struct in_addr));
  1142. /*
  1143.  * Then copy rest of options back
  1144.  * to close up the deleted entry.
  1145.  */
  1146. ovbcopy((caddr_t)(&cp[IPOPT_OFFSET+1] +
  1147.     sizeof(struct in_addr)),
  1148.     (caddr_t)&cp[IPOPT_OFFSET+1],
  1149.     (unsigned)cnt + sizeof(struct in_addr));
  1150. break;
  1151. }
  1152. }
  1153. if (m->m_len > MAX_IPOPTLEN + sizeof(struct in_addr))
  1154. goto bad;
  1155. *pcbopt = m;
  1156. return (0);
  1158. bad:
  1159. (void)m_free(m);
  1160. return (EINVAL);
  1161. }
  1163. /*
  1164.  * Set the IP multicast options in response to user setsockopt().
  1165.  */
  1166. static int ip_setmoptions
  1167.     (
  1168.     int optname,
  1169.     struct inpcb *  pInPcb,
  1170.     struct mbuf * m
  1171.     )
  1172. {
  1173. register int error = 0;
  1174. u_char loop;
  1175. struct in_addr addr;
  1176. register struct ip_mreq *mreq;
  1177. register struct ifnet *ifp;
  1178.         register struct ip_moptions ** imop = &pInPcb->inp_moptions;
  1179. register struct ip_moptions *imo = *imop;
  1181. struct route ro;
  1182. register struct sockaddr_in *dst;
  1183.         struct in_multi *  pInMulti;
  1184.         M_BLK_ID  pInmMblk = NULL;
  1185.         M_BLK ** ppMblk;
  1187. if (imo == NULL) {
  1188. /*
  1189.  * No multicast option buffer attached to the pcb;
  1190.  * allocate one and initialize to default values.
  1191.  */
  1192. MALLOC(imo,struct ip_moptions *, sizeof (*imo),
  1193.        MT_IPMOPTS, M_WAIT);
  1194. if (imo == NULL)
  1195. return (ENOBUFS);
  1196. *imop = imo;
  1197. imo->imo_multicast_ifp = NULL;
  1198. imo->imo_multicast_ttl = IP_DEFAULT_MULTICAST_TTL;
  1199. imo->imo_multicast_loop = IP_DEFAULT_MULTICAST_LOOP;
  1200. imo->imo_num_memberships = 0;
  1201.                 imo->pInmMblk = NULL; 
  1202. }
  1204. switch (optname) {
  1206. case IP_MULTICAST_IF:
  1207. /*
  1208.  * Select the interface for outgoing multicast packets.
  1209.  */
  1210. if (m == NULL || m->m_len != sizeof(struct in_addr)) {
  1211. error = EINVAL;
  1212. break;
  1213. }
  1214. addr = *(mtod(m, struct in_addr *));
  1215. /*
  1216.  * INADDR_ANY is used to remove a previous selection.
  1217.  * When no interface is selected, a default one is
  1218.  * chosen every time a multicast packet is sent.
  1219.  */
  1220. if (addr.s_addr == INADDR_ANY) {
  1221. imo->imo_multicast_ifp = NULL;
  1222. break;
  1223. }
  1224. /*
  1225.  * The selected interface is identified by its local
  1226.  * IP address.  Find the interface and confirm that
  1227.  * it supports multicasting.
  1228.  */
  1229. INADDR_TO_IFP(addr, ifp);
  1230. if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
  1231. error = EADDRNOTAVAIL;
  1232. break;
  1233. }
  1234. imo->imo_multicast_ifp = ifp;
  1235. break;
  1237. case IP_MULTICAST_TTL:
  1238. /*
  1239.  * Set the IP time-to-live for outgoing multicast packets.
  1240.  */
  1241. if (m == NULL || m->m_len != 1) {
  1242. error = EINVAL;
  1243. break;
  1244. }
  1245. imo->imo_multicast_ttl = *(mtod(m, u_char *));
  1246. break;
  1248. case IP_MULTICAST_LOOP:
  1249. /*
  1250.  * Set the loopback flag for outgoing multicast packets.
  1251.  * Must be zero or one.
  1252.  */
  1253. if (m == NULL || m->m_len != 1 ||
  1254.    (loop = *(mtod(m, u_char *))) > 1) {
  1255. error = EINVAL;
  1256. break;
  1257. }
  1258. imo->imo_multicast_loop = loop;
  1259. break;
  1261. case IP_ADD_MEMBERSHIP:
  1262. /*
  1263.  * Add a multicast group membership.
  1264.  * Group must be a valid IP multicast address.
  1265.  */
  1266. if (m == NULL || m->m_len != sizeof(struct ip_mreq)) {
  1267. error = EINVAL;
  1268. break;
  1269. }
  1270. mreq = mtod(m, struct ip_mreq *);
  1271. if (!IN_MULTICAST(ntohl(mreq->imr_multiaddr.s_addr))) {
  1272. error = EINVAL;
  1273. break;
  1274. }
  1275. /*
  1276.  * If no interface address was provided, use the interface of
  1277.  * the route to the given multicast address.
  1278.  */
  1279. if (mreq->imr_interface.s_addr == INADDR_ANY) {
  1280. ro.ro_rt = NULL;
  1281. dst = (struct sockaddr_in *)&ro.ro_dst;
  1282. dst->sin_len = sizeof(*dst);
  1283. dst->sin_family = AF_INET;
  1284. dst->sin_addr = mreq->imr_multiaddr;
  1285. rtalloc(&ro);
  1286. if (ro.ro_rt == NULL) {
  1287. error = EADDRNOTAVAIL;
  1288. break;
  1289. }
  1290. ifp = ro.ro_rt->rt_ifp;
  1291. rtfree(ro.ro_rt);
  1292. }
  1293. else {
  1294. INADDR_TO_IFP(mreq->imr_interface, ifp);
  1295. }
  1296. /*
  1297.  * See if we found an interface, and confirm that it
  1298.  * supports multicast.
  1299.  */
  1300. if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
  1301. error = EADDRNOTAVAIL;
  1302. break;
  1303. }
  1305.                 ppMblk = &imo->pInmMblk;
  1306.                 while (*ppMblk)
  1307.                     {
  1308.                     pInMulti = mtod (*ppMblk, struct in_multi*);
  1309.                     if ((pInMulti->inm_ifp == ifp) &&
  1310.                         (pInMulti->inm_addr.s_addr ==
  1311.                          mreq->imr_multiaddr.s_addr))
  1312.                         break; /* jump out of the while loop */
  1314.                     ppMblk = &(*ppMblk)->mBlkHdr.mNext;
  1315.                     }
  1317.                 if (*ppMblk == NULL)
  1318.                     {
  1319.                     if ((pInmMblk = in_addmulti (&mreq->imr_multiaddr,
  1320.                                                  ifp, pInPcb)) == NULL)
  1321.                         {
  1322. error = ENOBUFS;
  1323.                         break;
  1324.                         }
  1325.                     *ppMblk = pInmMblk; /* add to the list */
  1326.                     ++imo->imo_num_memberships;
  1327.                     }
  1328.                 else
  1329.                     error = EADDRINUSE;
  1331.                 break;
  1333. case IP_DROP_MEMBERSHIP:
  1334. /*
  1335.  * Drop a multicast group membership.
  1336.  * Group must be a valid IP multicast address.
  1337.  */
  1338. if (m == NULL || m->m_len != sizeof(struct ip_mreq)) {
  1339. error = EINVAL;
  1340. break;
  1341. }
  1342. mreq = mtod(m, struct ip_mreq *);
  1343. if (!IN_MULTICAST(ntohl(mreq->imr_multiaddr.s_addr))) {
  1344. error = EINVAL;
  1345. break;
  1346. }
  1347. /*
  1348.  * If an interface address was specified, get a pointer
  1349.  * to its ifnet structure.
  1350.  */
  1351. if (mreq->imr_interface.s_addr == INADDR_ANY)
  1352. ifp = NULL;
  1353. else {
  1354. INADDR_TO_IFP(mreq->imr_interface, ifp);
  1355. if (ifp == NULL) {
  1356. error = EADDRNOTAVAIL;
  1357. break;
  1358. }
  1359. }
  1361.                 {
  1362.                 ppMblk = &imo->pInmMblk;
  1363.                 while (*ppMblk)
  1364.                     {
  1365.                     pInMulti = mtod (*ppMblk, struct in_multi*);
  1367.                     if ((ifp == NULL || pInMulti->inm_ifp == ifp) &&
  1368.                         (pInMulti->inm_addr.s_addr ==
  1369.                          mreq->imr_multiaddr.s_addr))
  1370.                         {
  1371.                         pInmMblk = *ppMblk;
  1372.                         /* delete from the list */
  1373.                         *ppMblk = (*ppMblk)->mBlkHdr.mNext; 
  1374.                         break; /* jump out of the while loop */
  1375.                         }
  1376.                     ppMblk = &(*ppMblk)->mBlkHdr.mNext;
  1377.                     }
  1379.                 if (pInmMblk == NULL)
  1380.                     {
  1381.                     error = EADDRNOTAVAIL;
  1382.                     break;
  1383.                     }
  1384.                 
  1385. /*
  1386.  * Give up the multicast address record to which the
  1387.  * membership points.
  1388.  */
  1389. in_delmulti (pInmMblk, pInPcb);
  1391. --imo->imo_num_memberships;
  1392.                 
  1393. break;
  1394.                 }
  1396. default:
  1397. error = EOPNOTSUPP;
  1398. break;
  1399. }
  1401. /*
  1402.  * If all options have default values, no need to keep the mbuf.
  1403.  */
  1404. if (imo->imo_multicast_ifp == NULL &&
  1405.     imo->imo_multicast_ttl == IP_DEFAULT_MULTICAST_TTL &&
  1406.     imo->imo_multicast_loop == IP_DEFAULT_MULTICAST_LOOP &&
  1407.     imo->imo_num_memberships == 0) {
  1408.  FREE(*imop, MT_IPMOPTS);
  1409. *imop = NULL;
  1410. }
  1412. return (error);
  1413. }
  1415. /*
  1416.  * Return the IP multicast options in response to user getsockopt().
  1417.  */
  1418. int
  1419. ip_getmoptions(optname, imo, mp)
  1420. int optname;
  1421. register struct ip_moptions *imo;
  1422. register struct mbuf **mp;
  1423. {
  1424. u_char *ttl;
  1425. u_char *loop;
  1426. struct in_addr *addr;
  1427. struct in_ifaddr *ia;
  1429. *mp = mBufClGet(M_WAIT, MT_SOOPTS, CL_SIZE_128, TRUE);
  1431. if (*mp == NULL)
  1432.     return (ENOBUFS);
  1433.     
  1434. switch (optname) {
  1436. case IP_MULTICAST_IF:
  1437. addr = mtod(*mp, struct in_addr *);
  1438. (*mp)->m_len = sizeof(struct in_addr);
  1439. if (imo == NULL || imo->imo_multicast_ifp == NULL)
  1440. addr->s_addr = INADDR_ANY;
  1441. else {
  1442. IFP_TO_IA(imo->imo_multicast_ifp, ia);
  1443. addr->s_addr = (ia == NULL) ? INADDR_ANY
  1444. : IA_SIN(ia)->sin_addr.s_addr;
  1445. }
  1446. return (0);
  1448. case IP_MULTICAST_TTL:
  1449. ttl = mtod(*mp, u_char *);
  1450. (*mp)->m_len = 1;
  1451. *ttl = (imo == NULL) ? IP_DEFAULT_MULTICAST_TTL
  1452.      : imo->imo_multicast_ttl;
  1453. return (0);
  1455. case IP_MULTICAST_LOOP:
  1456. loop = mtod(*mp, u_char *);
  1457. (*mp)->m_len = 1;
  1458. *loop = (imo == NULL) ? IP_DEFAULT_MULTICAST_LOOP
  1459.       : imo->imo_multicast_loop;
  1460. return (0);
  1462. default:
  1463. return (EOPNOTSUPP);
  1464. }
  1465. }
  1467. /*
  1468.  * Discard the IP multicast options.
  1469.  */
  1470. void
  1471. ip_freemoptions(imo, pInPcb)
  1472. register struct ip_moptions *imo;
  1473. struct inpcb *  pInPcb;
  1474.         
  1475. {
  1476.         M_BLK_ID pInmMblk;
  1477.         M_BLK_ID pInmMblkNext;
  1479. if (imo != NULL) {
  1480.                 pInmMblk = imo->pInmMblk;
  1481.                 pInmMblkNext = imo->pInmMblk;
  1482.          while ((pInmMblk = pInmMblkNext) != NULL)
  1483.                     {
  1484.                     pInmMblkNext = pInmMblk->mBlkHdr.mNext; 
  1485.                     in_delmulti (pInmMblk, pInPcb);
  1486.                     }
  1487. FREE(imo, MT_IPMOPTS);
  1488. }
  1489. }
  1491. /*
  1492.  * Routine called from ip_output() to loop back a copy of an IP multicast
  1493.  * packet to the input queue of a specified interface.  Note that this
  1494.  * calls the output routine of the loopback "driver", but with an interface
  1495.  * pointer that might NOT be &loif -- easier than replicating that code here.
  1496.  */
  1497. void
  1498. ip_mloopback(ifp, m, dst, rt)
  1499. struct ifnet *ifp;
  1500. register struct mbuf *m;
  1501. register struct sockaddr_in *dst;
  1502. struct rtentry *rt;
  1503. {
  1504. register struct ip *ip;
  1505. struct mbuf *copym;
  1506.         struct mbuf * pMbuf;
  1508. #ifdef WV_INSTRUMENTATION
  1509. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  1510.     WV_NET_EVENT_0 (NET_AUX_EVENT, WV_NET_INFO, 12, 7,
  1511.                     WV_NETEVENT_IPMLOOP_START, WV_NET_RECV)
  1512. #endif  /* INCLUDE_WVNET */
  1513. #endif
  1515. copym = m_copy(m, 0, M_COPYALL);
  1516. if (copym != NULL) {
  1517. /*
  1518.  * We don't bother to fragment if the IP length is greater
  1519.  * than the interface's MTU.  Can this possibly matter?
  1520.  */
  1521. ip = mtod(copym, struct ip *);
  1523.                 /*
  1524.                  * This copying of ip header is done because the same
  1525.                  * ip header is shared by looutput and the code under the
  1526.                  * the label sendit: in ip_output. so a fresh mbuf has to be
  1527.                  * linked to the data.
  1528.                  */
  1529.                 if ((pMbuf = mBufClGet (M_DONTWAIT, MT_DATA, sizeof(struct ip),
  1530.                                    TRUE)) == NULL)
  1531.                     {
  1532.                     m_freem (copym); 
  1533.                     return;
  1534.                     }
  1536.                 /* copy the ip header */
  1537.                 bcopy ((char *)ip , (char *)(mtod(pMbuf, char *)),
  1538.                        sizeof(struct ip));
  1540.                 pMbuf->m_len   = sizeof (struct ip); 
  1541.                 pMbuf->m_flags = copym->m_flags; /* copy the flags */
  1542.                 pMbuf->m_pkthdr = copym->m_pkthdr; /* copy the pkt hdr */
  1543.                 pMbuf->m_next = copym;
  1544.                 
  1545.                 copym->m_flags &= ~M_PKTHDR;
  1546.                 copym->m_len -= sizeof(struct ip);
  1547.                 copym->m_data += sizeof(struct ip);
  1548. ip = mtod(pMbuf, struct ip *);
  1549.                 copym = pMbuf; 
  1551. ip->ip_len = htons((u_short)ip->ip_len);
  1552. ip->ip_off = htons((u_short)ip->ip_off);
  1554.                 ip->ip_sum = 0;
  1555.                 if (_ipCfgFlags & IP_DO_CHECKSUM_SND)
  1556.                     ip->ip_sum = in_cksum(copym, ip->ip_hl << 2);
  1558. (void) looutput(ifp, copym, (struct sockaddr *)dst, rt);
  1559. }
  1560. }