{

setV4();

(*this)[0] = first_octet;

(*this)[1] = second_octet;

(*this)[2] = third_octet;

(*this)[3] = fourth_octet;

{

uint8_t cnt;

if (v4)

{

cnt = 4;

setV4();

}

else

{

cnt = 16;

setV6();

}

for (int i = 0; i < cnt; i++)

{

(*this)[i] = address[i];

}

{

if (!ip.isSet())

{

setUnset();

}

else if (ip.isV4())

{

setV4();

for (int i = 0; i < 4; i++)

{

rawip[i] = ip[i];

}

}

else

{

setV6();

for (int i = 0; i < 16; i++)

{

rawip[i] = ip[i];

}

}

{

if (!fromString(ip.c_str()))

{

setUnset();

}

{

if (!fromString4(address))

{

return fromString6(address);

}

return true;

{

// TODO: (IPv4) add support for "a", "a.b", "a.b.c" formats

uint16_t acc = 0; // Accumulator

uint8_t dots = 0;

while (*address)

{

char c = *address++;

if (c >= '0' && c <= '9')

{

acc = acc * 10 + (c - '0');

if (acc > 255)

{

// Value out of [0..255] range

return false;

}

}

else if (c == '.')

{

if (dots == 3)

{

// Too much dots (there must be 3 dots)

return false;

}

(*this)[dots++] = acc;

acc = 0;

}

else

{

// Invalid char

return false;

}

}

if (dots != 3)

{

// Too few dots (there must be 3 dots)

return false;

}

(*this)[3] = acc;

setV4();

return true;

{

// TODO: test test test

uint32_t acc = 0; // Accumulator

int dots = 0, doubledots = -1;

while (*address)

{

char c = tolower(*address++);

if (isalnum(c))

{

if (c >= 'a')

{

c -= 'a' - '0' - 10;

}

acc = acc * 16 + (c - '0');

if (acc > 0xffff)

// Value out of range

{

return false;

}

}

else if (c == ':')

{

if (*address == ':')

{

if (doubledots >= 0)

// :: allowed once

{

return false;

}

// remember location

doubledots = dots + !!acc;

address++;

}

if (dots == 7)

// too many separators

{

return false;

}

reinterpret_cast<uint16_t*>(rawip)[dots++] = PP_HTONS(acc);

acc = 0;

}

else

// Invalid char

{

return false;

}

}

if (doubledots == -1 && dots != 7)

// Too few separators

{

return false;

}

reinterpret_cast<uint16_t*>(rawip)[dots++] = PP_HTONS(acc);

if (doubledots != -1)

{

for (int i = dots - doubledots - 1; i >= 0; i--)

{

reinterpret_cast<uint16_t*>(rawip)[8 - dots + doubledots + i] = reinterpret_cast<uint16_t*>(rawip)[doubledots + i];

}

for (int i = doubledots; i < 8 - dots + doubledots; i++)

{

reinterpret_cast<uint16_t*>(rawip)[i] = 0;

}

}

setV6();

return true;

{

StreamString sstr;

if (isV6())

{

sstr.reserve(40); // 8 shorts x 4 chars each + 7 colons + nullterm

}

else

{

sstr.reserve(16); // 4 bytes with 3 chars max + 3 dots + nullterm, or '(IP unset)'

}

printTo(sstr);

return sstr;

{

size_t n = 0;

if (!isSet())

{

return p.print(F("(IP unset)"));

}

if (isV6())

{

int count0 = 0;

for (int i = 0; i < 8; i++)

{

uint16_t bit = PP_NTOHS(reinterpret_cast<const uint16_t*>(rawip)[i]);

if (bit || count0 < 0)

{

n += p.printf("%x", bit);

if (count0 > 0)

// no more hiding 0

{

count0 = -8;

}

}

else

{

count0++;

}

if ((i != 7 && count0 < 2) || count0 == 7)

{

n += p.print(':');

}

}

return n;

}

for (int i = 0; i < 4; i++)

{

n += p.print((*this)[i], DEC);

if (i != 3)

{

n += p.print('.');

}

}

return n;

{

for (int i = 0; i < (v == IPversion::IPV4 ? 4 : 16); i++)

{

if (a[i] != b[i])

{

return false;

}

}

return true;

{

switch (ipv)

{

case IPversion::UNSET :

if (ip.isSet())

{

return false;

}

else

{

return true;

}

break;

case IPversion::IPV4 :

if (ip.isV6() || !ip.isSet())

{

return false;

}

else

{

return compareRaw(IPversion::IPV4, rawip, reinterpret_cast<const uint8_t*>(&ip.v4()));

}

break;

case IPversion::IPV6 :

if (ip.isV4() || !ip.isSet())

{

return false;

}

else

{

return compareRaw(IPversion::IPV6, rawip, reinterpret_cast<const uint8_t*>(ip.raw6()));

}

break;

default :

return false;

break;

}

{

switch (ipv)

{

case IPversion::UNSET :

if (nip.isSet())

{

return false;

}

else

{

return true;

}

break;

case IPversion::IPV4 :

if (nip.isV6() || !nip.isSet())

{

return false;

}

else

{

return compareRaw(IPversion::IPV4, rawip, nip.rawip);

}

break;

case IPversion::IPV6 :

if (nip.isV4() || !nip.isSet())

{

return false;

}

else

{

return compareRaw(IPversion::IPV6, rawip, nip.rawip);

}

break;

default :

return false;

break;

}