/*
* 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);
}
