ip_addr.c File Reference

#include "lwip/opt.h"
#include "lwip/ip_addr.h"
#include "lwip/netif.h"

Include dependency graph for ip_addr.c:

Go to the source code of this file.

Macros
#define	in_range(c, lo, up)   ((u8_t)c >= lo && (u8_t)c <= up)
#define	isprint(c)   in_range(c, 0x20, 0x7f)
#define	isxdigit(c)   (isdigit(c) || in_range(c, 'a', 'f') || in_range(c, 'A', 'F'))
#define	islower(c)   in_range(c, 'a', 'z')
#define	isspace(c)   (c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' || c == '\v')

Functions
u8_t	ip4_addr_isbroadcast (u32_t addr, const struct netif *netif)
u8_t	ip4_addr_netmask_valid (u32_t netmask)
u32_t	ipaddr_addr (const char *cp)
int	ipaddr_aton (const char *cp, ip_addr_t *addr)
char *	ipaddr_ntoa (const ip_addr_t *addr)
char *	ipaddr_ntoa_r (const ip_addr_t *addr, char *buf, int buflen)

Variables
const ip_addr_t ip_addr_any	ICACHE_RODATA_ATTR = { IPADDR_ANY }

Detailed Description

This is the IPv4 address tools implementation.

Definition in file ip_addr.c.

Macro Definition Documentation

in_range

#define in_range	(		c,
			lo,
			up
	)		((u8_t)c >= lo && (u8_t)c <= up)

Definition at line 114 of file ip_addr.c.

islower

#define islower

(

c

)

in_range(c, 'a', 'z')

Definition at line 118 of file ip_addr.c.

Referenced by ipaddr_aton().

isprint

#define isprint

(

c

)

in_range(c, 0x20, 0x7f)

Definition at line 115 of file ip_addr.c.

Referenced by compress_and_expand_and_check(), dump_buf(), push_byte(), push_literal_byte(), and st_yield_literal().

isspace

#define isspace

(

c

)

