[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.246.2.1 and 1.247

version 1.246.2.1, 2007/07/11 20:11:23 version 1.247, 2007/03/24 00:27:58
Line 429  ip_init(void)
Line 429  ip_init(void)
             M_WAITOK, &in_multihash);              M_WAITOK, &in_multihash);
         ip_mtudisc_timeout_q = rt_timer_queue_create(ip_mtudisc_timeout);          ip_mtudisc_timeout_q = rt_timer_queue_create(ip_mtudisc_timeout);
 #ifdef GATEWAY  #ifdef GATEWAY
         ipflow_init(ip_hashsize);          ipflow_init();
 #endif  #endif
   
 #ifdef PFIL_HOOKS  #ifdef PFIL_HOOKS
Line 1674  bad:
Line 1674  bad:
 struct in_ifaddr *  struct in_ifaddr *
 ip_rtaddr(struct in_addr dst)  ip_rtaddr(struct in_addr dst)
 {  {
         struct rtentry *rt;          if (!in_hosteq(dst, satocsin(rtcache_getdst(&ipforward_rt))->sin_addr))
         union {                  rtcache_free(&ipforward_rt);
                 struct sockaddr         dst;          else
                 struct sockaddr_in      dst4;                  rtcache_check(&ipforward_rt);
         } u;  
           if (ipforward_rt.ro_rt == NULL) {
         sockaddr_in_init(&u.dst4, &dst, 0);                  struct sockaddr_in *sin = satosin(&ipforward_rt.ro_dst);
   
         if ((rt = rtcache_lookup(&ipforward_rt, &u.dst)) == NULL)                  sin->sin_family = AF_INET;
                 return NULL;                  sin->sin_len = sizeof(*sin);
                   sin->sin_addr = dst;
         return ifatoia(rt->rt_ifa);  
                   rtcache_init(&ipforward_rt);
                   if (ipforward_rt.ro_rt == NULL)
                           return NULL;
           }
           return ifatoia(ipforward_rt.ro_rt->rt_ifa);
 }  }
   
 /*  /*
Line 1836  ip_forward(struct mbuf *m, int srcrt)
Line 1841  ip_forward(struct mbuf *m, int srcrt)
         int error, type = 0, code = 0, destmtu = 0;          int error, type = 0, code = 0, destmtu = 0;
         struct mbuf *mcopy;          struct mbuf *mcopy;
         n_long dest;          n_long dest;
         union {  
                 struct sockaddr         dst;  
                 struct sockaddr_in      dst4;  
         } u;  
   
         /*          /*
          * We are now in the output path.           * We are now in the output path.
Line 1868  ip_forward(struct mbuf *m, int srcrt)
Line 1869  ip_forward(struct mbuf *m, int srcrt)
                 return;                  return;
         }          }
   
         sockaddr_in_init(&u.dst4, &ip->ip_dst, 0);          if (!in_hosteq(ip->ip_dst,
         if ((rt = rtcache_lookup(&ipforward_rt, &u.dst)) == NULL) {                         satocsin(rtcache_getdst(&ipforward_rt))->sin_addr))
                 icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_NET, dest, 0);                  rtcache_free(&ipforward_rt);
                 return;          else
                   rtcache_check(&ipforward_rt);
           if (ipforward_rt.ro_rt == NULL) {
                   struct sockaddr_in *sin = satosin(&ipforward_rt.ro_dst);
   
                   sin->sin_family = AF_INET;
                   sin->sin_len = sizeof(*sin);
                   sin->sin_addr = ip->ip_dst;
   
                   rtcache_init(&ipforward_rt);
                   if (ipforward_rt.ro_rt == NULL) {
                           icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_NET, dest, 0);
                           return;
                   }
         }          }
           rt = ipforward_rt.ro_rt;
   
         /*          /*
          * Save at most 68 bytes of the packet in case           * Save at most 68 bytes of the packet in case
Line 2162  sysctl_net_inet_ip_maxflows(SYSCTLFN_ARG
Line 2177  sysctl_net_inet_ip_maxflows(SYSCTLFN_ARG
   
         return (0);          return (0);
 }  }
   
 static int  
 sysctl_net_inet_ip_hashsize(SYSCTLFN_ARGS)  
 {  
         int error, tmp;  
         struct sysctlnode node;  
   
         node = *rnode;  
         tmp = ip_hashsize;  
         node.sysctl_data = &tmp;  
         error = sysctl_lookup(SYSCTLFN_CALL(&node));  
         if (error || newp == NULL)  
                 return (error);  
   
         if ((tmp & (tmp - 1)) == 0 && tmp != 0) {  
                 /*  
                  * Can only fail due to malloc()  
                  */  
                 if (ipflow_invalidate_all(tmp))  
                         return ENOMEM;  
         } else {  
                 /*  
                  * EINVAL if not a power of 2  
                  */  
                 return EINVAL;  
         }  
   
         return (0);  
 }  
 #endif /* GATEWAY */  #endif /* GATEWAY */
   
   
Line 2312  SYSCTL_SETUP(sysctl_net_inet_ip_setup, "
Line 2298  SYSCTL_SETUP(sysctl_net_inet_ip_setup, "
                        sysctl_net_inet_ip_maxflows, 0, &ip_maxflows, 0,                         sysctl_net_inet_ip_maxflows, 0, &ip_maxflows, 0,
                        CTL_NET, PF_INET, IPPROTO_IP,                         CTL_NET, PF_INET, IPPROTO_IP,
                        IPCTL_MAXFLOWS, CTL_EOL);                         IPCTL_MAXFLOWS, CTL_EOL);
         sysctl_createv(clog, 0, NULL, NULL,  
                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,  
                         CTLTYPE_INT, "hashsize",  
                         SYSCTL_DESCR("Size of hash table for fast forwarding (IPv4)"),  
                         sysctl_net_inet_ip_hashsize, 0, &ip_hashsize, 0,  
                         CTL_NET, PF_INET, IPPROTO_IP,  
                         CTL_CREATE, CTL_EOL);  
 #endif /* GATEWAY */  #endif /* GATEWAY */
         sysctl_createv(clog, 0, NULL, NULL,          sysctl_createv(clog, 0, NULL, NULL,
                        CTLFLAG_PERMANENT|CTLFLAG_READWRITE,                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,

Legend:
Removed from v.1.246.2.1  
changed lines
  Added in v.1.247

CVSweb <webmaster@jp.NetBSD.org>