[BACK]Return to ip_input.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / netinet

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/netinet/ip_input.c between version 1.93.2.8 and 1.94

version 1.93.2.8, 2001/04/21 17:46:48 version 1.94, 1999/10/26 09:53:17
Line 120 
Line 120 
 #include <sys/proc.h>  #include <sys/proc.h>
 #include <sys/pool.h>  #include <sys/pool.h>
   
 #include <uvm/uvm_extern.h>  #include <vm/vm.h>
   
 #include <sys/sysctl.h>  #include <sys/sysctl.h>
   
 #include <net/if.h>  #include <net/if.h>
Line 140 
Line 139 
 #include <netinet/in_gif.h>  #include <netinet/in_gif.h>
 #include "gif.h"  #include "gif.h"
   
 #ifdef MROUTING  
 #include <netinet/ip_mroute.h>  
 #endif  
   
 #ifdef IPSEC  #ifdef IPSEC
 #include <netinet6/ipsec.h>  #include <netinet6/ipsec.h>
 #include <netkey/key.h>  #include <netkey/key.h>
   #include <netkey/key_debug.h>
 #endif  #endif
   
 #ifndef IPFORWARDING  #ifndef IPFORWARDING
Line 198  int ipprintfs = 0;
Line 194  int ipprintfs = 0;
 struct rttimer_queue *ip_mtudisc_timeout_q = NULL;  struct rttimer_queue *ip_mtudisc_timeout_q = NULL;
   
 extern  struct domain inetdomain;  extern  struct domain inetdomain;
   extern  struct protosw inetsw[];
   u_char  ip_protox[IPPROTO_MAX];
 int     ipqmaxlen = IFQ_MAXLEN;  int     ipqmaxlen = IFQ_MAXLEN;
 struct  in_ifaddrhead in_ifaddr;  struct  in_ifaddrhead in_ifaddr;
 struct  in_ifaddrhashhead *in_ifaddrhashtbl;  struct  in_ifaddrhashhead *in_ifaddrhashtbl;
 struct  ifqueue ipintrq;  struct  ifqueue ipintrq;
 struct  ipstat  ipstat;  struct  ipstat  ipstat;
 u_int16_t       ip_id;  u_int16_t       ip_id;
   int     ip_defttl;
 #ifdef PFIL_HOOKS  
 struct pfil_head inet_pfil_hook;  
 #endif  
   
 struct ipqhead ipq;  struct ipqhead ipq;
 int     ipq_locked;  int     ipq_locked;
 int     ip_nfragpackets = 0;  
 int     ip_maxfragpackets = 200;  
   
 static __inline int ipq_lock_try __P((void));  static __inline int ipq_lock_try __P((void));
 static __inline void ipq_unlock __P((void));  static __inline void ipq_unlock __P((void));
