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

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

VxWorks

开发平台：

C/C++

ip_input.c：源码内容
  1. /* ip_input.c - internet input routines */
  3. /* Copyright 1984 - 2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1982, 1986, 1988, 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_input.c 8.2 (Berkeley) 1/4/94
  39.  */
  41. /*
  42. modification history
  43. --------------------
  44. 01y,15apr02,wap  reinstate netJobAdd removal changes
  45. 01x,29mar02,wap  back out the previous change (needs more investigation)
  46. 01w,21mar02,rae  ipintr called directly (SPR #74604)
  47. 01v,03jan02,vvv  fixed reassembly problem for large packets with reordered
  48.  fragments (SPR #71746)
  49. 01u,12oct01,rae  merge from truestack ver 02f, base 01r (SPRs 69722,
  50.                  69112, 27706, etc)
  51. 01t,07dec00,rae  added IPsec input hook
  52. 01s,27sep00,rae  fixed ping of death bug
  53. 01r,08nov99,pul  merging T2 cumulative patch 2
  54. 01q,04jun99,spm  corrected ip_forward() routine to handle source routing
  55.                  options for hosts (SPR #27727)
  56. 01p,28feb99,ham  corrected comment below - (wrong)34040 -> (right)32767.
  57. 01o,28feb99,ham  fixed reassembly problem larger ip_off 34040, spr#23250.
  58. 01n,09jan98,vin  changed IP_CKSUM_RECV_MASK to IP_DO_CHECKSUM_RCV
  59. 01m,13nov97,vin  added HTONS(ip->ip_len) in ip_forward before icmp_error,
  60.  consolidated all flags into ipCfgFlags.
  61. 01l,28oct97,vin  reverted on the fix in version01j, what was vin thinking.
  62. 01k,15jul97,spm  made IP checksum calculation configurable (SPR #7836)
  63. 01j,05jun97,vin  fixed problem in ip_forward().HTONS(ip_len).
  64. 01i,17apr97,vin  added more functionality to the ipFilterHook.
  65. 01h,08mar97,vin  added mCastRouteFwdHook to access mcast routing code.
  66. 01g,11apr97,rjc  added ipFilter Hook and strongEnded flag processing.
  67. 01f,04mar97,vin  added fix to null domain pointer in ip_init SPR 8078.
  68. 01e,05feb97,rjc  tos routing changes
  69. 01d,31jan97,vin  changed declaration according to prototype decl in protosw.h
  70. 01c,07jan96,vin  moved iptime() from ip_icmp, added _icmpErrorHook instead
  71.  of icmp_error() for scalability, added ipfragttl. 
  72. 01b,30oct96,vin  re-worked ipreassembly, made it free from dtom macros.
  73.  added ipReAssembly, replace m_get(..) with mBufClGet(..)
  74. 01a,03mar96,vin  created from BSD4.4 stuff,integrated with 02r of ip_input.c
  75. */
  77. #include "vxWorks.h"
  78. #include "tickLib.h"
  79. #include "netLib.h"
  80. #include "net/systm.h"
  81. #include "net/mbuf.h"
  82. #include "net/domain.h"
  83. #include "net/protosw.h"
  84. #include "sys/socket.h"
  85. #include "errno.h"
  87. #include "net/if.h"
  88. #include "net/route.h"
  90. #include "netinet/in.h"
  91. #include "netinet/in_pcb.h"
  92. #include "netinet/in_systm.h"
  93. #include "netinet/in_var.h"
  94. #include "netinet/ip.h"
  95. #include "netinet/ip_var.h"
  96. #include "netinet/ip_icmp.h"
  98. #ifdef WV_INSTRUMENTATION
  99. #ifdef INCLUDE_WVNET
  100. #include "wvNetLib.h"
  101. #endif
  102. #endif
  104. #ifdef VIRTUAL_STACK
  105. #include "netinet/vsLib.h"
  106. #include "netinet/vsMcast.h"
  107. #endif /* VIRTUAL_STACK */
  109. extern void _insque();
  110. extern void _remque();
  111. extern int sysClkRateGet();
  112. extern int routeDrain();
  114. #ifndef VIRTUAL_STACK
  115. extern VOIDFUNCPTR _icmpErrorHook;
  116. extern FUNCPTR _mCastRouteFwdHook; /* WRS mcast forward command hook */
  117. #endif /* VIRTUAL_STACK */
  119. extern FUNCPTR _ipFilterHook;           /* ipFilter hook defined in netLib.c */
  121. /*IPsec input hook defined in /target/src/wrn/ipsec/ipsec_io.c */
  122. typedef int     (*IPSEC_INPUT_FUNCPTR)  (struct mbuf** m, int hlen, struct ip** ip);
  123. IPSEC_INPUT_FUNCPTR             _func_ipsecInput;
  126. /*IPsec filter hook is defined in /target/src/wrn/ipsec/ipsec_io.c */ 
  128. typedef int    (*IPSEC_FILTER_HOOK_FUNCPTR) (struct mbuf** m, struct ip** ip, int hlen);
  130. IPSEC_FILTER_HOOK_FUNCPTR       _func_ipsecFilterHook; 
  132. /* globals */
  134. #ifndef IPFORWARDING
  135. #ifdef GATEWAY
  136. #define IPFORWARDING 1 /* forward IP packets not for us */
  137. #else /* GATEWAY */
  138. #define IPFORWARDING 0 /* don't forward IP packets not for us */
  139. #endif /* GATEWAY */
  140. #endif /* IPFORWARDING */
  141. #ifndef IPSENDREDIRECTS
  142. #define IPSENDREDIRECTS 1
  143. #endif
  145. #define FORWARD_BROADCASTS
  147. #ifdef FORWARD_BROADCASTS
  148. #define DIRECTED_BROADCAST
  149. FUNCPTR proxyBroadcastHook = NULL;
  150. #endif
  152. #ifndef VIRTUAL_STACK
  153. int _ipCfgFlags; /* ip configurations, bit field flag */
  154. int ip_defttl = IPDEFTTL; /* default IP ttl */
  155. int ipfragttl = IPFRAGTTL; /* default IP fragment timeout */
  156. #ifdef DIAGNOSTIC
  157. int ipprintfs = 0;
  158. #endif
  159. int     ipStrongEnded = FALSE;             /* default ip ended'ness */
  161. extern struct domain inetdomain;
  162. extern struct protosw inetsw[];
  164. u_char ip_protox[IPPROTO_MAX];
  166. int ipqmaxlen = IFQ_MAXLEN;
  167. struct in_ifaddr *in_ifaddr; /* first inet address */
  168. struct ipstat ipstat;
  169. struct ipq ipq; /* ip reass. queue */
  170. u_short ip_id; /* ip packet ctr, for ids */
  172. int ip_nhops = 0;
  173. #endif /* VIRTUAL_STACK */
  175. #ifdef WV_INSTRUMENTATION
  176. #ifdef INCLUDE_WVNET
  177.     /* Set common fields of event identifiers for this module. */
  179. LOCAL UCHAR wvNetModuleId = WV_NET_IPINPUT_MODULE;   /* Value for ip_input.c */
  180. LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */
  182. LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */
  183. #endif    /* INCLUDE_WVNET */
  184. #endif
  186. struct ifqueue ipintrq;
  188. /* forward declarations */
  190. #ifdef SRCRT
  191. static void save_rte (u_char *, struct in_addr);
  192. #endif /* SRCRT */
  193. LOCAL struct mbuf * ipReAssemble (FAST struct mbuf * pMbuf, 
  194.   FAST struct ipq *  pIpFragQueue); 
  195. #ifdef SYSCTL_SUPPORT
  196. /* ipforwarding set to on or off depending upon compile time flag */
  197. int ipforwarding = IPFORWARDING;
  198. #endif /* SYSCTL_SUPPORT */
  200. struct rtentry *rtalloc2 (struct sockaddr *);
  202. /*
  203.  * IP initialization: fill in IP protocol switch table.
  204.  * All protocols not implemented in kernel go to raw IP protocol handler.
  205.  */
  206. void
  207. ip_init()
  208. {
  209. register struct protosw *pr;
  210. register int i;
  212. #ifdef WV_INSTRUMENTATION
  213. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  214.     WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_VERBOSE, 27, 20,
  215.                      WV_NETEVENT_IPINIT_START)
  216. #endif  /* INCLUDE_WVNET */
  217. #endif
  219. #ifdef VIRTUAL_STACK
  220.         ip_defttl = IPDEFTTL;
  221.         ipfragttl = IPFRAGTTL;
  222. #ifdef DIAGNOSTIC
  223.         ipprintfs = 0;
  224. #endif
  225.         ipStrongEnded = FALSE;
  226.         ipqmaxlen = IFQ_MAXLEN;
  227.         ip_nhops = 0;
  228.         input_ipaddr.sin_len = sizeof (struct sockaddr_in);
  229.         input_ipaddr.sin_family = AF_INET;
  230. #endif /* VIRTUAL_STACK */
  232. pr = pffindproto(PF_INET, IPPROTO_RAW, SOCK_RAW);
  233. if (pr == 0)
  234.             {
  235. #ifdef WV_INSTRUMENTATION
  236. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  237.             WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_EMERGENCY, 15, 1,
  238.                              WV_NETEVENT_IPINIT_PANIC)
  239. #endif  /* INCLUDE_WVNET */
  240. #endif
  242.             panic("ip_init");
  243.             }
  244. for (i = 0; i < IPPROTO_MAX; i++)
  245. ip_protox[i] = pr - inetsw;
  246. for (pr = inetdomain.dom_protosw;
  247.     pr < inetdomain.dom_protoswNPROTOSW; pr++)
  248.                 if ((pr->pr_domain != NULL) &&
  249.                     pr->pr_domain->dom_family == PF_INET &&
  250.                     pr->pr_protocol && pr->pr_protocol != IPPROTO_RAW)
  251.                     ip_protox[pr->pr_protocol] = pr - inetsw;
  252. #ifdef VIRTUAL_STACK
  253. _ipq.next = _ipq.prev = &_ipq;
  254. _ip_id = iptime() & 0xffff;
  255. #else
  256. ipq.next = ipq.prev = &ipq;
  257. ip_id = iptime() & 0xffff;
  258. #endif
  259. ipintrq.ifq_maxlen = ipqmaxlen;
  260. return;
  261. }
  263. #ifndef VIRTUAL_STACK
  264. struct sockaddr_in input_ipaddr = { sizeof(input_ipaddr), AF_INET };
  265. struct route ipforward_rt;
  266. #endif /* VIRTUAL_STACK */
  268. /*
  269.  * Job entry point for net task.
  270.  * Ip input routine.  Checksum and byte swap header.  If fragmented
  271.  * try to reassemble.  Process options.  Pass to next level.
  272.  */
  274. void
  275. ipintr(struct mbuf *m)
  276. {
  277. struct ip *ip;
  278. register struct ipq *fp;
  279. register struct in_ifaddr *ia;
  280. int hlen, s;
  282.         if (m==0)
  283.             return;
  284.         s = splnet();
  286. #ifdef DIAGNOSTIC
  287. if ((m->m_flags & M_PKTHDR) == 0)
  288.             {
  289. #ifdef WV_INSTRUMENTATION
  290. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  291.             WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_EMERGENCY, 16, 2, 
  292.                             WV_NETEVENT_IPIN_PANIC, WV_NET_RECV)
  293. #endif  /* INCLUDE_WVNET */
  294. #endif
  296.             panic("ipintr no HDR");
  297.             }
  298. #endif
  300. /*
  301.  * If no IP addresses have been set yet but the interfaces
  302.  * are receiving, can't do anything with incoming packets yet.
  303.  */
  304. #ifdef VIRTUAL_STACK
  305. if (_in_ifaddr == NULL)
  306. #else
  307. if (in_ifaddr == NULL)
  308. #endif /* VIRTUAL_STACK */
  309. goto bad;
  310. #ifdef VIRTUAL_STACK
  311. _ipstat.ips_total++;
  312. #else
  313. ipstat.ips_total++;
  314. #endif /* VIRTUAL_STACK */
  315. if (m->m_len < sizeof (struct ip) &&
  316.     (m = m_pullup(m, sizeof (struct ip))) == 0) {
  317. #ifdef WV_INSTRUMENTATION
  318. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  319.                 WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_CRITICAL, 12, 3, 
  320.                                 WV_NETEVENT_IPIN_SHORTMSG, WV_NET_RECV)
  321. #endif  /* INCLUDE_WVNET */
  322. #endif
  324. #ifdef VIRTUAL_STACK
  325. _ipstat.ips_toosmall++;
  326. #else
  327. ipstat.ips_toosmall++;
  328. #endif /* VIRTUAL_STACK */
  329. goto done;
  330. }
  331. ip = mtod(m, struct ip *);
  332. if (ip->ip_v != IPVERSION) {
  333. #ifdef WV_INSTRUMENTATION
  334. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  335.         WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 13, 4, 
  336.                         WV_NETEVENT_IPIN_BADVERS, WV_NET_RECV, ip->ip_v)
  337. #endif  /* INCLUDE_WVNET */
  338. #endif
  340. #ifdef VIRTUAL_STACK
  341. _ipstat.ips_badvers++;
  342. #else
  343. ipstat.ips_badvers++;
  344. #endif /* VIRTUAL_STACK */
  345. goto bad;
  346. }
  347. hlen = ip->ip_hl << 2;
  348. if (hlen < sizeof(struct ip)) { /* minimum header length */
  349. #ifdef WV_INSTRUMENTATION
  350. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  351.         WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 14, 5, 
  352.                         WV_NETEVENT_IPIN_BADHLEN, WV_NET_RECV, hlen)
  353. #endif  /* INCLUDE_WVNET */
  354. #endif
  356. #ifdef VIRTUAL_STACK
  357. _ipstat.ips_badhlen++;
  358. #else
  359. ipstat.ips_badhlen++;
  360. #endif /* VIRTUAL_STACK */
  361. goto bad;
  362. }
  363. if (hlen > m->m_len) {
  364. if ((m = m_pullup(m, hlen)) == 0) {
  366. #ifdef WV_INSTRUMENTATION
  367. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  368.             WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 14, 5, 
  369.                             WV_NETEVENT_IPIN_BADHLEN, WV_NET_RECV, hlen)
  370. #endif  /* INCLUDE_WVNET */
  371. #endif
  373. #ifdef VIRTUAL_STACK
  374. _ipstat.ips_badhlen++;
  375. #else
  376. ipstat.ips_badhlen++;
  377. #endif /* VIRTUAL_STACK */
  378. goto done;
  379. }
  380. ip = mtod(m, struct ip *);
  381. }
  383.         if (_ipCfgFlags & IP_DO_CHECKSUM_RCV)
  384.             {
  385.     if ( (ip->ip_sum = in_cksum(m, hlen)) != 0) 
  386.                 {
  387. #ifdef WV_INSTRUMENTATION
  388. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  389.                 WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_CRITICAL, 15, 6, 
  390.                                 WV_NETEVENT_IPIN_BADSUM, WV_NET_RECV)
  391. #endif  /* INCLUDE_WVNET */
  392. #endif
  394. #ifdef VIRTUAL_STACK
  395. _ipstat.ips_badsum++;
  396. #else
  397. ipstat.ips_badsum++;
  398. #endif /* VIRTUAL_STACK */
  399. goto bad;
  400.         }
  401.             }
  403. /*
  404.  * Convert fields to host representation.
  405.  */
  406. NTOHS(ip->ip_len);
  407. if (ip->ip_len < hlen) {
  408. #ifdef WV_INSTRUMENTATION
  409. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  410.         WV_NET_ADDRIN_EVENT_2 (NET_CORE_EVENT, WV_NET_CRITICAL, 16, 7, 
  411.                                ip->ip_src.s_addr, ip->ip_dst.s_addr,
  412.                                WV_NETEVENT_IPIN_BADLEN, WV_NET_RECV,
  413.                                ip->ip_len, hlen)
  414. #endif  /* INCLUDE_WVNET */
  415. #endif
  417. #ifdef VIRTUAL_STACK
  418. _ipstat.ips_badlen++;
  419. #else
  420. ipstat.ips_badlen++;
  421. #endif /* VIRTUAL_STACK */
  422. goto bad;
  423. }
  424. NTOHS(ip->ip_id);
  425. NTOHS(ip->ip_off);
  427. /*
  428.  * Check that the amount of data in the buffers
  429.  * is as at least much as the IP header would have us expect.
  430.  * Trim mbufs if longer than we expect.
  431.  * Drop packet if shorter than we expect.
  432.  */
  433. if (m->m_pkthdr.len < ip->ip_len) {
  434. #ifdef WV_INSTRUMENTATION
  435. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  436.         WV_NET_ADDRIN_EVENT_2 (NET_CORE_EVENT, WV_NET_CRITICAL, 17, 8,
  437.                                ip->ip_src.s_addr, ip->ip_dst.s_addr,
  438.                                WV_NETEVENT_IPIN_BADMBLK, WV_NET_RECV,
  439.                                m->m_pkthdr.len, ip->ip_len)
  440. #endif  /* INCLUDE_WVNET */
  441. #endif
  443. #ifdef VIRTUAL_STACK
  444. _ipstat.ips_tooshort++;
  445. #else
  446. ipstat.ips_tooshort++;
  447. #endif /* VIRTUAL_STACK */
  448. goto bad;
  449. }
  450. if (m->m_pkthdr.len > ip->ip_len) {
  451. if (m->m_len == m->m_pkthdr.len) {
  452. m->m_len = ip->ip_len;
  453. m->m_pkthdr.len = ip->ip_len;
  454. } else
  455. m_adj(m, ip->ip_len - m->m_pkthdr.len);
  456. }
  457.    /* IPsec filter Hook */
  458.    if (_func_ipsecFilterHook != NULL)
  459.       {
  460.       if (_func_ipsecFilterHook (&m, &ip, hlen) == ERROR)
  461.          {
  462.          goto done; /* IPsec filter hook has already freed the mbuf */
  463.          }
  464.       }
  466. /* ipFilterHook example fireWall Hook processing */
  468.    if (_ipFilterHook != NULL)
  469.      {
  470.     /* process the packet if the hook returns other than TRUE */
  472.      if ((*_ipFilterHook) (m->m_pkthdr.rcvif, &m, &ip, hlen) == TRUE)
  473.         goto done; /* the hook should free the mbuf */
  474.      }
  476. /*
  477.  * Process options and, if not destined for us,
  478.  * ship it on.  ip_dooptions returns 1 when an
  479.  * error was detected (causing an icmp message
  480.  * to be sent and the original packet to be freed).
  481.  */
  482. ip_nhops = 0; /* for source routed packets */
  483. if (hlen > sizeof (struct ip) && ip_dooptions(m))
  484. goto done;
  486. /*
  487.  * Check our list of addresses, to see if the packet is for us.
  488.  */
  489. #ifdef VIRTUAL_STACK
  490. for (ia = _in_ifaddr; ia; ia = ia->ia_next) {
  491. #else
  492. for (ia = in_ifaddr; ia; ia = ia->ia_next) {
  493. #endif /* VIRTUAL_STACK */
  494. #define satosin(sa) ((struct sockaddr_in *)(sa))
  495. /* if ip is strong ended we will accept packets on  an interface
  496.  * only if destination in ip hdr matches ip  address on the
  497.  * receiving interface and not just any interface. 
  498.  */
  499.                 if ((ipStrongEnded == TRUE) && 
  500.     (ia->ia_ifp != m->m_pkthdr.rcvif))
  501.     continue;
  503. if (IA_SIN(ia)->sin_addr.s_addr == ip->ip_dst.s_addr)
  504. goto ours;
  505. if (
  506. #ifdef DIRECTED_BROADCAST
  507.     ia->ia_ifp == m->m_pkthdr.rcvif &&
  508. #endif
  509.     (ia->ia_ifp->if_flags & IFF_BROADCAST)) {
  510. u_long t;
  512. if (satosin(&ia->ia_broadaddr)->sin_addr.s_addr ==
  513.     ip->ip_dst.s_addr)
  514. goto ours;
  515. if (ip->ip_dst.s_addr == ia->ia_netbroadcast.s_addr)
  516. goto ours;
  517. /*
  518.  * Look for all-0's host part (old broadcast addr),
  519.  * either for subnet or net.
  520.  */
  521. t = ntohl(ip->ip_dst.s_addr);
  522. if (t == ia->ia_subnet)
  523. goto ours;
  524. if (t == ia->ia_net)
  525. goto ours;
  526. }
  527. }
  528. if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr))) {
  529. struct in_multi *inm;
  530. if (_mCastRouteFwdHook != NULL) {
  531. /*
  532.  * If we are acting as a multicast router, all
  533.  * incoming multicast packets are passed to the
  534.  * kernel-level multicast forwarding function.
  535.  * The packet is returned (relatively) intact; if
  536.  * ip_mforward() returns a non-zero value, the packet
  537.  * must be discarded, else it may be accepted below.
  538.  *
  539.  * (The IP ident field is put in the same byte order
  540.  * as expected when ip_mforward() is called from
  541.  * ip_output().)
  542.  */
  543. ip->ip_id = htons(ip->ip_id);
  544.                         if ((*_mCastRouteFwdHook)(m, m->m_pkthdr.rcvif, ip, NULL) != 0) {
  545. #ifdef VIRTUAL_STACK
  546. _ipstat.ips_cantforward++;
  547. #else
  548. ipstat.ips_cantforward++;
  549. #endif /* VIRTUAL_STACK */
  550. m_freem(m);
  551. goto done;
  552. }
  553. ip->ip_id = ntohs(ip->ip_id);
  555. /*
  556.  * The process-level routing demon needs to receive
  557.  * all multicast IGMP packets, whether or not this
  558.  * host belongs to their destination groups.
  559.  */
  560. if (ip->ip_p == IPPROTO_IGMP)
  561. goto ours;
  562. #ifdef VIRTUAL_STACK
  563. _ipstat.ips_forward++;
  564. #else
  565. ipstat.ips_forward++;
  566. #endif /* VIRTUAL_STACK */
  567. }
  568. /*
  569.  * See if we belong to the destination multicast group on the
  570.  * arrival interface.
  571.  */
  572. IN_LOOKUP_MULTI(ip->ip_dst, m->m_pkthdr.rcvif, inm);
  573. if (inm == NULL) {
  574. #ifdef VIRTUAL_STACK
  575. _ipstat.ips_cantforward++;
  576. #else
  577. ipstat.ips_cantforward++;
  578. #endif /* VIRTUAL_STACK */
  579. m_freem(m);
  580. goto done;
  581. }
  582. goto ours;
  583. }
  584. if (ip->ip_dst.s_addr == (u_long)INADDR_BROADCAST)
  585. goto ours;
  586. if (ip->ip_dst.s_addr == INADDR_ANY)
  587. goto ours;
  589. /*
  590.  * Not for us; forward if possible and desirable.
  591.  */
  592. if ((_ipCfgFlags & IP_DO_FORWARDING) == 0) {
  593. #ifdef VIRTUAL_STACK
  594. _ipstat.ips_cantforward++;
  595. #else
  596. ipstat.ips_cantforward++;
  597. #endif /* VIRTUAL_STACK */
  598. m_freem(m);
  599. } else
  600. ip_forward(m, 0);
  601. goto done;
  603. ours:
  604. #ifdef WV_INSTRUMENTATION
  605. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  606.     WV_NET_ADDRIN_EVENT_2 (NET_CORE_EVENT, WV_NET_INFO, 6, 16,
  607.                            ip->ip_src.s_addr, ip->ip_dst.s_addr,
  608.                            WV_NETEVENT_IPIN_GOODMBLK, WV_NET_RECV,
  609.                            ip->ip_src.s_addr, ip->ip_dst.s_addr)
  610. #endif  /* INCLUDE_WVNET */
  611. #endif
  613. /*
  614.  * If offset or IP_MF are set, must reassemble.
  615.  * Otherwise, nothing need be done.
  616.  * (We could look in the reassembly queue to see
  617.  * if the packet was previously fragmented,
  618.  * but it's not worth the time; just let them time out.)
  619.  */
  620. if (ip->ip_off &~ IP_DF) {
  621. /*
  622.  * Look for queue of fragments
  623.  * of this datagram.
  624.  */
  625. #ifdef VIRTUAL_STACK
  626. for (fp = _ipq.next; fp != &_ipq; fp = fp->next)
  627. #else
  628. for (fp = ipq.next; fp != &ipq; fp = fp->next)
  629. #endif
  630. if (ip->ip_id == fp->ipq_id &&
  631.     ip->ip_src.s_addr == fp->ipq_src.s_addr &&
  632.     ip->ip_dst.s_addr == fp->ipq_dst.s_addr &&
  633.     ip->ip_p == fp->ipq_p)
  634. goto found;
  635. fp = 0;
  636. found:
  638. /*
  639.  * Adjust ip_len to not reflect header,
  640.  * set ip_mff if more fragments are expected,
  641.  * convert offset of this to bytes.
  642.  */
  643. ip->ip_len -= hlen;
  644. ((struct ipasfrag *)ip)->ipf_mff &= ~1;
  645. if (ip->ip_off & IP_MF)
  646. ((struct ipasfrag *)ip)->ipf_mff |= 1;
  647. ip->ip_off <<= 3;
  649. /*
  650.  * If datagram marked as having more fragments
  651.  * or if this is not the first fragment,
  652.  * attempt reassembly; if it succeeds, proceed.
  653.  */
  654. if (((struct ipasfrag *)ip)->ipf_mff & 1 || ip->ip_off) {
  655. #ifdef VIRTUAL_STACK
  656. _ipstat.ips_fragments++;
  657. #else
  658. ipstat.ips_fragments++;
  659. #endif /* VIRTUAL_STACK */
  660. if ((m = ipReAssemble (m, fp)) == NULL)
  661. goto done;
  662.                         ip = mtod (m, struct ip *);
  663. hlen = ip->ip_hl << 2;
  664. #ifdef VIRTUAL_STACK
  665. _ipstat.ips_reassembled++;
  666. #else
  667. ipstat.ips_reassembled++;
  668. #endif /* VIRTUAL_STACK */
  669. } else
  670. if (fp)
  671. ip_freef(fp);
  672. } else
  673. ip->ip_len -= hlen;
  675. #ifdef  FORWARD_BROADCASTS
  676.         if ((m->m_flags & M_BCAST) && (proxyBroadcastHook != NULL))
  677.             (* proxyBroadcastHook) (m, m->m_pkthdr.rcvif);
  678. #endif
  679.         if (_func_ipsecInput != NULL)
  680.             {
  681.             /* Deliver the packet to ipsec for further processing/filtering. */
  682.             if (_func_ipsecInput (&m, hlen, &ip) == ERROR)
  683.                 {
  684.                 goto done;
  685.                 }
  686.             }
  687. /*
  688.  * Switch out to protocol's input routine.
  689.  */
  691. #ifdef WV_INSTRUMENTATION
  692. #ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
  693.     WV_NET_ADDRIN_EVENT_2 (NET_CORE_EVENT, WV_NET_NOTICE, 10, 14,
  694.                            ip->ip_src.s_addr, ip->ip_dst.s_addr,
  695.                            WV_NETEVENT_IPIN_FINISH, WV_NET_RECV,
  696.                            ip->ip_src.s_addr, ip->ip_dst.s_addr)
  697. #endif  /* INCLUDE_WVNET */
  698. #endif
  700. #ifdef VIRTUAL_STACK
  701. _ipstat.ips_delivered++;
  702. #else
  703. ipstat.ips_delivered++;
  704. #endif /* VIRTUAL_STACK */
  705. (*inetsw[ip_protox[ip->ip_p]].pr_input) (m, hlen);
  706.         splx (s);
  707.         return;
  709. bad:
  710. m_freem(m);
  711. done:        
  712.         splx (s);
  713.         return;
  714.         }
  716. /*******************************************************************************
  717. *
  718. * ipReAssemble - reassemble ip fragments
  719. *
  720. * This function reassembles the ip fragments and returns the pointer to the
  721. * mbuf chain if reassembly is complete orelse returns null.
  722. *
  723. * RETURNS: pMbuf/NULL
  724. *
  725. * SEE ALSO: ,
  726. *
  727. * NOMANUAL
  728. */
  730. LOCAL struct mbuf * ipReAssemble
  731.     (
  732.     FAST struct mbuf * pMbuf, /* pointer to mbuf chain fragment */
  733.     FAST struct ipq * pIpFragQueue /* pointer to ip fragment queue */
  734.     )
  735.     {
  736.     FAST struct mbuf **  pPtrMbuf;     /* pointer to ptr to mbuf */
  737.     FAST struct mbuf *  pMbPktFrag = NULL; /* pointer to the packet */
  738.     FAST struct ip *  pIpHdr;       /* pointer to ip header */
  739.     FAST struct ipasfrag * pIpHdrFrag = NULL; /* ipfragment header */
  740.     FAST int         len; 
  741.     FAST struct mbuf * pMbufTmp;    /* pointer to mbuf */
  742.     
  743.     pIpHdr = mtod (pMbuf, struct ip *); 
  744.     pMbuf->m_nextpkt = NULL; 
  745.     /*
  746.      * If first fragment to arrive, create a reassembly queue.
  747.      */
  748.     if (pIpFragQueue == 0)
  749. {
  750. if ((pMbufTmp = mBufClGet (M_DONTWAIT, MT_FTABLE, sizeof(struct ipq),
  751.    TRUE)) == NULL)
  752.     goto dropFrag;
  753. pIpFragQueue = mtod(pMbufTmp, struct ipq *);
  754. #ifdef VIRTUAL_STACK
  755. insque(pIpFragQueue, &_ipq);
  756. #else
  757. insque(pIpFragQueue, &ipq);
  758. #endif
  759. pIpFragQueue->ipq_ttl = ipfragttl; /* configuration parameter */
  760. pIpFragQueue->ipq_p = pIpHdr->ip_p;
  761. pIpFragQueue->ipq_id = pIpHdr->ip_id;
  762. pIpFragQueue->ipq_src = ((struct ip *)pIpHdr)->ip_src;
  763. pIpFragQueue->ipq_dst = ((struct ip *)pIpHdr)->ip_dst;
  764. pIpFragQueue->pMbufHdr   = pMbufTmp;  /* back pointer to mbuf */
  765. pIpFragQueue->pMbufPkt = pMbuf;  /* first fragment received */
  766. goto ipChkReAssembly; 
  767. }
  769.     for (pPtrMbuf = &(pIpFragQueue->pMbufPkt); *pPtrMbuf != NULL;
  770.  pPtrMbuf = &(*pPtrMbuf)->m_nextpkt)
  771. {
  772. pMbPktFrag = *pPtrMbuf; 
  773. pIpHdrFrag = mtod(pMbPktFrag, struct ipasfrag *); 
  775. if ((USHORT)pIpHdr->ip_off > (USHORT)pIpHdrFrag->ip_off)
  776.     {
  777.     if ((len = (signed int)((USHORT)pIpHdrFrag->ip_off +
  778.     pIpHdrFrag->ip_len -
  779.     (USHORT)pIpHdr->ip_off)) > 0)
  780. {
  781. if (len >= pIpHdr->ip_len)
  782.     goto dropFrag; /* drop the fragment */
  783. pIpHdrFrag->ip_len -= len; 
  784. m_adj(pMbPktFrag, -len);  /* trim from the tail */
  785. }
  786.     if (pMbPktFrag->m_nextpkt == NULL)
  787. {  /* this is the likely case most of the time */
  788. pMbPktFrag->m_nextpkt = pMbuf;  /* insert the fragment */
  789. pMbuf->m_nextpkt = NULL;
  790. break;
  791. }
  792.     }
  793. else  /* if pIpHdr->ip_off <= pIpHdrFrag->ip_off */
  794.     {
  795.             /* if complete overlap */
  796.             while (((USHORT)pIpHdr->ip_off + pIpHdr->ip_len) >=
  797.                    ((USHORT)pIpHdrFrag->ip_off + pIpHdrFrag->ip_len))
  798.                 {
  799.                 *pPtrMbuf = (*pPtrMbuf)->m_nextpkt;
  800.                 pMbPktFrag->m_nextpkt = NULL;
  801.                 m_freem (pMbPktFrag);           /* drop the fragment */
  802.                 pMbPktFrag = *pPtrMbuf;
  803.                 if (pMbPktFrag == NULL)
  804.                     break;
  805.                 pIpHdrFrag = mtod(pMbPktFrag, struct ipasfrag *);
  806.                 }
  807.             /* if partial overlap trim my data at the end*/
  808.             if ((pMbPktFrag != NULL) &&
  809.                 ((len = (((USHORT) pIpHdr->ip_off + pIpHdr->ip_len) -
  810.                          (USHORT) pIpHdrFrag->ip_off)) > 0))
  811.                 {
  812.                 pIpHdr->ip_len -= len;
  813.                 m_adj (pMbuf, -len);         /* trim from the tail */
  814.                 }
  815.     pMbuf->m_nextpkt = pMbPktFrag; 
  816.     *pPtrMbuf = pMbuf;  /* insert the current fragment */     
  817.     break; 
  818.     }
  819. }
  821.     ipChkReAssembly:
  822.     len = 0; 
  823.     for (pMbPktFrag = pIpFragQueue->pMbufPkt; pMbPktFrag != NULL;
  824.  pMbPktFrag = pMbPktFrag->m_nextpkt)
  825. {
  826. pIpHdrFrag = mtod(pMbPktFrag, struct ipasfrag *); 
  827. if ((USHORT)pIpHdrFrag->ip_off != len)
  828.     return (NULL); 
  829. len += pIpHdrFrag->ip_len; 
  830. }    
  831.     if (pIpHdrFrag->ipf_mff & 1) /* last fragment's mff bit still set */
  832. return (NULL); 
  834.     /* reassemble and concatenate all fragments */
  835.     pMbuf = pIpFragQueue->pMbufPkt; 
  836.     pMbufTmp = pMbuf->m_nextpkt; 
  837.     pMbuf->m_nextpkt = NULL; 
  839.     while (pMbufTmp != NULL)
  840. {
  841. pMbPktFrag = pMbufTmp; 
  842. pIpHdrFrag = mtod(pMbPktFrag, struct ipasfrag *); 
  843. pMbPktFrag->m_data += pIpHdrFrag->ip_hl << 2; /* remove the header */
  844. pMbPktFrag->m_len  -= pIpHdrFrag->ip_hl << 2;
  845. pMbufTmp = pMbPktFrag->m_nextpkt; 
  846. pMbPktFrag->m_nextpkt = NULL ; 
  847. m_cat (pMbuf, pMbPktFrag);  /* concatenate the fragment */
  848. }
  850.     pIpHdrFrag = mtod(pMbuf, struct ipasfrag *); 
  851.     pIpHdrFrag->ip_len = len;  /* length of the ip packet */
  852.     if (len > 0xffff - (pIpHdrFrag->ip_hl << 2))  /* ping of death */
  853.         goto dropFrag;                            /* drop entire chain */
  854.     pIpHdrFrag->ipf_mff &= ~1;
  855.     remque(pIpFragQueue);
  856.     (void) m_free (pIpFragQueue->pMbufHdr); 
  858.     /* some debugging cruft by sklower, below, will go away soon */
  859.     if (pMbuf->m_flags & M_PKTHDR)
  860. { /* XXX this should be done elsewhere */
  861. len = 0; 
  862. for (pMbufTmp = pMbuf; pMbufTmp; pMbufTmp = pMbufTmp->m_next)
  863.     len += pMbufTmp->m_len;
  864. pMbuf->m_pkthdr.len = len;
  865. }
  867.     return (pMbuf); /* return the assembled packet */
  869.     dropFrag:
  870. #ifdef WV_INSTRUMENTATION
  871. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  872.     WV_NET_ADDRIN_EVENT_1 (NET_CORE_EVENT, WV_NET_WARNING, 8, 13,
  873.                            pIpHdr->ip_src.s_addr, pIpHdr->ip_dst.s_addr,
  874.                            WV_NETEVENT_IPIN_FRAGDROP, WV_NET_RECV, pIpHdrFrag)
  875. #endif  /* INCLUDE_WVNET */
  876. #endif
  878. #ifdef VIRTUAL_STACK
  879.     _ipstat.ips_fragdropped++;
  880. #else
  881.     ipstat.ips_fragdropped++;
  882. #endif /* VIRTUAL_STACK */
  883.     m_freem (pMbuf); /* free the fragment */
  884.     return (NULL);
  885.     }
  887. /*
  888.  * Free a fragment reassembly header and all
  889.  * associated datagrams.
  890.  */
  891. void
  892. ip_freef(fp)
  893. struct ipq *fp;
  894. {
  895. struct mbuf **  pPtrMbuf; 
  896. struct mbuf *  pMbuf;
  898. #ifdef WV_INSTRUMENTATION
  899. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  900.     WV_NET_ADDRIN_MARKER_2 (NET_AUX_EVENT, WV_NET_INFO, 7, 17,
  901.                             fp->ipq_src.s_addr, fp->ipq_dst.s_addr,
  902.                             WV_NETEVENT_IPFRAGFREE_START,
  903.                             fp->ipq_src.s_addr, fp->ipq_dst.s_addr)
  904. #endif  /* INCLUDE_WVNET */
  905. #endif
  907. /* free all fragments */
  908. pPtrMbuf = &(fp->pMbufPkt); 
  909. while (*pPtrMbuf)
  910.     {
  911.     pMbuf = (*pPtrMbuf)->m_nextpkt; 
  912.     m_freem (*pPtrMbuf); 
  913.     *pPtrMbuf = pMbuf; 
  914.     }
  915. remque(fp);
  916. (void) m_free(fp->pMbufHdr);
  917. }
  919. n_time
  920. iptime()
  921. {
  922. u_long t;
  924. /* t is time in milliseconds (i hope) */
  926. t = ((int) tickGet () * 1000) / sysClkRateGet ();
  928. return (htonl(t));
  929. }
  931. /*
  932.  * IP timer processing;
  933.  * if a timer expires on a reassembly
  934.  * queue, discard it.
  935.  */
  936. void
  937. ip_slowtimo()
  938. {
  939. register struct ipq *fp;
  940. int s = splnet();
  942. #ifdef WV_INSTRUMENTATION
  943. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  944.     WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_INFO, 8, 18, 
  945.                      WV_NETEVENT_IPTIMER_FRAGFREE)
  946. #endif  /* INCLUDE_WVNET */
  947. #endif
  949. #ifdef VIRTUAL_STACK
  950. fp = _ipq.next;
  951. #else
  952. fp = ipq.next;
  953. #endif
  954. if (fp == 0) {
  955. splx(s);
  956. return;
  957. }
  958. #ifdef VIRTUAL_STACK
  959. while (fp != &_ipq) {
  960. #else
  961. while (fp != &ipq) {
  962. #endif
  963. --fp->ipq_ttl;
  964. fp = fp->next;
  965. if (fp->prev->ipq_ttl == 0) {
  966. #ifdef VIRTUAL_STACK
  967. _ipstat.ips_fragtimeout++;
  968. #else
  969. ipstat.ips_fragtimeout++;
  970. #endif /* VIRTUAL_STACK */
  971. ip_freef(fp->prev);
  972. }
  973. }
  974. splx(s);
  975. return;
  976. }
  978. /*
  979.  * Drain off all datagram fragments and excess (unused) route entries.
  980.  */
  981. void
  982. ip_drain()
  983. {
  985. #ifdef VIRTUAL_STACK
  986. while (_ipq.next != &_ipq) {
  987. _ipstat.ips_fragdropped++;
  988. ip_freef(_ipq.next);
  989. }
  990. #else
  991. while (ipq.next != &ipq) {
  992. ipstat.ips_fragdropped++;
  993. ip_freef(ipq.next);
  994. }
  995. #endif /* VIRTUAL_STACK */
  997.         routeDrain();
  998. return;
  999. }
  1001. /*
  1002.  * Do option processing on a datagram,
  1003.  * possibly discarding it if bad options are encountered,
  1004.  * or forwarding it if source-routed.
  1005.  * Returns 1 if packet has been forwarded/freed,
  1006.  * 0 if the packet should be processed further.
  1007.  */
  1008. int
  1009. ip_dooptions(m)
  1010. struct mbuf *m;
  1011. {
  1012. register struct ip *ip = mtod(m, struct ip *);
  1013. register u_char *cp;
  1014. register struct ip_timestamp *ipt;
  1015. register struct in_ifaddr *ia;
  1016. int opt, optlen, cnt, off, code, type = ICMP_PARAMPROB, forward = 0;
  1017. struct in_addr *sin, dst;
  1018. n_time ntime;
  1020. dst = ip->ip_dst;
  1021. cp = (u_char *)(ip + 1);
  1022. cnt = (ip->ip_hl << 2) - sizeof (struct ip);
  1023. for (; cnt > 0; cnt -= optlen, cp += optlen) {
  1024. opt = cp[IPOPT_OPTVAL];
  1025. if (opt == IPOPT_EOL)
  1026. break;
  1027. if (opt == IPOPT_NOP)
  1028. optlen = 1;
  1029. else {
  1030. optlen = cp[IPOPT_OLEN];
  1031. if (optlen <= 0 || optlen > cnt) {
  1032. code = &cp[IPOPT_OLEN] - (u_char *)ip;
  1033. goto bad;
  1034. }
  1035. }
  1036. switch (opt) {
  1038. default:
  1039. break;
  1041. /*
  1042.  * Source routing with record.
  1043.  * Find interface with current destination address.
  1044.  * If none on this machine then drop if strictly routed,
  1045.  * or do nothing if loosely routed.
  1046.  * Record interface address and bring up next address
  1047.  * component.  If strictly routed make sure next
  1048.  * address is on directly accessible net.
  1049.  */
  1050. case IPOPT_LSRR:
  1051. case IPOPT_SSRR:
  1052. if ((off = cp[IPOPT_OFFSET]) < IPOPT_MINOFF) {
  1053. code = &cp[IPOPT_OFFSET] - (u_char *)ip;
  1054. goto bad;
  1055. }
  1056. input_ipaddr.sin_addr = ip->ip_dst;
  1057. TOS_SET (&input_ipaddr, ip->ip_tos);  /* tos routing */
  1059. ia = (struct in_ifaddr *)
  1060. ifa_ifwithaddr((struct sockaddr *)&input_ipaddr);
  1061. if (ia == 0) {
  1062. if (opt == IPOPT_SSRR) {
  1063. type = ICMP_UNREACH;
  1064. code = ICMP_UNREACH_SRCFAIL;
  1065. goto bad;
  1066. }
  1067. /*
  1068.  * Loose routing, and not at next destination
  1069.  * yet; nothing to do except forward.
  1070.  */
  1071. break;
  1072. }
  1073. off--; /* 0 origin */
  1074. if (off > optlen - sizeof(struct in_addr)) {
  1075. /*
  1076.  * End of source route.  Should be for us.
  1077.  */
  1078. #ifdef SRCRT
  1079. save_rte(cp, ip->ip_src);
  1080. #endif /* SRCRT */
  1081. break;
  1082. }
  1083. /*
  1084.  * locate outgoing interface
  1085.  */
  1086. bcopy((caddr_t)(cp + off), (caddr_t)&input_ipaddr.sin_addr,
  1087.     sizeof(input_ipaddr.sin_addr));
  1088. if (opt == IPOPT_SSRR) {
  1089. #define INA struct in_ifaddr *
  1090. #define SA struct sockaddr *
  1091.     if ((ia = (INA)ifa_ifwithdstaddr((SA)&input_ipaddr)) == 0)
  1092. ia = (INA)ifa_ifwithnet((SA)&input_ipaddr);
  1093. } else
  1094. ia = ip_rtaddr(input_ipaddr.sin_addr);
  1095. if (ia == 0) {
  1096. type = ICMP_UNREACH;
  1097. code = ICMP_UNREACH_SRCFAIL;
  1098. goto bad;
  1099. }
  1100. ip->ip_dst = input_ipaddr.sin_addr;
  1101. bcopy((caddr_t)&(IA_SIN(ia)->sin_addr),
  1102.     (caddr_t)(cp + off), sizeof(struct in_addr));
  1103. cp[IPOPT_OFFSET] += sizeof(struct in_addr);
  1104. /*
  1105.  * Let ip_intr's mcast routing check handle mcast pkts
  1106.  */
  1107. forward = !IN_MULTICAST(ntohl(ip->ip_dst.s_addr));
  1108. break;
  1110. case IPOPT_RR:
  1111. if ((off = cp[IPOPT_OFFSET]) < IPOPT_MINOFF) {
  1112. code = &cp[IPOPT_OFFSET] - (u_char *)ip;
  1113. goto bad;
  1114. }
  1115. /*
  1116.  * If no space remains, ignore.
  1117.  */
  1118. off--; /* 0 origin */
  1119. if (off > optlen - sizeof(struct in_addr))
  1120. break;
  1121. bcopy((caddr_t)(&ip->ip_dst), (caddr_t)&input_ipaddr.sin_addr,
  1122.     sizeof(input_ipaddr.sin_addr));
  1123. /*
  1124.  * locate outgoing interface; if we're the destination,
  1125.  * use the incoming interface (should be same).
  1126.  */
  1127. if ((ia = (INA)ifa_ifwithaddr((SA)&input_ipaddr)) == 0 &&
  1128.     (ia = ip_rtaddr(input_ipaddr.sin_addr)) == 0) {
  1129. type = ICMP_UNREACH;
  1130. code = ICMP_UNREACH_HOST;
  1131. goto bad;
  1132. }
  1133. bcopy((caddr_t)&(IA_SIN(ia)->sin_addr),
  1134.     (caddr_t)(cp + off), sizeof(struct in_addr));
  1135. cp[IPOPT_OFFSET] += sizeof(struct in_addr);
  1136. break;
  1138. case IPOPT_TS:
  1139. code = cp - (u_char *)ip;
  1140. ipt = (struct ip_timestamp *)cp;
  1141. if (ipt->ipt_len < 5)
  1142. goto bad;
  1143. if (ipt->ipt_ptr > ipt->ipt_len - sizeof (long)) {
  1144. if (++ipt->ipt_oflw == 0)
  1145. goto bad;
  1146. break;
  1147. }
  1148. sin = (struct in_addr *)(cp + ipt->ipt_ptr - 1);
  1149. switch (ipt->ipt_flg) {
  1151. case IPOPT_TS_TSONLY:
  1152. break;
  1154. case IPOPT_TS_TSANDADDR:
  1155. if (ipt->ipt_ptr + sizeof(n_time) +
  1156.     sizeof(struct in_addr) > ipt->ipt_len)
  1157. goto bad;
  1158. input_ipaddr.sin_addr = dst;
  1159. ia = (INA)ifaof_ifpforaddr((SA)&input_ipaddr,
  1160.     m->m_pkthdr.rcvif);
  1161. if (ia == 0)
  1162. continue;
  1163. bcopy((caddr_t)&IA_SIN(ia)->sin_addr,
  1164.     (caddr_t)sin, sizeof(struct in_addr));
  1165. ipt->ipt_ptr += sizeof(struct in_addr);
  1166. break;
  1168. case IPOPT_TS_PRESPEC:
  1169. if (ipt->ipt_ptr + sizeof(n_time) +
  1170.     sizeof(struct in_addr) > ipt->ipt_len)
  1171. goto bad;
  1172. bcopy((caddr_t)sin, (caddr_t)&input_ipaddr.sin_addr,
  1173.     sizeof(struct in_addr));
  1174. if (ifa_ifwithaddr((SA)&input_ipaddr) == 0)
  1175. continue;
  1176. ipt->ipt_ptr += sizeof(struct in_addr);
  1177. break;
  1179. default:
  1180. goto bad;
  1181. }
  1182. ntime = iptime();
  1183. bcopy((caddr_t)&ntime, (caddr_t)cp + ipt->ipt_ptr - 1,
  1184.     sizeof(n_time));
  1185. ipt->ipt_ptr += sizeof(n_time);
  1186. }
  1187. }
  1188. if (forward) {
  1189. ip_forward(m, 1);
  1190. return (1);
  1191. }
  1192. return (0);
  1193. bad:
  1194. ip->ip_len -= ip->ip_hl << 2;   /* XXX icmp_error adds in hdr length */
  1195. if (_icmpErrorHook != NULL)
  1196.     (*_icmpErrorHook) (m, type, code, 0, 0); 
  1198. #ifdef WV_INSTRUMENTATION
  1199. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  1200.         WV_NET_EVENT_2 (NET_CORE_EVENT, WV_NET_CRITICAL, 18, 9, 
  1201.                         WV_NETEVENT_IPIN_BADOPT, WV_NET_RECV, type, code)
  1202. #endif  /* INCLUDE_WVNET */
  1203. #endif
  1205. #ifdef VIRTUAL_STACK
  1206. _ipstat.ips_badoptions++;
  1207. #else
  1208. ipstat.ips_badoptions++;
  1209. #endif /* VIRTUAL_STACK */
  1210. return (1);
  1211. }
  1213. /*
  1214.  * Given address of next destination (final or next hop),
  1215.  * return internet address info of interface to be used to get there.
  1216.  */
  1217. struct in_ifaddr *
  1218. ip_rtaddr(dst)
  1219.  struct in_addr dst;
  1220. {
  1221. register struct sockaddr_in *sin;
  1223. sin = (struct sockaddr_in *) &ipforward_rt.ro_dst;
  1225. if (ipforward_rt.ro_rt == 0 ||
  1226.             (ipforward_rt.ro_rt->rt_flags & RTF_UP) == 0 ||
  1227.             dst.s_addr != sin->sin_addr.s_addr) {
  1228. if (ipforward_rt.ro_rt) {
  1229. RTFREE(ipforward_rt.ro_rt);
  1230. ipforward_rt.ro_rt = 0;
  1231. }
  1232. sin->sin_family = AF_INET;
  1233. sin->sin_len = sizeof(*sin);
  1234. sin->sin_addr = dst;
  1236. ipforward_rt.ro_rt = rtalloc2 (&ipforward_rt.ro_dst);
  1237. }
  1238. if (ipforward_rt.ro_rt == 0)
  1239. return ((struct in_ifaddr *)0);
  1240. return ((struct in_ifaddr *) ipforward_rt.ro_rt->rt_ifa);
  1241. }
  1243. #ifdef SRCRT
  1244. /*
  1245.  * Save incoming source route for use in replies,
  1246.  * to be picked up later by ip_srcroute if the receiver is interested.
  1247.  */
  1248. void
  1249. save_rte(option, dst)
  1250. u_char *option;
  1251. struct in_addr dst;
  1252. {
  1253. unsigned olen;
  1255. olen = option[IPOPT_OLEN];
  1256. #ifdef DIAGNOSTIC
  1257. if (ipprintfs)
  1258. printf("save_rte: olen %dn", olen);
  1259. #endif
  1260. if (olen > sizeof(ip_srcrt) - (1 + sizeof(dst)))
  1261. return;
  1262. bcopy((caddr_t)option, (caddr_t)ip_srcrt.srcopt, olen);
  1263. ip_nhops = (olen - IPOPT_OFFSET - 1) / sizeof(struct in_addr);
  1264. ip_srcrt.dst = dst;
  1265. }
  1267. /*
  1268.  * Retrieve incoming source route for use in replies,
  1269.  * in the same form used by setsockopt.
  1270.  * The first hop is placed before the options, will be removed later.
  1271.  */
  1272. struct mbuf *
  1273. ip_srcroute()
  1274. {
  1275. register struct in_addr *p, *q;
  1276. register struct mbuf *m;
  1278. if (ip_nhops == 0)
  1279. return ((struct mbuf *)0);
  1280. m= mBufClGet(M_DONTWAIT, MT_SOOPTS, CL_SIZE_128, TRUE);
  1281. if (m == 0)
  1282. return ((struct mbuf *)0);
  1284. #define OPTSIZ (sizeof(ip_srcrt.nop) + sizeof(ip_srcrt.srcopt))
  1286. /* length is (nhops+1)*sizeof(addr) + sizeof(nop + srcrt header) */
  1287. m->m_len = ip_nhops * sizeof(struct in_addr) + sizeof(struct in_addr) +
  1288.     OPTSIZ;
  1289. #ifdef DIAGNOSTIC
  1290. if (ipprintfs)
  1291. printf("ip_srcroute: nhops %d mlen %d", ip_nhops, m->m_len);
  1292. #endif
  1294. /*
  1295.  * First save first hop for return route
  1296.  */
  1297. p = &ip_srcrt.route[ip_nhops - 1];
  1298. *(mtod(m, struct in_addr *)) = *p--;
  1299. #ifdef DIAGNOSTIC
  1300. if (ipprintfs)
  1301. printf(" hops %lx", ntohl(mtod(m, struct in_addr *)->s_addr));
  1302. #endif
  1304. /*
  1305.  * Copy option fields and padding (nop) to mbuf.
  1306.  */
  1307. ip_srcrt.nop = IPOPT_NOP;
  1308. ip_srcrt.srcopt[IPOPT_OFFSET] = IPOPT_MINOFF;
  1309. bcopy((caddr_t)&ip_srcrt.nop,
  1310.     mtod(m, caddr_t) + sizeof(struct in_addr), OPTSIZ);
  1311. q = (struct in_addr *)(mtod(m, caddr_t) +
  1312.     sizeof(struct in_addr) + OPTSIZ);
  1313. #undef OPTSIZ
  1314. /*
  1315.  * Record return path as an IP source route,
  1316.  * reversing the path (pointers are now aligned).
  1317.  */
  1318. while (p >= ip_srcrt.route) {
  1319. #ifdef DIAGNOSTIC
  1320. if (ipprintfs)
  1321. printf(" %lx", ntohl(q->s_addr));
  1322. #endif
  1323. *q++ = *p--;
  1324. }
  1325. /*
  1326.  * Last hop goes to final destination.
  1327.  */
  1328. *q = ip_srcrt.dst;
  1329. #ifdef DIAGNOSTIC
  1330. if (ipprintfs)
  1331. printf(" %lxn", ntohl(q->s_addr));
  1332. #endif
  1333. return (m);
  1334. }
  1336. #endif /* SRCRT */
  1338. /*
  1339.  * Strip out IP options, at higher
  1340.  * level protocol in the kernel.
  1341.  * Second argument is buffer to which options
  1342.  * will be moved, and return value is their length.
  1343.  * XXX should be deleted; last arg currently ignored.
  1344.  */
  1345. void
  1346. ip_stripoptions(m, mopt)
  1347. register struct mbuf *m;
  1348. struct mbuf *mopt;
  1349. {
  1350. register int i;
  1351. struct ip *ip = mtod(m, struct ip *);
  1352. register caddr_t opts;
  1353. int olen;
  1355. olen = (ip->ip_hl<<2) - sizeof (struct ip);
  1356. opts = (caddr_t)(ip + 1);
  1357. i = m->m_len - (sizeof (struct ip) + olen);
  1358. bcopy(opts  + olen, opts, (unsigned)i);
  1359. m->m_len -= olen;
  1360. if (m->m_flags & M_PKTHDR)
  1361. m->m_pkthdr.len -= olen;
  1362. ip->ip_hl = sizeof(struct ip) >> 2;
  1363. }
  1365. u_char inetctlerrmap[PRC_NCMDS] = {
  1366. 0, 0, 0, 0,
  1367. 0, EMSGSIZE, EHOSTDOWN, EHOSTUNREACH,
  1368. EHOSTUNREACH, EHOSTUNREACH, ECONNREFUSED, ECONNREFUSED,
  1369. EMSGSIZE, EHOSTUNREACH, 0, 0,
  1370. 0, 0, 0, 0,
  1371. ENOPROTOOPT
  1372. };
  1374. /*
  1375.  * Forward a packet.  If some error occurs return the sender
  1376.  * an icmp packet.  Note we can't always generate a meaningful
  1377.  * icmp message because icmp doesn't have a large enough repertoire
  1378.  * of codes and types.
  1379.  *
  1380.  * If not forwarding, just drop the packet.  This could be confusing
  1381.  * if (_ipCfgFlags & IP_DO_FORWARDING) was zero but some routing protocol was
  1382.  * advancing us as a gateway to somewhere.  However, we must let the routing
  1383.  * protocol deal with that.
  1384.  *
  1385.  * The srcrt parameter indicates whether the packet is being forwarded
  1386.  * via a source route.
  1387.  */
  1388. void
  1389. ip_forward(m, srcrt)
  1390. struct mbuf *m;
  1391. int srcrt;
  1392. {
  1393. register struct ip *ip = mtod(m, struct ip *);
  1394. register struct sockaddr_in *sin;
  1395. register struct rtentry *rt;
  1396. int error, type = 0, code = 0;
  1397. struct mbuf *mcopy;
  1398. n_long dest;
  1399. struct ifnet *destifp;
  1401. #ifdef WV_INSTRUMENTATION
  1402. #ifdef INCLUDE_WVNET
  1403.         u_long srcAddr; /* Source IP address, unavailable after ip_output() */
  1404.         u_long dstAddr; /* Dest. IP address, unavailable after ip_output() */
  1405. #endif
  1406. #endif
  1408. dest = 0;
  1409. #ifdef DIAGNOSTIC
  1410. if (ipprintfs)
  1411. printf("forward: src %x dst %x ttl %xn", ip->ip_src,
  1412. ip->ip_dst, ip->ip_ttl);
  1413. #endif
  1414. if (m->m_flags & M_BCAST || in_canforward(ip->ip_dst) == 0) {
  1415. #ifdef WV_INSTRUMENTATION
  1416. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  1417.     WV_NET_ADDROUT_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 19, 10, 
  1418.                             ip->ip_src.s_addr, ip->ip_dst.s_addr,
  1419.                             WV_NETEVENT_IPFWD_BADADDR, WV_NET_RECV,
  1420.                             ip->ip_dst.s_addr)
  1421. #endif  /* INCLUDE_WVNET */
  1422. #endif
  1424. #ifdef VIRTUAL_STACK
  1425. _ipstat.ips_cantforward++;
  1426. #else
  1427. ipstat.ips_cantforward++;
  1428. #endif /* VIRTUAL_STACK */
  1429. m_freem(m);
  1430. return;
  1431. }
  1432. HTONS(ip->ip_id);
  1433. if (ip->ip_ttl <= IPTTLDEC) {
  1434. if (_icmpErrorHook != NULL)
  1435.                     {
  1436.                     HTONS(ip->ip_len);
  1437.                     (*_icmpErrorHook)(m, ICMP_TIMXCEED, ICMP_TIMXCEED_INTRANS,
  1438.                                       dest, 0);
  1439.                     }
  1440. return;
  1441. }
  1442. ip->ip_ttl -= IPTTLDEC;
  1444. sin = (struct sockaddr_in *)&ipforward_rt.ro_dst;
  1445. if ((rt = ipforward_rt.ro_rt) == 0 ||
  1446.             (rt->rt_flags & RTF_UP) == 0 ||
  1447.     ip->ip_dst.s_addr != sin->sin_addr.s_addr) {
  1448. if (ipforward_rt.ro_rt) {
  1449. RTFREE(ipforward_rt.ro_rt);
  1450. ipforward_rt.ro_rt = 0;
  1451. }
  1452. sin->sin_family = AF_INET;
  1453. sin->sin_len = sizeof(*sin);
  1454. sin->sin_addr = ip->ip_dst;
  1456. ipforward_rt.ro_rt = rtalloc2 (&ipforward_rt.ro_dst);
  1457. if (ipforward_rt.ro_rt == 0) {
  1458. #ifdef VIRTUAL_STACK
  1459. _ipstat.ips_noroute++;
  1460. #else
  1461. ipstat.ips_noroute++;
  1462. #endif /* VIRTUAL_STACK */
  1463. if (_icmpErrorHook != NULL)
  1464.     (*_icmpErrorHook)(m, ICMP_UNREACH, 
  1465.      ICMP_UNREACH_HOST, dest, 0);
  1466. return;
  1467. }
  1468. rt = ipforward_rt.ro_rt;
  1469. }
  1471. /*
  1472.  * Save at most 64 bytes of the packet in case
  1473.  * we need to generate an ICMP message to the src.
  1474.  */
  1475. mcopy = m_copy(m, 0, min((int)ip->ip_len, 64));
  1477. /*
  1478.  * If forwarding packet using same interface that it came in on,
  1479.  * perhaps should send a redirect to sender to shortcut a hop.
  1480.  * Only send redirect if source is sending directly to us,
  1481.  * and if packet was not source routed (or has any options).
  1482.  * Also, don't send redirect if forwarding using a default route
  1483.  * or a route modified by a redirect.
  1484.  */
  1485. #define satosin(sa) ((struct sockaddr_in *)(sa))
  1486. if (rt->rt_ifp == m->m_pkthdr.rcvif &&
  1487.     (rt->rt_flags & (RTF_DYNAMIC|RTF_MODIFIED)) == 0 &&
  1488.     satosin(rt_key(rt))->sin_addr.s_addr != 0 &&
  1489.     (_ipCfgFlags & IP_DO_REDIRECT) && !srcrt) {
  1490. #define RTA(rt) ((struct in_ifaddr *)(rt->rt_ifa))
  1491. u_long src = ntohl(ip->ip_src.s_addr);
  1493. if (RTA(rt) &&
  1494.     (src & RTA(rt)->ia_subnetmask) == RTA(rt)->ia_subnet) {
  1495.     if (rt->rt_flags & RTF_GATEWAY)
  1496. dest = satosin(rt->rt_gateway)->sin_addr.s_addr;
  1497.     else
  1498. dest = ip->ip_dst.s_addr;
  1499.     /* Router requirements says to only send host redirects */
  1500.     type = ICMP_REDIRECT;
  1501.     code = ICMP_REDIRECT_HOST;
  1502. #ifdef DIAGNOSTIC
  1503.     if (ipprintfs)
  1504.         printf("redirect (%d) to %lxn", code, (u_long)dest);
  1505. #endif
  1506. }
  1507. }
  1509. #ifdef WV_INSTRUMENTATION
  1510. #ifdef INCLUDE_WVNET
  1511.         /*
  1512.          * Save the source and destination address from the original packet,
  1513.          * since they will be unavailable after the ip_output() call returns.
  1514.          */
  1516.         srcAddr = ip->ip_src.s_addr;
  1517.         dstAddr = ip->ip_dst.s_addr;
  1518. #endif
  1519. #endif
  1521.         /*
  1522.          * Set the M_FORWARD flag to nominate the route for the fast path.
  1523.          */
  1525.         m->m_flags |= M_FORWARD;
  1527. error = ip_output(m, (struct mbuf *)0, &ipforward_rt, IP_FORWARDING
  1528. #ifdef DIRECTED_BROADCAST
  1529.     | IP_ALLOWBROADCAST
  1530. #endif
  1531.                           , 0);
  1533. #ifdef WV_INSTRUMENTATION
  1534. #ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
  1535.     WV_NET_ADDROUT_EVENT_3 (NET_CORE_EVENT, WV_NET_NOTICE, 11, 15,
  1536.                             srcAddr, dstAddr,
  1537.                             WV_NETEVENT_IPFWD_STATUS, WV_NET_SEND,
  1538.                             error, srcAddr, dstAddr)
  1539. #endif  /* INCLUDE_WVNET */
  1540. #endif
  1542. if (error)
  1543. #ifdef VIRTUAL_STACK
  1544. _ipstat.ips_cantforward++;
  1545. #else
  1546. ipstat.ips_cantforward++;
  1547. #endif /* VIRTUAL_STACK */
  1548. else {
  1549. #ifdef VIRTUAL_STACK
  1550. _ipstat.ips_forward++;
  1551. #else
  1552. ipstat.ips_forward++;
  1553. #endif /* VIRTUAL_STACK */
  1554. if (type)
  1555. #ifdef VIRTUAL_STACK
  1556. _ipstat.ips_redirectsent++;
  1557. #else
  1558. ipstat.ips_redirectsent++;
  1559. #endif /* VIRTUAL_STACK */
  1560. else {
  1561. if (mcopy)
  1562. m_freem(mcopy);
  1563. return;
  1564. }
  1565. }
  1566. if (mcopy == NULL)
  1567. return;
  1568. destifp = NULL;
  1570. switch (error) {
  1572. case 0: /* forwarded, but need redirect */
  1573. /* type, code set above */
  1574. break;
  1576. case ENETUNREACH: /* shouldn't happen, checked above */
  1577. case EHOSTUNREACH:
  1578. case ENETDOWN:
  1579. case EHOSTDOWN:
  1580. default:
  1581. type = ICMP_UNREACH;
  1582. code = ICMP_UNREACH_HOST;
  1583. break;
  1585. case EMSGSIZE:
  1586. type = ICMP_UNREACH;
  1587. code = ICMP_UNREACH_NEEDFRAG;
  1588. if (ipforward_rt.ro_rt)
  1589. destifp = ipforward_rt.ro_rt->rt_ifp;
  1590. #ifdef VIRTUAL_STACK
  1591. _ipstat.ips_cantfrag++;
  1592. #else
  1593. ipstat.ips_cantfrag++;
  1594. #endif /* VIRTUAL_STACK */
  1595. break;
  1597. case ENOBUFS:
  1598. type = ICMP_SOURCEQUENCH;
  1599. code = 0;
  1600. break;
  1601. }
  1602. if (_icmpErrorHook != NULL)
  1603.     (*_icmpErrorHook)(mcopy, type, code, dest, destifp);
  1604. }
  1606. #ifdef SYSCTL_SUPPORT
  1607. int
  1608. ip_sysctl(name, namelen, oldp, oldlenp, newp, newlen)
  1609. int *name;
  1610. u_int namelen;
  1611. void *oldp;
  1612. size_t *oldlenp;
  1613. void *newp;
  1614. size_t newlen;
  1615. {
  1616. /*
  1617.  * XXX - This event cannot currently occur: the ip_sysctl() routine
  1618.  *       is only called by the Unix sysctl command which is not supported
  1619.  *       by VxWorks
  1621. #ifdef WV_INSTRUMENTATION
  1622. #ifdef INCLUDE_WVNET    /@ WV_NET_INFO event @/
  1623.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_INFO, 9, 19, 
  1624.                      WV_NETEVENT_IPCTRL_START, name[0])
  1625. #endif  /@ INCLUDE_WVNET @/
  1626. #endif
  1628.  * XXX - end of unused event
  1629.  */ 
  1631. /* All sysctl names at this level are terminal. */
  1632. if (namelen != 1)
  1633.             {
  1634. /*
  1635.  * XXX - This event cannot currently occur: the ip_sysctl() routine
  1636.  *       is only called by the Unix sysctl command which is not supported
  1637.  *       by VxWorks
  1639. #ifdef WV_INSTRUMENTATION
  1640. #ifdef INCLUDE_WVNET    /@ WV_NET_ERROR event @/
  1641.             WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_ERROR, 20, 11, 
  1642.                              WV_NETEVENT_IPCTRL_BADCMDLEN, namelen)
  1643. #endif  /@ INCLUDE_WVNET @/
  1644. #endif
  1646.  * XXX - end of unused event
  1647.  */ 
  1648.             return (ENOTDIR);
  1649.             }
  1651. switch (name[0]) {
  1652. case IPCTL_FORWARDING:
  1653. return (sysctl_int(oldp, oldlenp, newp, newlen, &ipforwarding));
  1654. case IPCTL_SENDREDIRECTS:
  1655. return (sysctl_int(oldp, oldlenp, newp, newlen,
  1656. &ipsendredirects));
  1657. case IPCTL_DEFTTL:
  1658. return (sysctl_int(oldp, oldlenp, newp, newlen, &ip_defttl));
  1659. #ifdef notyet
  1660. case IPCTL_DEFMTU:
  1661. return (sysctl_int(oldp, oldlenp, newp, newlen, &ip_mtu));
  1662. #endif
  1663. default:
  1665. /*
  1666.  * XXX - This event cannot currently occur: the ip_sysctl() routine
  1667.  *       is only called by the Unix sysctl command which is not supported
  1668.  *       by VxWorks
  1670. #ifdef WV_INSTRUMENTATION
  1671. #ifdef INCLUDE_WVNET    /@ WV_NET_ERROR event @/
  1672.             WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_ERROR, 21, 12, 
  1673.                              WV_NETEVENT_IPCTRL_BADCMD, name[0])
  1674. #endif  /@ INCLUDE_WVNET @/
  1675. #endif
  1677.  * XXX - end of unused event
  1678.  */ 
  1680. return (EOPNOTSUPP);
  1681. }
  1682. /* NOTREACHED */
  1683. }
  1684. #endif /* SYSCTL_SUPPORT */