(c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' || c == '\v')

Definition at line 119 of file ip_addr.c.

Referenced by base64_decode(), and ipaddr_aton().

isxdigit

#define isxdigit

(

c

)

(isdigit(c) || in_range(c, 'a', 'f') || in_range(c, 'A', 'F'))

Definition at line 117 of file ip_addr.c.

Referenced by ipaddr_aton().

Function Documentation

ip4_addr_isbroadcast()

u8_t ip4_addr_isbroadcast	(	u32_t	addr,
		const struct netif *	netif
	)

Determine if an address is a broadcast address on a network interface

Parameters

addr	address to be checked
netif	the network interface against which the address is checked

Returns

returns non-zero if the address is a broadcast address

Definition at line 55 of file ip_addr.c.

References netif::flags, ip4_addr_get_u32, ip4_addr_set_u32, netif::ip_addr, ip_addr_netcmp, IPADDR_ANY, IPADDR_BROADCAST, NETIF_FLAG_BROADCAST, and netif::netmask.

{
  ip_addr_t ipaddr;
  ip4_addr_set_u32(&ipaddr, addr);

  /* all ones (broadcast) or all zeroes (old skool broadcast) */
  if ((~addr == IPADDR_ANY) ||
      (addr == IPADDR_ANY)) {
    return 1;
  /* no broadcast support on this network interface? */
  } else if ((netif->flags & NETIF_FLAG_BROADCAST) == 0) {
    /* the given address cannot be a broadcast address
     * nor can we check against any broadcast addresses */
    return 0;
  /* address matches network interface address exactly? => no broadcast */
  } else if (addr == ip4_addr_get_u32(&netif->ip_addr)) {
    return 0;
  /*  on the same (sub) network... */
  } else if (ip_addr_netcmp(&ipaddr, &(netif->ip_addr), &(netif->netmask))
         /* ...and host identifier bits are all ones? =>... */
          && ((addr & ~ip4_addr_get_u32(&netif->netmask)) ==
           (IPADDR_BROADCAST & ~ip4_addr_get_u32(&netif->netmask)))) {
    /* => network broadcast address */
    return 1;
  } else {
    return 0;
  }
}

ip4_addr_netmask_valid()

u8_t ip4_addr_netmask_valid

(

u32_t

netmask

)

Checks if a netmask is valid (starting with ones, then only zeros)

Parameters

netmask

the IPv4 netmask to check (in network byte order!)

Returns

1 if the netmask is valid, 0 if it is not

Definition at line 90 of file ip_addr.c.

References lwip_htonl().

{
  u32_t mask;
  u32_t nm_hostorder = lwip_htonl(netmask);

  /* first, check for the first zero */
  for (mask = 1U << 31 ; mask != 0; mask >>= 1) {
    if ((nm_hostorder & mask) == 0) {
      break;
    }
  }
  /* then check that there is no one */
  for (; mask != 0; mask >>= 1) {
    if ((nm_hostorder & mask) != 0) {
      /* there is a one after the first zero -> invalid */
      return 0;
    }
  }
  /* no one after the first zero -> valid */
  return 1;
}

Here is the call graph for this function:

ipaddr_addr()

u32_t ipaddr_addr

(

const char *

cp

)

Ascii internet address interpretation routine. The value returned is in network order.

Parameters

cp	IP address in ascii represenation (e.g. "127.0.0.1")

Returns

ip address in network order

Definition at line 130 of file ip_addr.c.

References ip4_addr_get_u32, ipaddr_aton(), and IPADDR_NONE.

{
  ip_addr_t val;

  if (ipaddr_aton(cp, &val)) {
    return ip4_addr_get_u32(&val);
  }
  return (IPADDR_NONE);
}

Here is the call graph for this function:

ipaddr_aton()

int ipaddr_aton	(	const char *	cp,
		ip_addr_t *	addr
	)

Check whether "cp" is a valid ascii representation of an Internet address and convert to a binary address. Returns 1 if the address is valid, 0 if not. This replaces inet_addr, the return value from which cannot distinguish between failure and a local broadcast address.

Parameters

cp	IP address in ascii represenation (e.g. "127.0.0.1")
addr	pointer to which to save the ip address in network order

Returns

1 if cp could be converted to addr, 0 on failure

Definition at line 152 of file ip_addr.c.

References htonl, ip4_addr_set_u32, islower, isspace, isxdigit, and LWIP_ASSERT.

Referenced by ipaddr_addr().

{
  u32_t val;
  u8_t base;
  char c;
  char ch;
  unsigned long cutoff;
  int cutlim;
  u32_t parts[4];
  u32_t *pp = parts;

  c = *cp;
  for (;;) {
    /*
     * Collect number up to ``.''.
     * Values are specified as for C:
     * 0x=hex, 0=octal, 1-9=decimal.
     */
    if (!isdigit(c))
      return (0);
    val = 0;
    base = 10;
    if (c == '0') {
      c = *++cp;
      if (c == 'x' || c == 'X') {
        base = 16;
        c = *++cp;
      } else
        base = 8;
    }

    cutoff =(unsigned long)0xffffffff / (unsigned long)base;
    cutlim =(unsigned long)0xffffffff % (unsigned long)base;

    for (;;) {
      if (isdigit(c)) {
        ch = (int)(c - '0');

        if (val > cutoff || (val == cutoff && ch > cutlim))
            return (0);

        val = (val * base) + (int)(c - '0');
        c = *++cp;
      } else if (base == 16 && isxdigit(c)) {
        ch = (int)(c + 10 - (islower(c) ? 'a' : 'A'));

        if (val > cutoff || (val == cutoff && ch > cutlim))
            return (0);

        val = (val << 4) | (int)(c + 10 - (islower(c) ? 'a' : 'A'));
        c = *++cp;
      } else
        break;
    }
    if (c == '.') {
      /*
       * Internet format:
       *  a.b.c.d
       *  a.b.c   (with c treated as 16 bits)
       *  a.b (with b treated as 24 bits)
       */
      if (pp >= parts + 3) {
        return (0);
      }
      *pp++ = val;
      c = *++cp;
    } else
      break;
  }
  /*
   * Check for trailing characters.
   */
  if (c != '\0' && !isspace(c)) {
    return (0);
  }
  /*
   * Concoct the address according to
   * the number of parts specified.
   */
  switch (pp - parts + 1) {

  case 0:
    return (0);       /* initial nondigit */

  case 1:             /* a -- 32 bits */
    break;

  case 2:             /* a.b -- 8.24 bits */
    if ((val > 0xffffffUL) || (parts[0] > 0xff)) {
      return (0);
    }
    val |= parts[0] << 24;
    break;

  case 3:             /* a.b.c -- 8.8.16 bits */
    if ((val > 0xffff) || (parts[0] > 0xff) || (parts[1] > 0xff)) {
      return (0);
    }
    val |= (parts[0] << 24) | (parts[1] << 16);
    break;

  case 4:             /* a.b.c.d -- 8.8.8.8 bits */
    if ((val > 0xff) || (parts[0] > 0xff) || (parts[1] > 0xff) || (parts[2] > 0xff)) {
      return (0);
    }
    val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
    break;
  default:
    LWIP_ASSERT("unhandled", 0);
    break;
  }
  if (addr) {
    ip4_addr_set_u32(addr, htonl(val));
  }
  return (1);
}

Here is the caller graph for this function:

ipaddr_ntoa()

char* ipaddr_ntoa

(

const ip_addr_t *

addr

)

Convert numeric IP address into decimal dotted ASCII representation. returns ptr to static buffer; not reentrant!

Parameters

addr	ip address in network order to convert

Returns

pointer to a global static (!) buffer that holds the ASCII represenation of addr

Definition at line 278 of file ip_addr.c.

References ipaddr_ntoa_r().

{
  static char str[16];
  return ipaddr_ntoa_r(addr, str, 16);
}

Here is the call graph for this function:

ipaddr_ntoa_r()

char* ipaddr_ntoa_r	(	const ip_addr_t *	addr,
		char *	buf,
		int	buflen
	)

Same as ipaddr_ntoa, but reentrant since a user-supplied buffer is used.

Parameters

addr	ip address in network order to convert
buf	target buffer where the string is stored
buflen	length of buf

Returns

either pointer to buf which now holds the ASCII representation of addr or NULL if buf was too small

Definition at line 293 of file ip_addr.c.

References ip4_addr_get_u32, and NULL.

Referenced by ipaddr_ntoa().

{
  u32_t s_addr;
  char inv[3];
  char *rp;
  u8_t *ap;
  u8_t rem;
  u8_t n;
  u8_t i;
  int len = 0;

  s_addr = ip4_addr_get_u32(addr);

  rp = buf;
  ap = (u8_t *)&s_addr;
  for(n = 0; n < 4; n++) {
    i = 0;
    do {
      rem = *ap % (u8_t)10;
      *ap /= (u8_t)10;
      inv[i++] = '0' + rem;
    } while(*ap);
    while(i--) {
      if (len++ >= buflen) {
        return NULL;
      }
      *rp++ = inv[i];
    }
    if (len++ >= buflen) {
      return NULL;
    }
    *rp++ = '.';
    ap++;
  }
  *--rp = 0;
  return buf;
}

Here is the caller graph for this function:

Variable Documentation

ICACHE_RODATA_ATTR

const ip_addr_t ip_addr_broadcast ICACHE_RODATA_ATTR = { IPADDR_ANY }

Definition at line 44 of file ip_addr.c.