Line 222  ipq_lock_try()
Line 215  ipq_lock_try()
 {  {
         int s;          int s;
   
         /*          s = splimp();
          * Use splvm() -- we're bloking things that would cause  
          * mbuf allocation.  
          */  
         s = splvm();  
         if (ipq_locked) {          if (ipq_locked) {
                 splx(s);                  splx(s);
                 return (0);                  return (0);
Line 241  ipq_unlock()
Line 230  ipq_unlock()
 {  {
         int s;          int s;
   
         s = splvm();          s = splimp();
         ipq_locked = 0;          ipq_locked = 0;
         splx(s);          splx(s);
 }  }
Line 294  static void save_rte __P((u_char *, stru
Line 283  static void save_rte __P((u_char *, stru
 void  void
 ip_init()  ip_init()
 {  {
         struct protosw *pr;          register struct protosw *pr;
         int i;          register int i;
   
         pool_init(&ipqent_pool, sizeof(struct ipqent), 0, 0, 0, "ipqepl",          pool_init(&ipqent_pool, sizeof(struct ipqent), 0, 0, 0, "ipqepl",
             0, NULL, NULL, M_IPQ);              0, NULL, NULL, M_IPQ);
Line 314  ip_init()
Line 303  ip_init()
         ip_id = time.tv_sec & 0xffff;          ip_id = time.tv_sec & 0xffff;
         ipintrq.ifq_maxlen = ipqmaxlen;          ipintrq.ifq_maxlen = ipqmaxlen;
         TAILQ_INIT(&in_ifaddr);          TAILQ_INIT(&in_ifaddr);
         in_ifaddrhashtbl = hashinit(IN_IFADDR_HASH_SIZE, HASH_LIST, M_IFADDR,          in_ifaddrhashtbl =
             M_WAITOK, &in_ifaddrhash);              hashinit(IN_IFADDR_HASH_SIZE, M_IFADDR, M_WAITOK, &in_ifaddrhash);
         if (ip_mtudisc != 0)          if (ip_mtudisc != 0)
                 ip_mtudisc_timeout_q =                  ip_mtudisc_timeout_q =
                     rt_timer_queue_create(ip_mtudisc_timeout);                      rt_timer_queue_create(ip_mtudisc_timeout);
 #ifdef GATEWAY  #ifdef GATEWAY
         ipflow_init();          ipflow_init();
 #endif  #endif
   
 #ifdef PFIL_HOOKS  
         /* Register our Packet Filter hook. */  
         inet_pfil_hook.ph_type = PFIL_TYPE_AF;  
         inet_pfil_hook.ph_af   = AF_INET;  
         i = pfil_head_register(&inet_pfil_hook);  
         if (i != 0)  
                 printf("ip_init: WARNING: unable to register pfil hook, "  
                     "error %d\n", i);  
 #endif /* PFIL_HOOKS */  
 }  }
   
 struct  sockaddr_in ipaddr = { sizeof(ipaddr), AF_INET };  struct  sockaddr_in ipaddr = { sizeof(ipaddr), AF_INET };
Line 347  ipintr()
Line 326  ipintr()
         struct mbuf *m;          struct mbuf *m;
   
         while (1) {          while (1) {
                 s = splnet();                  s = splimp();
                 IF_DEQUEUE(&ipintrq, m);                  IF_DEQUEUE(&ipintrq, m);
                 splx(s);                  splx(s);
                 if (m == 0)                  if (m == 0)
Line 363  ipintr()
Line 342  ipintr()
 void  void
 ip_input(struct mbuf *m)  ip_input(struct mbuf *m)
 {  {
         struct ip *ip = NULL;          register struct ip *ip = NULL;
         struct ipq *fp;          register struct ipq *fp;
         struct in_ifaddr *ia;          register struct in_ifaddr *ia;
         struct ifaddr *ifa;          register struct ifaddr *ifa;
         struct ipqent *ipqe;          struct ipqent *ipqe;
         int hlen = 0, mff, len;          int hlen = 0, mff, len;
         int downmatch;  #ifdef PFIL_HOOKS
           struct packet_filter_hook *pfh;
           struct mbuf *m0;
           int rv;
   #endif /* PFIL_HOOKS */
   
 #ifdef  DIAGNOSTIC  #ifdef  DIAGNOSTIC
         if ((m->m_flags & M_PKTHDR) == 0)          if ((m->m_flags & M_PKTHDR) == 0)
Line 414  ip_input(struct mbuf *m)
Line 397  ip_input(struct mbuf *m)
                 }                  }
                 ip = mtod(m, struct ip *);                  ip = mtod(m, struct ip *);
         }          }
   
         /*          /*
          * RFC1122: packets with a multicast source address are           * we drop packets that have a multicast address as source
          * not allowed.           * as wanted by rfc 1112
          */           */
         if (IN_MULTICAST(ip->ip_src.s_addr)) {          if (IN_MULTICAST(ip->ip_src.s_addr)) {
                 ipstat.ips_badaddr++;  
                 goto bad;                  goto bad;
         }          }
   
         /* 127/8 must not appear on wire - RFC1122 */  
         if ((ntohl(ip->ip_dst.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET ||  
             (ntohl(ip->ip_src.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) {  
                 if ((m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) == 0) {  
                         ipstat.ips_badaddr++;  
                         goto bad;  
                 }  
         }  
   
         if (in_cksum(m, hlen) != 0) {          if (in_cksum(m, hlen) != 0) {
                 ipstat.ips_badsum++;                  ipstat.ips_badsum++;
                 goto bad;                  goto bad;
         }          }
   
         /* Retrieve the packet length. */          /*
         len = ntohs(ip->ip_len);           * Convert fields to host representation.
            */
           NTOHS(ip->ip_len);
           NTOHS(ip->ip_off);
           len = ip->ip_len;
   
         /*          /*
          * Check for additional length bogosity           * Check for additional length bogosity
Line 486  ip_input(struct mbuf *m)
Line 462  ip_input(struct mbuf *m)
          * Note that filters must _never_ set this flag, as another filter           * Note that filters must _never_ set this flag, as another filter
          * in the list may have previously cleared it.           * in the list may have previously cleared it.
          */           */
         /*          m0 = m;
          * let ipfilter look at packet on the wire,          for (pfh = pfil_hook_get(PFIL_IN); pfh; pfh = pfh->pfil_link.tqe_next)
          * not the decapsulated packet.                  if (pfh->pfil_func) {
          */                          rv = pfh->pfil_func(ip, hlen, m->m_pkthdr.rcvif, 0, &m0);
 #ifdef IPSEC                          if (rv)
         if (!ipsec_gethist(m, NULL))                                  return;
 #else                          m = m0;
         if (1)                          if (m == NULL)
 #endif                                  return;
         {                          ip = mtod(m, struct ip *);
                 if (pfil_run_hooks(&inet_pfil_hook, &m, m->m_pkthdr.rcvif,                  }
                                    PFIL_IN) != 0)  
                 return;  
                 if (m == NULL)  
                         return;  
                 ip = mtod(m, struct ip *);  
         }  
 #endif /* PFIL_HOOKS */  #endif /* PFIL_HOOKS */
   
 #ifdef ALTQ  
         /* XXX Temporary until ALTQ is changed to use a pfil hook */  
         if (altq_input != NULL && (*altq_input)(m, AF_INET) == 0) {  
                 /* packet dropped by traffic conditioner */  
                 return;  
         }  
 #endif  
   
         /*  
          * Convert fields to host representation.  
          */  
         NTOHS(ip->ip_len);  
         NTOHS(ip->ip_off);  
   
         /*          /*
          * Process options and, if not destined for us,           * Process options and, if not destined for us,
          * ship it on.  ip_dooptions returns 1 when an           * ship it on.  ip_dooptions returns 1 when an
Line 531  ip_input(struct mbuf *m)
Line 487  ip_input(struct mbuf *m)
   
         /*          /*
          * Check our list of addresses, to see if the packet is for us.           * Check our list of addresses, to see if the packet is for us.
          *           */
          * Traditional 4.4BSD did not consult IFF_UP at all.          INADDR_TO_IA(ip->ip_dst, ia);
          * The behavior here is to treat addresses on !IFF_UP interface  
          * as not mine.  
          */  
         downmatch = 0;  
         for (ia = IN_IFADDR_HASH(ip->ip_dst.s_addr).lh_first;  
              ia != NULL;  
              ia = ia->ia_hash.le_next) {  
                 if (in_hosteq(ia->ia_addr.sin_addr, ip->ip_dst)) {  
                         if ((ia->ia_ifp->if_flags & IFF_UP) != 0)  
                                 break;  
                         else  
                                 downmatch++;  
                 }  
         }  
         if (ia != NULL)          if (ia != NULL)
                 goto ours;                  goto ours;
         if (m->m_pkthdr.rcvif->if_flags & IFF_BROADCAST) {          if (m->m_pkthdr.rcvif->if_flags & IFF_BROADCAST) {
Line 635  ip_input(struct mbuf *m)
Line 577  ip_input(struct mbuf *m)
         if (ipforwarding == 0) {          if (ipforwarding == 0) {
                 ipstat.ips_cantforward++;                  ipstat.ips_cantforward++;
                 m_freem(m);                  m_freem(m);
         } else {          } else
                 /*  
                  * If ip_dst matched any of my address on !IFF_UP interface,  
                  * and there's no IFF_UP interface that matches ip_dst,  
                  * send icmp unreach.  Forwarding it will result in in-kernel  
                  * forwarding loop till TTL goes to 0.  
                  */  
                 if (downmatch) {  
                         icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0, 0);  
                         ipstat.ips_cantforward++;  
                         return;  
                 }  
                 ip_forward(m, 0);                  ip_forward(m, 0);
         }  
         return;          return;
   
 ours:  ours:
Line 725  found:
Line 655  found:
                 IPQ_UNLOCK();                  IPQ_UNLOCK();
         }          }
   
 #ifdef IPSEC  
         /*  
          * enforce IPsec policy checking if we are seeing last header.  
          * note that we do not visit this with protocols with pcb layer  
          * code - like udp/tcp/raw ip.  
          */  
         if ((inetsw[ip_protox[ip->ip_p]].pr_flags & PR_LASTHDR) != 0 &&  
             ipsec4_in_reject(m, NULL)) {  
                 ipsecstat.in_polvio++;  
                 goto bad;  
         }  
 #endif  
   
         /*          /*
          * Switch out to protocol's input routine.           * Switch out to protocol's input routine.
          */           */
 #if IFA_STATS  #if IFA_STATS
         if (ia && ip)          ia->ia_ifa.ifa_data.ifad_inbytes += ip->ip_len;
                 ia->ia_ifa.ifa_data.ifad_inbytes += ip->ip_len;  
 #endif  #endif
         ipstat.ips_delivered++;          ipstat.ips_delivered++;
     {      {
Line 764  bad:
Line 680  bad:
  */   */
 struct mbuf *  struct mbuf *
 ip_reass(ipqe, fp)  ip_reass(ipqe, fp)
         struct ipqent *ipqe;          register struct ipqent *ipqe;
         struct ipq *fp;          register struct ipq *fp;
 {  {
         struct mbuf *m = ipqe->ipqe_m;          register struct mbuf *m = ipqe->ipqe_m;
         struct ipqent *nq, *p, *q;          register struct ipqent *nq, *p, *q;
         struct ip *ip;          struct ip *ip;
         struct mbuf *t;          struct mbuf *t;
         int hlen = ipqe->ipqe_ip->ip_hl << 2;          int hlen = ipqe->ipqe_ip->ip_hl << 2;
Line 787  ip_reass(ipqe, fp)
Line 703  ip_reass(ipqe, fp)
          * If first fragment to arrive, create a reassembly queue.           * If first fragment to arrive, create a reassembly queue.
          */           */
         if (fp == 0) {          if (fp == 0) {
                 /*  
                  * Enforce upper bound on number of fragmented packets  
                  * for which we attempt reassembly;  
                  * If maxfrag is 0, never accept fragments.  
                  * If maxfrag is -1, accept all fragments without limitation.  
                  */  
                 if (ip_maxfragpackets < 0)  
                         ;  
                 else if (ip_nfragpackets >= ip_maxfragpackets)  
                         goto dropfrag;  
                 ip_nfragpackets++;  
                 MALLOC(fp, struct ipq *, sizeof (struct ipq),                  MALLOC(fp, struct ipq *, sizeof (struct ipq),
                     M_FTABLE, M_NOWAIT);                      M_FTABLE, M_NOWAIT);
                 if (fp == NULL)                  if (fp == NULL)
Line 909  insert:
Line 814  insert:
          * Make header visible.           * Make header visible.
          */           */
         ip->ip_len = next;          ip->ip_len = next;
           ip->ip_ttl = 0; /* xxx */
           ip->ip_sum = 0;
         ip->ip_src = fp->ipq_src;          ip->ip_src = fp->ipq_src;
         ip->ip_dst = fp->ipq_dst;          ip->ip_dst = fp->ipq_dst;
         LIST_REMOVE(fp, ipq_q);          LIST_REMOVE(fp, ipq_q);
         FREE(fp, M_FTABLE);          FREE(fp, M_FTABLE);
         ip_nfragpackets--;  
         m->m_len += (ip->ip_hl << 2);          m->m_len += (ip->ip_hl << 2);
         m->m_data -= (ip->ip_hl << 2);          m->m_data -= (ip->ip_hl << 2);
         /* some debugging cruft by sklower, below, will go away soon */          /* some debugging cruft by sklower, below, will go away soon */
         if (m->m_flags & M_PKTHDR) { /* XXX this should be done elsewhere */          if (m->m_flags & M_PKTHDR) { /* XXX this should be done elsewhere */
                 int plen = 0;                  register int plen = 0;
                 for (t = m; t; t = t->m_next)                  for (t = m; t; t = t->m_next)
                         plen += t->m_len;                          plen += t->m_len;
                 m->m_pkthdr.len = plen;                  m->m_pkthdr.len = plen;
Line 940  void
Line 846  void
 ip_freef(fp)  ip_freef(fp)
         struct ipq *fp;          struct ipq *fp;
 {  {
         struct ipqent *q, *p;          register struct ipqent *q, *p;
   
         IPQ_LOCK_CHECK();          IPQ_LOCK_CHECK();
   
Line 952  ip_freef(fp)
Line 858  ip_freef(fp)
         }          }
         LIST_REMOVE(fp, ipq_q);          LIST_REMOVE(fp, ipq_q);
         FREE(fp, M_FTABLE);          FREE(fp, M_FTABLE);
         ip_nfragpackets--;  
 }  }
   
 /*  /*
Line 963  ip_freef(fp)
Line 868  ip_freef(fp)
 void  void
 ip_slowtimo()  ip_slowtimo()
 {  {
         struct ipq *fp, *nfp;          register struct ipq *fp, *nfp;
         int s = splsoftnet();          int s = splsoftnet();
   
         IPQ_LOCK();          IPQ_LOCK();
Line 974  ip_slowtimo()
Line 879  ip_slowtimo()
                         ip_freef(fp);                          ip_freef(fp);
                 }                  }
         }          }
         /*  
          * If we are over the maximum number of fragments  
          * (due to the limit being lowered), drain off  
          * enough to get down to the new limit.  
          */  
         if (ip_maxfragpackets < 0)  
                 ;  
         else {  
                 while (ip_nfragpackets > ip_maxfragpackets && ipq.lh_first)  
                         ip_freef(ipq.lh_first);  
         }  
         IPQ_UNLOCK();          IPQ_UNLOCK();
 #ifdef GATEWAY  #ifdef GATEWAY
         ipflow_slowtimo();          ipflow_slowtimo();
Line 1025  int
Line 919  int
 ip_dooptions(m)  ip_dooptions(m)
         struct mbuf *m;          struct mbuf *m;
 {  {
         struct ip *ip = mtod(m, struct ip *);          register struct ip *ip = mtod(m, struct ip *);
         u_char *cp, *cp0;          register u_char *cp;
         struct ip_timestamp *ipt;          register struct ip_timestamp *ipt;
         struct in_ifaddr *ia;          register struct in_ifaddr *ia;
         int opt, optlen, cnt, off, code, type = ICMP_PARAMPROB, forward = 0;          int opt, optlen, cnt, off, code, type = ICMP_PARAMPROB, forward = 0;
         struct in_addr dst;          struct in_addr *sin, dst;
         n_time ntime;          n_time ntime;
   
         dst = ip->ip_dst;          dst = ip->ip_dst;
Line 1043  ip_dooptions(m)
Line 937  ip_dooptions(m)
                 if (opt == IPOPT_NOP)                  if (opt == IPOPT_NOP)
                         optlen = 1;                          optlen = 1;
                 else {                  else {
                         if (cnt < IPOPT_OLEN + sizeof(*cp)) {  
                                 code = &cp[IPOPT_OLEN] - (u_char *)ip;  
                                 goto bad;  
                         }  
                         optlen = cp[IPOPT_OLEN];                          optlen = cp[IPOPT_OLEN];
                         if (optlen < IPOPT_OLEN + sizeof(*cp) || optlen > cnt) {                          if (optlen <= 0 || optlen > cnt) {
                                 code = &cp[IPOPT_OLEN] - (u_char *)ip;                                  code = &cp[IPOPT_OLEN] - (u_char *)ip;
                                 goto bad;                                  goto bad;
                         }                          }
Line 1074  ip_dooptions(m)
Line 964  ip_dooptions(m)
                                 code = ICMP_UNREACH_NET_PROHIB;                                  code = ICMP_UNREACH_NET_PROHIB;
                                 goto bad;                                  goto bad;
                         }                          }
                         if (optlen < IPOPT_OFFSET + sizeof(*cp)) {  
                                 code = &cp[IPOPT_OLEN] - (u_char *)ip;  
                                 goto bad;  
                         }  
                         if ((off = cp[IPOPT_OFFSET]) < IPOPT_MINOFF) {                          if ((off = cp[IPOPT_OFFSET]) < IPOPT_MINOFF) {
                                 code = &cp[IPOPT_OFFSET] - (u_char *)ip;                                  code = &cp[IPOPT_OFFSET] - (u_char *)ip;
                                 goto bad;                                  goto bad;
Line 1097  ip_dooptions(m)
Line 983  ip_dooptions(m)
                                 break;                                  break;
                         }                          }
                         off--;                  /* 0 origin */                          off--;                  /* 0 origin */
                         if ((off + sizeof(struct in_addr)) > optlen) {                          if (off > optlen - sizeof(struct in_addr)) {
                                 /*                                  /*
                                  * End of source route.  Should be for us.                                   * End of source route.  Should be for us.
                                  */                                   */
Line 1109  ip_dooptions(m)
Line 995  ip_dooptions(m)
                          */                           */
                         bcopy((caddr_t)(cp + off), (caddr_t)&ipaddr.sin_addr,                          bcopy((caddr_t)(cp + off), (caddr_t)&ipaddr.sin_addr,
                             sizeof(ipaddr.sin_addr));                              sizeof(ipaddr.sin_addr));
                         if (opt == IPOPT_SSRR)                          if (opt == IPOPT_SSRR) {
                                 ia = ifatoia(ifa_ifwithaddr(sintosa(&ipaddr)));  #define INA     struct in_ifaddr *
                         else  #define SA      struct sockaddr *
                               ia = (INA)ifa_ifwithladdr((SA)&ipaddr);
                           } else
                                 ia = ip_rtaddr(ipaddr.sin_addr);                                  ia = ip_rtaddr(ipaddr.sin_addr);
                         if (ia == 0) {                          if (ia == 0) {
                                 type = ICMP_UNREACH;                                  type = ICMP_UNREACH;
Line 1129  ip_dooptions(m)
Line 1017  ip_dooptions(m)
                         break;                          break;
   
                 case IPOPT_RR:                  case IPOPT_RR:
                         if (optlen < IPOPT_OFFSET + sizeof(*cp)) {  
                                 code = &cp[IPOPT_OLEN] - (u_char *)ip;  
                                 goto bad;  
                         }  
                         if ((off = cp[IPOPT_OFFSET]) < IPOPT_MINOFF) {                          if ((off = cp[IPOPT_OFFSET]) < IPOPT_MINOFF) {
                                 code = &cp[IPOPT_OFFSET] - (u_char *)ip;                                  code = &cp[IPOPT_OFFSET] - (u_char *)ip;
                                 goto bad;                                  goto bad;
Line 1141  ip_dooptions(m)
Line 1025  ip_dooptions(m)
                          * If no space remains, ignore.                           * If no space remains, ignore.
                          */                           */
                         off--;                  /* 0 origin */                          off--;                  /* 0 origin */
                         if ((off + sizeof(struct in_addr)) > optlen)                          if (off > optlen - sizeof(struct in_addr))
                                 break;                                  break;
                         bcopy((caddr_t)(&ip->ip_dst), (caddr_t)&ipaddr.sin_addr,                          bcopy((caddr_t)(&ip->ip_dst), (caddr_t)&ipaddr.sin_addr,
                             sizeof(ipaddr.sin_addr));                              sizeof(ipaddr.sin_addr));
Line 1149  ip_dooptions(m)
Line 1033  ip_dooptions(m)
                          * locate outgoing interface; if we're the destination,                           * locate outgoing interface; if we're the destination,
                          * use the incoming interface (should be same).                           * use the incoming interface (should be same).
                          */                           */
                         if ((ia = ifatoia(ifa_ifwithaddr(sintosa(&ipaddr))))                          if ((ia = (INA)ifa_ifwithaddr((SA)&ipaddr)) == 0 &&
                             == NULL &&                              (ia = ip_rtaddr(ipaddr.sin_addr)) == 0) {
                             (ia = ip_rtaddr(ipaddr.sin_addr)) == NULL) {  
                                 type = ICMP_UNREACH;                                  type = ICMP_UNREACH;
                                 code = ICMP_UNREACH_HOST;                                  code = ICMP_UNREACH_HOST;
                                 goto bad;                                  goto bad;
Line 1164  ip_dooptions(m)
Line 1047  ip_dooptions(m)
                 case IPOPT_TS:                  case IPOPT_TS:
                         code = cp - (u_char *)ip;                          code = cp - (u_char *)ip;
                         ipt = (struct ip_timestamp *)cp;                          ipt = (struct ip_timestamp *)cp;
                         if (ipt->ipt_len < 4 || ipt->ipt_len > 40) {                          if (ipt->ipt_len < 5)
                                 code = (u_char *)&ipt->ipt_len - (u_char *)ip;  
                                 goto bad;  
                         }  
                         if (ipt->ipt_ptr < 5) {  
                                 code = (u_char *)&ipt->ipt_ptr - (u_char *)ip;  
                                 goto bad;                                  goto bad;
                         }  
                         if (ipt->ipt_ptr > ipt->ipt_len - sizeof (int32_t)) {                          if (ipt->ipt_ptr > ipt->ipt_len - sizeof (int32_t)) {
                                 if (++ipt->ipt_oflw == 0) {                                  if (++ipt->ipt_oflw == 0)
                                         code = (u_char *)&ipt->ipt_ptr -  
                                             (u_char *)ip;  
                                         goto bad;                                          goto bad;
                                 }  
                                 break;                                  break;
                         }                          }
                         cp0 = (cp + ipt->ipt_ptr - 1);                          sin = (struct in_addr *)(cp + ipt->ipt_ptr - 1);
                         switch (ipt->ipt_flg) {                          switch (ipt->ipt_flg) {
   
                         case IPOPT_TS_TSONLY:                          case IPOPT_TS_TSONLY:
Line 1188  ip_dooptions(m)
Line 1062  ip_dooptions(m)
   
                         case IPOPT_TS_TSANDADDR:                          case IPOPT_TS_TSANDADDR:
                                 if (ipt->ipt_ptr - 1 + sizeof(n_time) +                                  if (ipt->ipt_ptr - 1 + sizeof(n_time) +
                                     sizeof(struct in_addr) > ipt->ipt_len) {                                      sizeof(struct in_addr) > ipt->ipt_len)
                                         code = (u_char *)&ipt->ipt_ptr -  
                                             (u_char *)ip;  
                                         goto bad;                                          goto bad;
                                 }  
                                 ipaddr.sin_addr = dst;                                  ipaddr.sin_addr = dst;
                                 ia = ifatoia(ifaof_ifpforaddr(sintosa(&ipaddr),                                  ia = (INA)ifaof_ifpforaddr((SA)&ipaddr,
                                     m->m_pkthdr.rcvif));                                                              m->m_pkthdr.rcvif);
                                 if (ia == 0)                                  if (ia == 0)
                                         continue;                                          continue;
                                 bcopy(&ia->ia_addr.sin_addr,                                  bcopy((caddr_t)&ia->ia_addr.sin_addr,
                                     cp0, sizeof(struct in_addr));                                      (caddr_t)sin, sizeof(struct in_addr));
                                 ipt->ipt_ptr += sizeof(struct in_addr);                                  ipt->ipt_ptr += sizeof(struct in_addr);
                                 break;                                  break;
   
                         case IPOPT_TS_PRESPEC:                          case IPOPT_TS_PRESPEC:
                                 if (ipt->ipt_ptr - 1 + sizeof(n_time) +                                  if (ipt->ipt_ptr - 1 + sizeof(n_time) +
                                     sizeof(struct in_addr) > ipt->ipt_len) {                                      sizeof(struct in_addr) > ipt->ipt_len)
                                         code = (u_char *)&ipt->ipt_ptr -  
                                             (u_char *)ip;  
                                         goto bad;                                          goto bad;
                                 }                                  bcopy((caddr_t)sin, (caddr_t)&ipaddr.sin_addr,
                                 bcopy(cp0, &ipaddr.sin_addr,  
                                     sizeof(struct in_addr));                                      sizeof(struct in_addr));
                                 if (ifatoia(ifa_ifwithaddr(sintosa(&ipaddr)))                                  if (ifa_ifwithaddr((SA)&ipaddr) == 0)
                                     == NULL)  
                                         continue;                                          continue;
                                 ipt->ipt_ptr += sizeof(struct in_addr);                                  ipt->ipt_ptr += sizeof(struct in_addr);
                                 break;                                  break;
   
                         default:                          default:
                                 /* XXX can't take &ipt->ipt_flg */  
                                 code = (u_char *)&ipt->ipt_ptr -  
                                     (u_char *)ip + 1;  
                                 goto bad;                                  goto bad;
                         }                          }
                         ntime = iptime();                          ntime = iptime();
                         cp0 = (u_char *) &ntime; /* XXX grumble, GCC... */                          bcopy((caddr_t)&ntime, (caddr_t)cp + ipt->ipt_ptr - 1,
                         bcopy(cp0, (caddr_t)cp + ipt->ipt_ptr - 1,  
                             sizeof(n_time));                              sizeof(n_time));
                         ipt->ipt_ptr += sizeof(n_time);                          ipt->ipt_ptr += sizeof(n_time);
                 }                  }
Line 1255  struct in_ifaddr *
Line 1118  struct in_ifaddr *
 ip_rtaddr(dst)  ip_rtaddr(dst)
          struct in_addr dst;           struct in_addr dst;
 {  {
         struct sockaddr_in *sin;          register struct sockaddr_in *sin;
   
         sin = satosin(&ipforward_rt.ro_dst);          sin = satosin(&ipforward_rt.ro_dst);
   
Line 1306  save_rte(option, dst)
Line 1169  save_rte(option, dst)
 struct mbuf *  struct mbuf *
 ip_srcroute()  ip_srcroute()
 {  {
         struct in_addr *p, *q;          register struct in_addr *p, *q;
         struct mbuf *m;          register struct mbuf *m;
   
         if (ip_nhops == 0)          if (ip_nhops == 0)
                 return ((struct mbuf *)0);                  return ((struct mbuf *)0);
Line 1376  ip_srcroute()
Line 1239  ip_srcroute()
  */   */
 void  void
 ip_stripoptions(m, mopt)  ip_stripoptions(m, mopt)
         struct mbuf *m;          register struct mbuf *m;
         struct mbuf *mopt;          struct mbuf *mopt;
 {  {
         int i;          register int i;
         struct ip *ip = mtod(m, struct ip *);          struct ip *ip = mtod(m, struct ip *);
         caddr_t opts;          register caddr_t opts;
         int olen;          int olen;
   
         olen = (ip->ip_hl << 2) - sizeof (struct ip);          olen = (ip->ip_hl << 2) - sizeof (struct ip);
Line 1423  ip_forward(m, srcrt)
Line 1286  ip_forward(m, srcrt)
         struct mbuf *m;          struct mbuf *m;
         int srcrt;          int srcrt;
 {  {
         struct ip *ip = mtod(m, struct ip *);          register struct ip *ip = mtod(m, struct ip *);
         struct sockaddr_in *sin;          register struct sockaddr_in *sin;
         struct rtentry *rt;          register struct rtentry *rt;
         int error, type = 0, code = 0;          int error, type = 0, code = 0;
         struct mbuf *mcopy;          struct mbuf *mcopy;
         n_long dest;          n_long dest;
Line 1474  ip_forward(m, srcrt)
Line 1337  ip_forward(m, srcrt)
         /*          /*
          * Save at most 68 bytes of the packet in case           * Save at most 68 bytes of the packet in case
          * we need to generate an ICMP message to the src.           * we need to generate an ICMP message to the src.
          * Pullup to avoid sharing mbuf cluster between m and mcopy.  
          */           */
         mcopy = m_copym(m, 0, imin((int)ip->ip_len, 68), M_DONTWAIT);          mcopy = m_copy(m, 0, imin((int)ip->ip_len, 68));
         if (mcopy)  
                 mcopy = m_pullup(mcopy, ip->ip_hl << 2);  
   
         /*          /*
          * If forwarding packet using same interface that it came in on,           * If forwarding packet using same interface that it came in on,
Line 1514  ip_forward(m, srcrt)
Line 1374  ip_forward(m, srcrt)
         }          }
   
 #ifdef IPSEC  #ifdef IPSEC
         /* Don't lookup socket in forwading case */          m->m_pkthdr.rcvif = NULL;
         (void)ipsec_setsocket(m, NULL);  #endif /*IPSEC*/
 #endif  
         error = ip_output(m, (struct mbuf *)0, &ipforward_rt,          error = ip_output(m, (struct mbuf *)0, &ipforward_rt,
             (IP_FORWARDING | (ip_directedbcast ? IP_ALLOWBROADCAST : 0)), 0);              (IP_FORWARDING | (ip_directedbcast ? IP_ALLOWBROADCAST : 0)), 0);
         if (error)          if (error)
Line 1571  ip_forward(m, srcrt)
Line 1430  ip_forward(m, srcrt)
                 if (ipforward_rt.ro_rt) {                  if (ipforward_rt.ro_rt) {
                         struct secpolicy *sp;                          struct secpolicy *sp;
                         int ipsecerror;                          int ipsecerror;
                         size_t ipsechdr;                          int ipsechdr;
                         struct route *ro;                          struct route *ro;
   
                         sp = ipsec4_getpolicybyaddr(mcopy,                          sp = ipsec4_getpolicybyaddr(mcopy,
                                                     IPSEC_DIR_OUTBOUND,                                                      IP_FORWARDING,
                                                     IP_FORWARDING,                                                      &ipsecerror);
                                                     &ipsecerror);  
   
                         if (sp == NULL)                          if (sp == NULL)
                                 destifp = ipforward_rt.ro_rt->rt_ifp;                                  destifp = ipforward_rt.ro_rt->rt_ifp;
                         else {                          else {
                                 /* count IPsec header size */                                  /* count IPsec header size */
                                 ipsechdr = ipsec4_hdrsiz(mcopy,                                  ipsechdr = ipsec4_hdrsiz(mcopy, NULL);
                                                          IPSEC_DIR_OUTBOUND,  
                                                          NULL);  
   
                                 /*                                  /*
                                  * find the correct route for outer IPv4                                   * find the correct route for outer IPv4
Line 1598  ip_forward(m, srcrt)
Line 1454  ip_forward(m, srcrt)
                                 /*XXX*/                                  /*XXX*/
                                 destifp = NULL;                                  destifp = NULL;
                                 if (sp->req != NULL                                  if (sp->req != NULL
                                  && sp->req->sav != NULL                                   && sp->req->sa != NULL) {
                                  && sp->req->sav->sah != NULL) {                                          ro = &sp->req->sa->saidx->sa_route;
                                         ro = &sp->req->sav->sah->sa_route;  
                                         if (ro->ro_rt && ro->ro_rt->rt_ifp) {                                          if (ro->ro_rt && ro->ro_rt->rt_ifp) {
                                                 dummyifp.if_mtu =                                                  dummyifp.if_mtu =
                                                     ro->ro_rt->rt_ifp->if_mtu;                                                      ro->ro_rt->rt_ifp->if_mtu;
Line 1626  ip_forward(m, srcrt)
Line 1481  ip_forward(m, srcrt)
   
 void  void
 ip_savecontrol(inp, mp, ip, m)  ip_savecontrol(inp, mp, ip, m)
         struct inpcb *inp;          register struct inpcb *inp;
         struct mbuf **mp;          register struct mbuf **mp;
         struct ip *ip;          register struct ip *ip;
         struct mbuf *m;          register struct mbuf *m;
 {  {
   
         if (inp->inp_socket->so_options & SO_TIMESTAMP) {          if (inp->inp_socket->so_options & SO_TIMESTAMP) {
Line 1744  ip_sysctl(name, namelen, oldp, oldlenp, 
Line 1599  ip_sysctl(name, namelen, oldp, oldlenp, 
         case IPCTL_ANONPORTMIN:          case IPCTL_ANONPORTMIN:
                 old = anonportmin;                  old = anonportmin;
                 error = sysctl_int(oldp, oldlenp, newp, newlen, &anonportmin);                  error = sysctl_int(oldp, oldlenp, newp, newlen, &anonportmin);
                 if (anonportmin >= anonportmax || anonportmin < 0                  if (anonportmin >= anonportmax || anonportmin > 65535
                     || anonportmin > 65535  
 #ifndef IPNOPRIVPORTS  #ifndef IPNOPRIVPORTS
                     || anonportmin < IPPORT_RESERVED                      || anonportmin < IPPORT_RESERVED
 #endif  #endif
Line 1757  ip_sysctl(name, namelen, oldp, oldlenp, 
Line 1611  ip_sysctl(name, namelen, oldp, oldlenp, 
         case IPCTL_ANONPORTMAX:          case IPCTL_ANONPORTMAX:
                 old = anonportmax;                  old = anonportmax;
                 error = sysctl_int(oldp, oldlenp, newp, newlen, &anonportmax);                  error = sysctl_int(oldp, oldlenp, newp, newlen, &anonportmax);
                 if (anonportmin >= anonportmax || anonportmax < 0                  if (anonportmin >= anonportmax || anonportmax > 65535
                     || anonportmax > 65535  
 #ifndef IPNOPRIVPORTS  #ifndef IPNOPRIVPORTS
                     || anonportmax < IPPORT_RESERVED                      || anonportmax < IPPORT_RESERVED
 #endif  #endif
Line 1796  ip_sysctl(name, namelen, oldp, oldlenp, 
Line 1649  ip_sysctl(name, namelen, oldp, oldlenp, 
                                   &ip_gif_ttl));                                    &ip_gif_ttl));
 #endif  #endif
   
 #ifndef IPNOPRIVPORTS  
         case IPCTL_LOWPORTMIN:  
                 old = lowportmin;  
                 error = sysctl_int(oldp, oldlenp, newp, newlen, &lowportmin);  
                 if (lowportmin >= lowportmax  
                     || lowportmin > IPPORT_RESERVEDMAX  
                     || lowportmin < IPPORT_RESERVEDMIN  
                     ) {  
                         lowportmin = old;  
                         return (EINVAL);  
                 }  
                 return (error);  
         case IPCTL_LOWPORTMAX:  
                 old = lowportmax;  
                 error = sysctl_int(oldp, oldlenp, newp, newlen, &lowportmax);  
                 if (lowportmin >= lowportmax  
                     || lowportmax > IPPORT_RESERVEDMAX  
                     || lowportmax < IPPORT_RESERVEDMIN  
                     ) {  
                         lowportmax = old;  
                         return (EINVAL);  
                 }  
                 return (error);  
 #endif  
   
         case IPCTL_MAXFRAGPACKETS:  
                 return (sysctl_int(oldp, oldlenp, newp, newlen,  
                     &ip_maxfragpackets));  
   
         default:          default:
                 return (EOPNOTSUPP);                  return (EOPNOTSUPP);
         }          }

Legend:
Removed from v.1.93.2.8  
changed lines
  Added in v.1.94

CVSweb <webmaster@jp.NetBSD.org>