/* * Given a host-order address, calculate client's default net mask. * Consult netmasks database to see if net is further subnetted. * We'll only snag the first netmask that matches our criteria. * We return the resultant netmask in host order. */ void get_netmask4(const struct in_addr *n_addrp, struct in_addr *s_addrp) { struct in_addr hp, tp; /* * First check if VLSM is in use. */ hp.s_addr = htonl(n_addrp->s_addr); if (getnetmaskbyaddr(hp, &tp) == 0) { s_addrp->s_addr = ntohl(tp.s_addr); return; } /* * Fall back on standard classed networks. */ if (IN_CLASSA(n_addrp->s_addr)) s_addrp->s_addr = IN_CLASSA_NET; else if (IN_CLASSB(n_addrp->s_addr)) s_addrp->s_addr = IN_CLASSB_NET; else if (IN_CLASSC(n_addrp->s_addr)) s_addrp->s_addr = IN_CLASSC_NET; else s_addrp->s_addr = IN_CLASSE_NET; }
/* This calculates the netmask that we should use for static routes. * This IS different from the calculation used to calculate the netmask * for an interface address. */ static uint32_t route_netmask(uint32_t ip_in) { /* used to be unsigned long - check if error */ uint32_t p = ntohl(ip_in); uint32_t t; if (IN_CLASSA(p)) t = ~IN_CLASSA_NET; else { if (IN_CLASSB(p)) t = ~IN_CLASSB_NET; else { if (IN_CLASSC(p)) t = ~IN_CLASSC_NET; else t = 0; } } while (t & p) t >>= 1; return (htonl(~t)); }
unsigned long in_netof(struct in_addr in) { unsigned long i, net; struct in_ifaddr *ia; /* Setup locals */ i = ntohl(in.s_addr); /* Get network number */ if ( IN_CLASSA(i) ) net = i & IN_CLASSA_NET; else if ( IN_CLASSB(i) ) net = i & IN_CLASSB_NET; else if ( IN_CLASSC(i) ) net = i & IN_CLASSC_NET; else if ( IN_CLASSD(i) ) net = i & IN_CLASSD_NET; else return 0; /* Check if subnet */ for (ia = in_ifaddr; ia != NULL; ia = ia->ia_next) if (net == ia->ia_net) return (i & ia->ia_subnetmask); return net; }
/* * Return user specified netmask, modified by any mask we might determine * for address `addr' (in network byte order). * Here we scan through the system's list of interfaces, looking for * any non-point-to-point interfaces which might appear to be on the same * network as `addr'. If we find any, we OR in their netmask to the * user-specified netmask. */ uint32_t GetMask( uint32_t addr) { uint32_t mask, nmask, ina; struct ifreq *ifr, *ifend, ifreq; struct ifconf ifc; struct ifreq ifs[MAX_IFS]; addr = ntohl(addr); if (IN_CLASSA(addr)) /* determine network mask for address class */ nmask = IN_CLASSA_NET; else if (IN_CLASSB(addr)) nmask = IN_CLASSB_NET; else nmask = IN_CLASSC_NET; /* class D nets are disallowed by bad_ip_adrs */ mask = netmask | htonl(nmask); /* * Scan through the system's network interfaces. */ ifc.ifc_len = sizeof(ifs); ifc.ifc_req = ifs; if (ioctl(sockfd, SIOCGIFCONF, &ifc) < 0) { warn("ioctl(SIOCGIFCONF): %m"); return mask; } ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len); for (ifr = ifc.ifc_req; ifr < ifend; ifr = (struct ifreq *) ((char *)&ifr->ifr_addr + ifr->ifr_addr.sa_len)) { /* * Check the interface's internet address. */ if (ifr->ifr_addr.sa_family != AF_INET) continue; ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr; if ((ntohl(ina) & nmask) != (addr & nmask)) continue; /* * Check that the interface is up, and not point-to-point or loopback. */ strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name)); if (ioctl(sockfd, SIOCGIFFLAGS, &ifreq) < 0) continue; if ((ifreq.ifr_flags & (IFF_UP|IFF_POINTOPOINT|IFF_LOOPBACK)) != IFF_UP) continue; /* * Get its netmask and OR it into our mask. */ if (ioctl(sockfd, SIOCGIFNETMASK, &ifreq) < 0) continue; mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr; } return mask; }
/// This function uses Windows Sockets macros to get standard class information. It /// does not know about subnetting or any classes beyond class C. TINetSocketAddress::TINetClass TINetSocketAddress::GetClass() const { if (IN_CLASSA(GetNetworkAddress())) return ClassA; if (IN_CLASSB(GetNetworkAddress())) return ClassB; if (IN_CLASSC(GetNetworkAddress())) return ClassC; return ClassUnknown; }
/* XXX - should really support CIDR which means explicit masks always. */ static u_int32_t net_mask(struct in_addr in) /*!< XXX - should really use system's version of this */ { u_int32_t i = ntohl(in.s_addr); if (IN_CLASSA(i)) return (htonl(IN_CLASSA_NET)); else if (IN_CLASSB(i)) return (htonl(IN_CLASSB_NET)); return (htonl(IN_CLASSC_NET)); }
/* * Return the local network address portion of an * internet address; handles class a/b/c network * number formats. */ in_addr_t inet_lnaof(struct in_addr in) { in_addr_t i = ntohl(in.s_addr); if (IN_CLASSA(i)) return (i & IN_CLASSA_HOST); else if (IN_CLASSB(i)) return (i & IN_CLASSB_HOST); else return (i & IN_CLASSC_HOST); }
static int config_ip_prefix(struct in_addr *addr) { if (IN_CLASSA(addr->s_addr)) return 32 - IN_CLASSA_NSHIFT; if (IN_CLASSB(addr->s_addr)) return 32 - IN_CLASSB_NSHIFT; if (IN_CLASSC(addr->s_addr)) return 32 - IN_CLASSC_NSHIFT; return 0; }
static uint32_t inet_class_netmask(uint32_t ip) { ip = ntohl(ip); if (IN_CLASSA(ip)) return htonl(IN_CLASSA_NET); if (IN_CLASSB(ip)) return htonl(IN_CLASSB_NET); if (IN_CLASSC(ip)) return htonl(IN_CLASSC_NET); return INADDR_ANY; }
//--------------------------------------------------------------------------- // Search the entity with the IPv4 address 'addr' struct cx_entity *nasmt_CLASS_cx4(struct sk_buff *skb, unsigned char dscp, int *paddr_type, unsigned char *cx_index) { //--------------------------------------------------------------------------- unsigned char cxi; uint32_t daddr; struct cx_entity *cx=NULL; struct classifier_entity *pclassifier=NULL; struct in_addr masked_addr; #ifdef NAS_DEBUG_CLASS printk("nasmt_CLASS_cx4: begin\n"); #endif if (skb!=NULL) { daddr = ((struct iphdr*)(skb_network_header(skb)))->daddr; if (daddr != INADDR_ANY) { #ifdef NAS_DEBUG_CLASS printk("nasmt_CLASS_cx4: SOURCE ADDR %d.%d.%d.%d",NIPADDR(ip_hdr(skb)->saddr)); printk(" DEST ADDR %d.%d.%d.%d\n",NIPADDR(ip_hdr(skb)->daddr)); #endif if (ipv4_is_multicast(ip_hdr(skb)->daddr)) { // TO BE CHECKED *paddr_type = NAS_IPV4_ADDR_MC_SIGNALLING; } else { if (ipv4_is_lbcast(ip_hdr(skb)->daddr)) { // TO BE CHECKED *paddr_type = NAS_IPV4_ADDR_BROADCAST; } else { if (IN_CLASSA(ip_hdr(skb)->daddr) || IN_CLASSB(ip_hdr(skb)->daddr) || IN_CLASSC(ip_hdr(skb)->daddr)) { *paddr_type = NAS_IPV4_ADDR_UNICAST; cxi = 0; (*cx_index)++; pclassifier = gpriv->cx[cxi].sclassifier[dscp]; while (pclassifier!=NULL) { // verify that this is an IPv4 classifier if ((pclassifier->version == NAS_VERSION_4) || (pclassifier->version == NAS_VERSION_DEFAULT)) { nasmt_create_mask_ipv4_addr(&masked_addr, pclassifier->dplen); if (IN_ARE_ADDR_MASKED_EQUAL(&ip_hdr(skb)->daddr, &(pclassifier->daddr.ipv4), &masked_addr)) { #ifdef NAS_DEBUG_CLASS printk("nasmt_CLASS_cx4: IP MASK MATCHED: found cx %d: %d.%d.%d.%d/%d\n",cxi, NIPADDR(pclassifier->daddr.ipv4), pclassifier->dplen); #endif return &gpriv->cx[cxi]; } } // goto to next classification rule for the connection pclassifier = pclassifier->next; } } else { *paddr_type = NAS_IPV4_ADDR_UNKNOWN; } } } } } return cx; }
/* * Return the local network address portion of an * internet address; handles class a/b/c network * number formats. */ int inet_lnaof(struct in_addr in) { u_long i = ntohl(in.s_addr); if (IN_CLASSA(i)) return ((i)&IN_CLASSA_HOST); else if (IN_CLASSB(i)) return ((i)&IN_CLASSB_HOST); else return ((i)&IN_CLASSC_HOST); }
_WCRTLINK in_addr_t inet_lnaof( struct in_addr __in ) { unsigned long a = ntohl( __in.s_addr ); if( IN_CLASSA( a ) ) return( a & IN_CLASSA_HOST ); if( IN_CLASSB( a ) ) return( a & IN_CLASSB_HOST ); return( a & IN_CLASSC_HOST ); }
/* * Get the netmask of an IP address. This routine is used if * SIOCGIFNETMASK doesn't work. */ u_int32_t ipaddrtonetmask(u_int32_t addr) { if (IN_CLASSA(addr)) return IN_CLASSA_NET; if (IN_CLASSB(addr)) return IN_CLASSB_NET; if (IN_CLASSC(addr)) return IN_CLASSC_NET; error(FATAL, "unknown IP address class: %08X", addr); /* NOTREACHED */ }
static uint32_t forgemask(uint32_t a) { uint32_t m; if (IN_CLASSA(a)) m = IN_CLASSA_NET; else if (IN_CLASSB(a)) m = IN_CLASSB_NET; else m = IN_CLASSC_NET; return (m); }
static u_long forgemask(u_long a) { u_long m; if (IN_CLASSA(a)) m = IN_CLASSA_NET; else if (IN_CLASSB(a)) m = IN_CLASSB_NET; else m = IN_CLASSC_NET; return (m); }
unsigned long inet_lnaof(struct in_addr in) { unsigned long addr = ntohl(in.s_addr); if (IN_CLASSA(addr)) addr &= IN_CLASSA_HOST; else if (IN_CLASSB(addr)) addr &= IN_CLASSB_HOST; else addr &= IN_CLASSC_HOST; return(htonl(addr)); }
int nl_set_ifaddr(struct in_addr ifaddr, struct in_addr bcaddr, int ifindex) { struct { struct ifaddrmsg ifa; struct { struct rtattr rta; struct in_addr addr; } data[3]; } m; memset(&m, 0, sizeof(m)); m.ifa.ifa_family = AF_INET; if (IN_CLASSA(ifaddr.s_addr)) m.ifa.ifa_prefixlen = IN_CLASSA_NSHIFT; else if (IN_CLASSB(ifaddr.s_addr)) m.ifa.ifa_prefixlen = IN_CLASSB_NSHIFT; else if (IN_CLASSC(ifaddr.s_addr)) m.ifa.ifa_prefixlen = IN_CLASSC_NSHIFT; else if (IN_CLASSD(ifaddr.s_addr)) m.ifa.ifa_prefixlen = 0; m.ifa.ifa_prefixlen = 24; m.ifa.ifa_flags = 0; //IFA_F_PERMANENT; m.ifa.ifa_scope = RT_SCOPE_UNIVERSE; m.ifa.ifa_index = ifindex; m.data[0].rta.rta_len = RTA_LENGTH(sizeof(ifaddr)); m.data[0].rta.rta_type = IFA_LOCAL; m.data[0].addr.s_addr = ifaddr.s_addr; m.data[1].rta.rta_len = RTA_LENGTH(sizeof(ifaddr)); m.data[1].rta.rta_type = IFA_ADDRESS; m.data[1].addr.s_addr = ifaddr.s_addr; m.data[2].rta.rta_len = RTA_LENGTH(sizeof(ifaddr)); m.data[2].rta.rta_type = IFA_BROADCAST; m.data[2].addr.s_addr = bcaddr.s_addr; DEBUG(LOG_DEBUG, 0, "Sending new ifaddr %s %s netlink message index=%d", ip_to_str(ifaddr), ip_to_str(bcaddr), ifindex); return nl_create_and_send_msg(rtnlsock, RTM_NEWADDR, &m, sizeof(m)); }
unsigned long get_netmask (unsigned long addr) { unsigned long dst; if (addr == 0) return (0); dst = htonl (addr); if (IN_CLASSA (dst)) return (ntohl (IN_CLASSA_NET)); if (IN_CLASSB (dst)) return (ntohl (IN_CLASSB_NET)); if (IN_CLASSC (dst)) return (ntohl (IN_CLASSC_NET)); return (0); }
//------------------------------------------------------------------------------ // FUNCTION // void buid_ip_set(struct ip_set *setp, // const char *if_name, // unsigned int addrs_ip, // unsigned int addrs_netmask, // unsigned int addrs_broadcast, // unsigned int addrs_gateway, // unsigned int addrs_server, // unsigned char mode, // unsigned char *data ) // // DESCRIPTION // // // PARAMETERS // // // RETURN // // //------------------------------------------------------------------------------ void buid_ip_set(struct ip_set *setp, const char *if_name, unsigned int addrs_ip, unsigned int addrs_netmask, unsigned int addrs_broadcast, unsigned int addrs_gateway, unsigned int addrs_server, unsigned int mtu, unsigned char mode, const char *domain, unsigned char *data ) { if(if_name == NULL) return; memset(setp, 0, sizeof(struct ip_set)); // clear strcpy(setp->ifname, if_name); setp->ip = addrs_ip; if(addrs_netmask || (setp->ip == 0)) setp->netmask = addrs_netmask; else { // if no netmask, set class netmask if (IN_CLASSA(setp->ip)) setp->netmask = IN_CLASSA_HOST; else if (IN_CLASSB(setp->ip)) setp->netmask = IN_CLASSB_HOST; else setp->netmask = IN_CLASSC_HOST; } setp->server_ip = addrs_server; setp->gw_ip = addrs_gateway; if(addrs_broadcast) setp->broad_ip = addrs_broadcast; else setp->broad_ip=((setp->ip)&(setp->netmask))|~(setp->netmask); setp->mtu = mtu; setp->mode = mode; if(domain) strcpy(setp->domain, domain); setp->data = data; }
void start_networking(void) { struct ip_addr ipaddr = { htonl(IF_IPADDR) }; struct ip_addr netmask = { htonl(IF_NETMASK) }; struct ip_addr gw = { 0 }; char *ip = NULL; #ifdef CONFIG_PRINT tprintk("Waiting for network.\n"); #endif dev = init_netfront(NULL, NULL, rawmac, &ip); if (ip) { ipaddr.addr = inet_addr(ip); if (IN_CLASSA(ntohl(ipaddr.addr))) netmask.addr = htonl(IN_CLASSA_NET); else if (IN_CLASSB(ntohl(ipaddr.addr))) netmask.addr = htonl(IN_CLASSB_NET); else if (IN_CLASSC(ntohl(ipaddr.addr))) netmask.addr = htonl(IN_CLASSC_NET); else tprintk("Strange IP %s, leaving netmask to 0.\n", ip); } tprintk("IP %x netmask %x gateway %x.\n", ntohl(ipaddr.addr), ntohl(netmask.addr), ntohl(gw.addr)); #ifdef CONFIG_PRINT tprintk("TCP/IP bringup begins.\n"); #endif netif = xmalloc(struct netif); tcpip_init(tcpip_bringup_finished, netif); netif_add(netif, &ipaddr, &netmask, &gw, rawmac, netif_netfront_init, ip_input); netif_set_default(netif); netif_set_up(netif); down(&tcpip_is_up); #ifdef CONFIG_FRONT tprintk("Network is ready.\n"); #endif }
uint32_t get_netmask(uint32_t addr) { uint32_t dst; if (addr == 0) return 0; dst = htonl(addr); if (IN_CLASSA(dst)) return ntohl(IN_CLASSA_NET); if (IN_CLASSB(dst)) return ntohl(IN_CLASSB_NET); if (IN_CLASSC(dst)) return ntohl(IN_CLASSC_NET); return 0; }
static void natural_mask(struct apattern *pat) { struct in_addr addr; /* Store a host-byte-order copy of pat in a struct in_addr. Icky, * but portable. */ addr.s_addr = ntohl(pat->addr.s_addr); /* This is out of date in the CIDR world, but some people might * still rely on it. */ if (IN_CLASSA(addr.s_addr)) pat->mask.s_addr = htonl(IN_CLASSA_NET); else if (IN_CLASSB(addr.s_addr)) pat->mask.s_addr = htonl(IN_CLASSB_NET); else pat->mask.s_addr = htonl(IN_CLASSC_NET); }
static inline int inet_abc_len(__be32 addr) { int rc = -1; /* Something else, probably a multicast. */ if (ipv4_is_zeronet(addr)) rc = 0; else { __u32 haddr = ntohl(addr); if (IN_CLASSA(haddr)) rc = 8; else if (IN_CLASSB(haddr)) rc = 16; else if (IN_CLASSC(haddr)) rc = 24; } return rc; }
static __inline__ int inet_abc_len(u32 addr) { if (ZERONET(addr)) return 0; addr = ntohl(addr); if (IN_CLASSA(addr)) return 8; if (IN_CLASSB(addr)) return 16; if (IN_CLASSC(addr)) return 24; /* * Something else, probably a multicast. */ return -1; }
static unsigned long getnetmask (unsigned long ip_in) { unsigned long t, p = ntohl (ip_in); if (IN_CLASSA (p)) t = ~IN_CLASSA_NET; else { if (IN_CLASSB (p)) t = ~IN_CLASSB_NET; else { if (IN_CLASSC (p)) t = ~IN_CLASSC_NET; else t = 0; } } while (t & p) t >>= 1; return htonl (~t); }
static struct in_addr networkFromInaddr(struct in_addr a) { struct in_addr b; b.s_addr = ntohl(a.s_addr); #if USE_CLASSFUL if (IN_CLASSC(b.s_addr)) b.s_addr &= IN_CLASSC_NET; else if (IN_CLASSB(b.s_addr)) b.s_addr &= IN_CLASSB_NET; else if (IN_CLASSA(b.s_addr)) b.s_addr &= IN_CLASSA_NET; #else /* use /24 for everything */ b.s_addr &= IN_CLASSC_NET; #endif b.s_addr = htonl(b.s_addr); return b; }
static __inline__ int inet_abc_len(u32 addr) { int rc = -1; /* Something else, probably a multicast. */ if (ZERONET(addr)) rc = 0; else { addr = ntohl(addr); if (IN_CLASSA(addr)) rc = 8; else if (IN_CLASSB(addr)) rc = 16; else if (IN_CLASSC(addr)) rc = 24; } return rc; }
void resume_networking(int cancelled) { //struct netif *netif; struct ip_addr ipaddr = { htonl(IF_IPADDR) }; struct ip_addr netmask = { htonl(IF_NETMASK) }; struct ip_addr gw = { htonl(0xc0a87a01) }; char *ip = NULL; #ifdef CONFIG_PRINT tprintk("Waiting for network.\n"); #endif dev = init_netfront(NULL, NULL, rawmac, &ip); if(!cancelled){ if (ip) { ipaddr.addr = inet_addr(ip); if (IN_CLASSA(ntohl(ipaddr.addr))) netmask.addr = htonl(IN_CLASSA_NET); else if (IN_CLASSB(ntohl(ipaddr.addr))) netmask.addr = htonl(IN_CLASSB_NET); else if (IN_CLASSC(ntohl(ipaddr.addr))) netmask.addr = htonl(IN_CLASSC_NET); else tprintk("Strange IP %s, leaving netmask to 0.\n", ip); } tprintk("IP %x netmask %x gateway %x.\n", ntohl(ipaddr.addr), ntohl(netmask.addr), ntohl(gw.addr)); netif = xmalloc(struct netif); netif_add(netif, &ipaddr, &netmask, &gw, rawmac, netif_netfront_init, ip_input); netif_set_default(netif); netif_set_up(netif); down(&tcpip_is_up); } #ifdef CONFIG_SUSPEND tprintk("TCP/IP bringup begins.\n"); #endif }
/* Utility function to convert ipv4 netmask to prefixes ex.) "1.1.0.0" "255.255.0.0" => "1.1.0.0/16" ex.) "1.0.0.0" NULL => "1.0.0.0/8" */ int netmask_isis_str2prefix_str (const char *net_str, const char *mask_str, char *prefix_str) { struct in_addr network; struct in_addr mask; u_char prefixlen; u_int32_t destination; int ret; ret = inet_aton (net_str, &network); if (! ret) return 0; if (mask_str) { ret = inet_aton (mask_str, &mask); if (! ret) return 0; prefixlen = isis_ip_masklen (mask); } else { destination = ntohl (network.s_addr); if (network.s_addr == 0) prefixlen = 0; else if (IN_CLASSC (destination)) prefixlen = 24; else if (IN_CLASSB (destination)) prefixlen = 16; else if (IN_CLASSA (destination)) prefixlen = 8; else return 0; } sprintf (prefix_str, "%s/%d", net_str, prefixlen); return 1; }
static unsigned int guess_prefix_len(struct in_addr addr) { uint32_t prefix = ntohl(addr.s_addr); unsigned int len; /* At a minimum, use the prefix len for this IPv4 address class. */ if (IN_CLASSA(prefix)) len = 8; else if (IN_CLASSB(prefix)) len = 16; else if (IN_CLASSC(prefix)) len = 24; else len = 0; /* If the address has bits beyond the default class, * extend the prefix until we've covered all of them. */ return len + __count_net_bits(prefix << len); }