IPV4 to IPV6: IP address

Address Types & Formats IPv6

Tukiyooo 0 address, Addressing, Hexadecimal, Infrastructures, IP address, IPv6, Setup IPv6 01:17

<h2>
Hexadecimal Number System</h2>
Before introducing <a href="http://ipv4-ipv6.blogspot.com/" target="_blank">IPv6 Address format</a>, we shall look into 
Hexadecimal Number System. Hexadecimal is positional number system 
which uses radix (base) of 16. To represent the values in readable 
format, this system uses 0-9 symbols to represent values from zero to 
nine and A-F symbol to represent values from ten to fifteen. Every 
digit in Hexadecimal can represent values from 0 to 15. 
<figure>
<img caption="Hexadecimal Conversion Table" src="http://www.tutorialspoint.com/ipv6/images/Hexadecimal_conversion_table.jpg" />
<figcaption align="center">[Image: Conversion Table]</figcaption>
</figure><h2>
Address Structure</h2>
An IPv6 address is made of 128 bits divided into eight 16-bits 
blocks. Each block is then converted into 4-digit Hexadecimal numbers 
separated by colon symbol.

For example, the below is 128 bit IPv6 address represented in binary format and divided into eight 16-bits blocks: 
<blockquote>
0010000000000001 0000000000000000 0011001000110100 1101111111100001 
0000000001100011 0000000000000000 0000000000000000 1111111011111011</blockquote>
Each block is then converted into Hexadecimal and separated by ‘:’ symbol: 
<blockquote>
2001:0000:3238:DFE1:0063:0000:0000:FEFB</blockquote>
Even after converting into Hexadecimal format, IPv6 address remains 
long. IPv6 provides some rules to shorten the address. These rules 
are: 
Rule:1 Discard leading Zero(es): 
In Block 5, 0063, the leading two 0s can be omitted, such as (5th block): 
<blockquote>
2001:0000:3238:DFE1:63:0000:0000:FEFB</blockquote>
Rule:2 If two of more blocks contains consecutive zeroes, omit
 them all and replace with double colon sign ::, such as (6th and 7th 
block): 
<blockquote>
2001:0000:3238:DFE1:63::FEFB</blockquote>
Consecutive blocks of zeroes can be replaced only once by :: so if 
there are still blocks of zeroes in the address they can be shrink down 
to single zero, such as (2nd block): 
<blockquote>
2001:0:3238:DFE1:63::FEFB</blockquote>
<h2>
Interface ID</h2>
IPv6 has three different type of Unicast Address scheme. The second 
half of the address (last 64 bits) is always used for Interface ID. MAC
 address of a system is composed of 48-bits and represented in 
Hexadecimal. MAC address is considered to be uniquely assigned 
worldwide. Interface ID takes advantage of this uniqueness of MAC 
addresses. A host can auto-configure its Interface ID by using IEEE’s 
Extended Unique Identifier (EUI-64) format. First, a Host divides its 
own MAC address into two 24-bits halves. Then 16-bit Hex value 0xFFFE 
is sandwiched into those two halves of MAC address, resulting in EUI-64 
Interface ID.

<img src="http://www.tutorialspoint.com/ipv6/images/interface_id.jpg" />
 
<figcaption align="center">[Image: EUI-64 Interface ID]</figcaption>Conversion of EUI-64 ID into IPv6 Interface Identifier 
To convert EUI-64 ID into IPv6 Interface Identifier, the most significant 7th bit of EUI-64 ID is complemented. For example: 
<figure style="margin: 0px; padding: 0px;">
<img src="http://www.tutorialspoint.com/ipv6/images/eui_to_ipv6_id.png" />
<figcaption align="center">[Image: IPV6 Interface ID]</figcaption>
</figure><h2>
Global Unicast Address</h2>
This address type is equivalent to IPv4’s public address. Global 
Unicast addresses in IPv6 are globally identifiable and uniquely 
addressable. 
<figure style="margin: 0px; padding: 0px;">
<img caption="Global Unicast Address" src="http://www.tutorialspoint.com/ipv6/images/global_unicast_address.jpg" />
<figcaption align="center">[Image: Global Unicast Address]</figcaption>
</figure>Global Routing Prefix: The most significant 48-bits are designated as
 Global Routing Prefix which is assigned to specific Autonomous System. 
 Three most significant bits of Global Routing Prefix is always set to 
001. 
<h2>
Link-Local Address</h2>
Auto-configured IPv6 address is known as Link-Local address. This 
address always starts with FE80. First 16 bits of Link-Local address is
 always set to 1111 1110 1000 0000 (FE80). Next 48-bits are set to 0, 
thus: 
<figure style="margin: 0px; padding: 0px;">
<img caption="Link-Local Address" src="http://www.tutorialspoint.com/ipv6/images/link_local_address.jpg" />
<figcaption align="center">[Image: Link-Local Address]</figcaption>
</figure>Link-Local addresses are used for communication among IPv6 hosts on a
 link (broadcast segment) only. These addresses are not routable so a 
Router never forwards these addresses outside the link. 
<h2>
Unique-Local Address</h2>
This type of IPv6 address which is though globally unique, but it 
should be used in local communication. This address has second half of 
Interface ID and first half is divided among Prefix, Local Bit, Global 
ID and Subnet ID. 
<figure style="margin: 0px; padding: 0px;">
<img caption="Unique-Local Address" src="http://www.tutorialspoint.com/ipv6/images/unique_local_address.jpg" />
<figcaption align="center">[Image: Unique-Local Address]</figcaption>
</figure>
Prefix is always set to 1111 110. 
L bit, which is set to 1 if the address is locally assigned. So far the meaning of L bit to 0 is not defined.
Therefore, Unique Local IPv6 address always starts with ‘FD’.
 
<h3>
Scope of IPv6 Unicast Addresses:</h3>
<figure>
<img caption="IPv6 Unicast Address Scope" src="http://www.tutorialspoint.com/ipv6/images/address_scope.jpg" />
<figcaption align="center">[Image: IPv6 Unicast Address Scope]</figcaption>
</figure>

The scope of Link-local address is limited to the segment. Unique 
Local Address are though locally global but are not routed over the 
Internet, limiting their scope to an organization’s boundary. Global 
Unicast addresses are globally unique and recognizable. They shall make
 the essence of Internet v2 addressing. 
 
<a href="http://ipv4-ipv6.blogspot.com/2014/07/address-types-formats-ipv6.html">http://ipv4-ipv6.blogspot.com/2014/07/address-types-formats-ipv6.html</a>

Address Types & Formats IPv6

Tukiyooo 0 address, Addressing, Hexadecimal, Infrastructures, IP address, IPv6, Setup IPv6 01:17

Hexadecimal Number System Before introducing IPv6 Address format, we shall look into Hexadecimal Number System. Hexadecimal is positional number system which uses radix (base) of 16. To represent the values in readable format, this system uses … Read more »

07Jul2014

Solving the IP Address Chicken-and-Egg Challenge

Tukiyooo 0 Challenge, computer, Facebook, hardware manufacturers, IP address, ISPs, mobile phone, OS makers, Solving, Telecom carriers, Web companies 10:25

<a href="https://scontent-b.xx.fbcdn.net/hphotos-xpa1/t1.0-0/165639_494742522199_1812395_n.jpg" imageanchor="1" style="clear: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" class="img" data-store="{"imgsrc":"https:\/\/scontent-b.xx.fbcdn.net\/hphotos-xpa1\/t1.0-0\/165639_494742522199_1812395_n.jpg"}" height="150" src="https://scontent-b.xx.fbcdn.net/hphotos-xpa1/t1.0-0/165639_494742522199_1812395_n.jpg" width="180" /></a>We’re announcing today our participation in <a href="http://lm.facebook.com/l.php?u=http%3A%2F%2Fwww.isoc.org%2Fworldipv6day&h=DAQErAJSI&s=1" rel="nofollow" target="_blank">World IPv6 Day</a>,
 along with Google, Yahoo!, Akamai, Limelight Networks, and the Internet
 Society. June 8, 2011, will be the first global-scale "test flight" of 
IPv6, the next generation protocol for the Internet. And best of all, 
it’s open to everyone who’s interested in testing their IPv6 service. 
 
This
 is a big step forward for the Internet because the current protocol, 
IPv4 (also known as IP), will run out of addresses this year. Since 
every endpoint on the Internet — whether it’s a computer, mobile phone, 
or TV — relies on a unique IP address to communicate, we need more 
addresses so they can all stay connected. 
 
As a next 
generation protocol, IPv6 provides a vast number of addresses by today's
 standards — 4 billion times the number that are available under IPv4. 
Telecom carriers, ISPs, OS makers, hardware manufacturers, Web 
companies, and governments around the world are depending on IPv6 to 
continue growth of the Internet. World IPv6 Day — a 24 hour period 
during which Internet companies will test IPv6 — is an important step 
that enables the technology to move forward in a globally coordinated 
setting. 
 
Testing IPv6 is important because recent studies 
indicate about 0.05% of Internet users (1 in 2,000) can’t reliably 
connect to websites that enable both IPv4 and IPv6 addresses (known as 
"dual-stacked" websites). This has resulted in a classic chicken-and-egg
 puzzle right now: websites don’t want to enable IPv6 because a small 
number of their users may have trouble connecting. At the same time, 
doing nothing means that ever more users will have trouble connecting to
 these dual-stacked websites, and ISPs will turn to less effective 
technical alternatives like Large Scale NAT (see below). 
 
To
 break this conundrum, we need to take a small, concerted step for just 
24 hours, where Web companies, ISPs, hardware/software makers, and users
 work together and synchronize plans, communication, and support. 
 
Why IPv6 Is Important to Facebook 
The
 switch to IPv6 is especially important for us at Facebook as we pursue 
our mission of helping the world connect and share online. Since last 
summer, we’ve offered Facebook over IPv6 at <a href="http://www.v6.facebook.com/?refid=22" rel="nofollow" target="_blank">www.v6.facebook.com</a>
 (addressed 2620:0:1cfe:face:b00c::3 in true hexadecimal IPv6 hacker 
fashion; note that the v6 link works only from IPv6 endpoints). World 
IPv6 Day will allow us to test our infrastructure and code more widely 
with low risk to our service and users. 
 
The day also 
promotes awareness among hardware and software suppliers, and should 
encourage everyone to create robust IPv6 products and fix buggy ones. 
Between now and June 8th, there’s an opportunity for the entire industry
 to ensure hardware and software isn’t just IPv6-capable, but that it 
can reliably connect people to dual-stacked websites. 
 
This
 year's exhaustion of IPv4 addresses isn’t exactly a sky-is-falling 
situation, because there are always economic and technical solutions 
when there's enough energy put behind a big problem. An economic 
solution is for organizations to buy IPv4 addresses from others willing 
to sell them. But this isn’t a sustainable solution, and it’s perhaps 
not completely fair when you consider how the Internet has historically 
been fully open and accessible. On the technical side, there are many 
protocols and devices in different stages of maturity. But some v4-to-v6
 transitional protocols are so old they are nearly phased-out or 
obsolete. 
 
LSN: A Technical Alternative 
One
 newer solution being proposed is Large Scale NAT (Network Address 
Translation) or LSN, also called Carrier Grade NAT. NAT basically 
translates one address into another, typically a private address into a 
public address and vice-versa. Many users and sites do this today on a 
small scale. Your laptop may have the private address 192.168.1.10, 
which is translated by your home router into a public address provided 
by your ISP. The public address is unique and the address you depend on 
for global Internet connectivity. So what happens when your ISP runs out
 of addresses? Before address exhaustion, it would simply apply for and 
receive new addresses. But that is no longer the case. 
 
<img class="img" data-store="{"imgsrc":"https:\/\/scontent-b.xx.fbcdn.net\/hphotos-xpa1\/t1.0-0\/s280x280\/167495_494743352199_5361035_n.jpg"}" height="171" src="https://scontent-b.xx.fbcdn.net/hphotos-xpa1/t1.0-0/s280x280/167495_494743352199_5361035_n.jpg" width="280" /> 
 
Enter
 LSN. The plan here is to give your endpoint, like your home router, a 
private address instead of a public one and then translate your traffic 
at a new, heavy-duty LSN device that lives elsewhere on the Internet. 
Thus, your laptop's private address will be translated to another 
private address at your home router, which will then be translated again
 into a public address at this new LSN device. Thousands of users share a
 single IP address thanks to the massive translator. What’s unclear is 
whether this will give us the same performance, reliability, and 
security we have on the Internet today. And the people deploying LSN are
 not exactly thrilled about having to use it — it's more out of 
necessity because most websites aren’t yet dual-stacked to handle an 
end-to-end IPv6 connection. 
 
IPv6 vs. LSN 
Many
 people have spent years working IPv6, which is a longer-term and more 
reliable solution than LSN. Adopting IPv6 means that people with IPv6 
addresses can talk to IPv6-enabled, dual-stack sites without 
translators. The following chart describes some other aspects of LSN 
compared to end-to-end IPv6 connectivity. 
 
<img class="img" data-store="{"imgsrc":"https:\/\/scontent-b.xx.fbcdn.net\/hphotos-xfa1\/t1.0-0\/s280x280\/166116_494743382199_4204840_n.jpg"}" height="183" src="https://scontent-b.xx.fbcdn.net/hphotos-xfa1/t1.0-0/s280x280/166116_494743382199_4204840_n.jpg" width="280" /> 
 
We
 hope you'll follow along in the coming months and then join us for 
World IPv6 Day on June 8, 2011, when the Internet takes a big step 
forward! 
 
Acknowledgements 
Many people contributed to our IPv6 efforts and this event, notably <a href="http://www.facebook.com/wlawton?refid=22" rel="nofollow" target="_blank">Will Lawton</a>, <a href="http://www.facebook.com/ps?refid=22" rel="nofollow" target="_blank">Paul Saab</a>, <a href="http://www.facebook.com/jallen?refid=22" rel="nofollow" target="_blank">John Allen</a>, and <a href="http://www.facebook.com/jonnythaw?refid=22" rel="nofollow" target="_blank">Jonny Thaw</a> at Facebook, Lorenzo Colitti at Google, and Tore Anderson at Redpill Linpro.

Solving the IP Address Chicken-and-Egg Challenge

Tukiyooo 0 Challenge, computer, Facebook, hardware manufacturers, IP address, ISPs, mobile phone, OS makers, Solving, Telecom carriers, Web companies 10:25

We’re announcing today our participation in World IPv6 Day, along with Google, Yahoo!, Akamai, Limelight Networks, and the Internet Society. June 8, 2011, will be the first global-scale "test flight" of IPv6, the next generation protocol for the I… Read more »

12Jun2014

C++ Internet Protocol and Socket Address Classes

Tukiyooo 0 C++, Internet, IP address, IPv4, IPv4/IPv6, IPv6, Protocol, Socket 19:18

<pre>C++ Internet Protocol and Socket Address Classes

Document Number: TBD
Date: TBD
Author: Aleksandar Fabijanic <alex AT pocoproject.org>
 Günter Obiltschnig <guenter.obiltschnig AT appinf.com>

Content

1. Revision History

2. Motivation and Scope

3. IP Address
 3.1. Usage Examples
 3.1.1. IPv4
 3.1.2. IPv6
 3.2. Header <ip_address> synopsis

5. Socket Address
 5.1. Usage Examples
 5.2. Header <socket_address> synopsis

6. Conclusion

7. Acknowledgments

1. Revision History

- Oct 10 2012: created

2. Motivation and Scope

Given the pervasiveness of networking and Internet, there is a
pressing need for standard networking support in C++ language.
This proposal addresses the concerns of IP and socket addresses;
it is aimed to be one of the fundamental building blocks and
steps toward the Standard C++ Network Library goal.

This proposal is based on IP and socket address implementations
in the Net library in C++ Portable Components (POCO) [6] framework.
POCO framework has been open sourced in 2005 by its principal
sponsor (Applied Informatics Software Engineering GmbH) and is
currently licensed under Boost Software License and used in
production by numerous commercial entities as well as other
open source projects [7].

The scope of the proposal is description of functionality,
interfaces and usage examples for a set of classes providing
functionality to store and manipulate Internet Protocol
(IPv4 and v6) as well as socket (IP address + port) addresses.

3. IP Address

The ip_address class represents an Internet Protocol host
address. The address can belong to either IPv4 or IPv6 
(if the target platform supports it) address family.

Relational operators (==, !=, <, <=, >, >=) are supported. 
Notably, an IPv4 address is never equal to an IPv6 
address, even if the IPv6 address is IPv4 compatible and 
the addresses are logically the same.

For underlying IP address bit manipulation, bitwise operators
(&, |, ^, ~) are supported.

3.1 Usage Examples

3.1.1. IPv4:

ip_address ia("127.0.0.1");
assert (ia.family() == ip_address::ipv4);
assert (ia.to_string() == "127.0.0.1");
assert (ip.is_loopback());

ip_address addr("10.0.0.51");
ip_address mask(24, ip_address::ipv4);
assert(mask.prefix_len() == 24);

ip_address net = addr & mask;
assert(net.to_string() == "10.0.0.0");

ip_address host("0.0.0.51");
assert((net | host) == addr);
assert((~mask).to_string() == "0.0.0.255");

3.1.2. IPv6

ip_address ia("1080:0:0:0:8:600:200a:425c");
assert (ia.family() == ip_address::ipv6);
assert (ia.to_string() == "1080::8:600:200a:425c");

ip_address ia(62, ip_address::ipv6);
assert(ia.to_string() == "ffff:ffff:ffff:fffc::");

3.2. Header <ip_address> synopsis

namespace std {
namespace net {

typedef int socklen_t;

class ip_address {
public:
typedef std::vector<IPAddress> list;

enum family
/// Possible address families for IP addresses.
{
 ipv4
#ifdef _STD_HAVE_IPv6
 ,ipv6
#endif
};
 
ip_address();
 /// Creates a wildcard (zero) IPv4 ip_address.

ip_address(const ip_address& addr);
 /// Creates an ip_address by copying another one.

explicit IPAddress(family family);
 /// Creates a wildcard (zero) ip_address for the given address family.

explicit ip_address(const std::string& addr);
 /// Creates an IPAddress from the string containing
 /// an IP address in presentation format (dotted decimal
 /// for IPv4, hex string for IPv6).
 /// Depending on the format of addr, IPv4 or an IPv6 address is 
 /// created. See to_string() for details on the supported formats.
 /// Throws std::runtime_exception if the address cannot be parsed.

ip_address(const std::string& addr, Family family);
 /// Creates an ip_address from the string containing
 /// an IP address in presentation format (dotted decimal
 /// for IPv4, hex string for IPv6).

ip_address(const void* addr, socklen_t length);
 /// Creates an IPAddress from a native internet address.
 /// A pointer to an in_addr or an in6_addr structure may be passed.

ip_address(const void* addr, socklen_t length, uint32_t scope);
 /// Creates an IPAddress from a native internet address.
 /// A pointer to a in_addr or a in6_addr structure may be 
 /// passed. Additionally, for an IPv6 address, a scope ID
 /// may be specified. The scope ID will be ignored if an IPv4
 /// address is specified.

ip_address(uint32_t prefix, family family);
 /// Creates an ip_address mask with the given length of prefix.

ip_address(const struct sockaddr& sockaddr);
 /// Creates an ip_address from sockaddr structure.

~ip_address();
 /// Destroys the IPAddress.

ip_address& operator = (const ip_address& addr);
 /// Assigns an IPAddress.
  
void swap(ip_address& address);
 /// Swaps the IPAddress with another one.
  
family family() const;
 /// Returns the address family (ipv4 or ipv6) of the address.

uint32_t scope() const;
 /// Returns the IPv6 scope identifier of the address. Returns 0 if
 /// the address is an IPv4 address, or the address is an
 /// IPv6 address but does not have a scope identifier.

std::string to_string() const;
 /// Returns a string containing a representation of the address
 /// in presentation format.
 /// For IPv4 addresses the result will be in dotted-decimal (d.d.d.d) notation.
 /// The preferred form is x:x:x:x:x:x:x:x, where the 'x's are the hexadecimal 
 /// values of the eight 16-bit pieces of the address. This is the full form.
 /// Example: 1080:0:0:0:8:600:200a:425c
 /// It is not necessary to write the leading zeros in an individual field. 
 /// However, there must be at least one numeral in every field, except as 
 /// described below.
 /// It is common for IPv6 addresses to contain long strings of zero bits. 
 /// In order to make writing addresses containing zero bits easier, a special
  /// syntax is  available to compress the zeros. The use of "::" indicates multiple
 /// groups of 16-bits of zeros. 
 /// The "::" can only appear once in an address. The "::" can also be used to 
 /// compress the leading and/or trailing zeros in an address. 
 /// Example: 1080::8:600:200a:425c
 /// For dealing with IPv4 compatible addresses in a mixed environment,
 /// a special syntax is available: x:x:x:x:x:x:d.d.d.d, where the 'x's are the 
 /// hexadecimal values of the six high-order 16-bit pieces of the address, 
 /// and the 'd's are the decimal values of the four low-order 8-bit pieces of the 
 /// standard IPv4 representation address. Example: ::ffff:192.168.1.120
 /// If an IPv6 address contains a non-zero scope identifier, it is added
 /// to the string, delimited by a percent character. On Windows platforms,
 /// the numeric value (which specifies an interface index) is directly
 /// appended. On Unix platforms, the name of the interface corresponding
 /// to the index (interpretation of the scope identifier) is added.

bool is_wildcard() const;
 /// Returns true iff the address is a wildcard (all zero) address.
  
bool is_broadcast() const;
 /// Returns true iff the address is a broadcast address.
 /// Only IPv4 addresses can be broadcast addresses. In a broadcast
 /// address, all bits are one. For an IPv6 address, returns always false.
 
bool is_loopback() const;
 /// Returns true iff the address is a loopback address.
 /// For IPv4, the loopback address is 127.0.0.1.
 /// For IPv6, the loopback address is ::1.
 
bool is_multicast() const;
 /// Returns true iff the address is a multicast address.
 /// IPv4 multicast addresses are in the
 /// 224.0.0.0 to 239.255.255.255 range
 /// (the first four bits have the value 1110).
 /// IPv6 multicast addresses are in the
 /// FFxx:x:x:x:x:x:x:x range.
  
bool is_unicast() const;
 /// Returns true iff the address is a unicast address.
 /// An address is unicast if it is neither a wildcard,
 /// broadcast or multicast address.
  
bool is_link_local() const;
 /// Returns true iff the address is a link local unicast address.
 /// IPv4 link local addresses are in the 169.254.0.0/16 range,
 /// according to RFC 3927.
 /// IPv6 link local addresses have 1111 1110 10 as the first
 /// 10 bits, followed by 54 zeros.
  
bool is_site_local() const;
 /// Returns true iff the address is a site local unicast address.
 /// IPv4 site local addresses are in on of the 10.0.0.0/24,
 /// 192.168.0.0/16 or 172.16.0.0 to 172.31.255.255 ranges.
 /// Originally, IPv6 site-local addresses had FEC0/10 (1111 1110 11) 
 /// prefix (RFC 4291), followed by 38 zeros. Interfaces using  
 /// this mask are supported, but obsolete; RFC 4193 [3] prescribes
 /// fc00::/7 (1111 110) as local unicast prefix.
  
bool is_ipv4_compatible() const;
 /// Returns true iff the address is IPv4 compatible.
 /// For IPv4 addresses, this is always true.
 /// For IPv6, the address must be in the ::x:x range (the
 /// first 96 bits are zero).

bool is_ipv4_mapped() const;
 /// Returns true iff the address is an IPv4 mapped IPv6 address.
 /// For IPv4 addresses, this is always true.
 /// For IPv6, the address must be in the ::FFFF:x:x range.
 
bool is_well_known_mcast() const;
 /// Returns true iff the address is a well-known multicast address.
 /// For IPv4, well-known multicast addresses are in the 224.0.0.0/8 range.
 /// For IPv6, well-known multicast addresses are in the 
 /// FF0x:x:x:x:x:x:x:x range.
 
bool is_node_local_mcast() const;
 /// Returns true iff the address is a node-local multicast address.
 /// IPv4 does not support node-local addresses, thus the result is
 /// always false for an IPv4 address.
 /// For IPv6, node-local multicast addresses are in the
 /// FFx1:x:x:x:x:x:x:x range.
 
bool is_link_local_mcast() const;
 /// Returns true iff the address is a link-local multicast address.
 /// For IPv4, link-local multicast addresses are in the
 /// 224.0.0.0/24 range. Note that this overlaps with the range for well-known
 /// multicast addresses.
 /// For IPv6, link-local multicast addresses are in the
 /// FFx2:x:x:x:x:x:x:x range.

bool is_site_local_mcast() const;
 /// Returns true iff the address is a site-local multicast address.
 /// For IPv4, site local multicast addresses are in the 239.255.0.0/16 range.
 /// For IPv6, site-local multicast addresses are in the
 /// FFx5:x:x:x:x:x:x:x range.

bool is_org_local_mcast() const;
 /// Returns true iff the address is a organization-local multicast address.
 /// For IPv4, organization-local multicast addresses are in the
 /// 239.192.0.0/16 range.
 /// For IPv6, organization-local multicast addresses are in the
 /// FFx8:x:x:x:x:x:x:x range.

bool is_global_mcast() const;
 /// Returns true iff the address is a global multicast address.
 /// For IPv4, global multicast addresses are in the 
 /// 224.0.1.0 to 238.255.255.255 range.
 /// For IPv6, global multicast addresses are in the
 /// FFxF:x:x:x:x:x:x:x range.
 
bool operator == (const ip_address& addr) const;
 /// Returns true if IP addresses are equal.

bool operator != (const ip_address& addr) const;
 /// Returns true if IP addresses are not equal.

bool operator < (const ip_address& addr) const;
 /// Returns true if this IP address is lesser than addr.

bool operator <= (const ip_address& addr) const;
 /// Returns true if this IP address is lesser than or equal to addr.

bool operator >  (const ip_address& addr) const
 /// Returns true if this IP address is greater than addr.

bool operator >= (const ip_address& addr) const;
 /// Returns true if this IP address is greater than or equal to addr.

ip_address operator & (const ip_address& addr) const;
 /// Performs a bitwise ANd operation and returns result.

ip_address operator | (const ip_address& addr) const;
 /// Performs a bitwise OR operation and returns result.

ip_address operator ^ (const ip_address& addr) const;
 /// Performs a bitwise XOR operation and returns result.

ip_address operator ~ () const;
 /// Performs a bitwise NOT operation on this IP address and returns result.
  
socklen_t length() const;
 /// Returns the length in bytes of the internal socket address structure. 
  
const void* addr() const;
 /// Returns the internal address structure.
  
uint32_t af() const;
 /// Returns the address family (AF_INET or AF_INET6) of the address.

unit32_t prefix_len() const;
 /// Returns the prefix length.
  
void mask(const ip_address& mask);
 /// Masks the IP address using the given netmask, which is usually
 /// a IPv4 subnet mask. Only supported for IPv4 addresses.
 /// The new address is (address & mask).
  
void mask(const ip_address& mask, const ip_address& set);
 /// Masks the IP address using the given netmask, which is usually
 /// a IPv4 subnet mask. Only supported for IPv4 addresses.
 /// The new address is (address & mask) | (set & ~mask).
  
static ip_address assign(const std::string& addr);
 /// Creates an IPAddress from the string containing
 /// an IP address in presentation format (dotted decimal
 /// for IPv4, hex string for IPv6).
 /// Depending on the format of addr, either an IPv4 or
 /// an IPv6 address is created.
 /// See to_string() for details on the supported formats.
 /// Throws std::runtime_exception if the address cannot be parsed.

static bool try_assign(const std::string& addr, IPAddress& result);
 /// Tries to interpret the given address string as an
 /// IP address in presentation format (dotted decimal
 /// for IPv4, hex string for IPv6).
 /// Returns true and stores the IPAddress in result if the
 /// string contains a valid address.
 /// Returns false and leaves result unchanged otherwise.

static IPAddress wildcard(Family family = ipv4);
 /// Returns a wildcard IPv4 or IPv6 address.
  
static IPAddress broadcast();
 /// Returns a broadcast IPv4 address (255.255.255.255).
};
}} // namespace std::net

4. Socket Address

This class represents an internet (IP) endpoint/socket address. The address
can belong either to the IPv4 or the IPv6 address family and consists of a
host IP  address and a port number.

4.1 Usage Examples

socket_address wild;
assert (wild.host().is_wildcard());
assert (wild.port() == 0);

socket_address sa1("192.168.1.100", 100);
assert (sa1.host().to_string() == "192.168.1.100");
assert (sa1.port() == 100);

socket_address sa2("192.168.1.100", "100");
assert (sa2.host().to_string() == "192.168.1.100");
assert (sa2.port() == 100);

socket_address sa3("192.168.1.100", "ftp");
assert (sa3.host().to_string() == "192.168.1.100");
assert (sa3.port() == 21);

socket_address sa4("www.appinf.com", 80);
assert (sa4.host().toString() == "50.57.108.29");
assert (sa4.port() == 80);

4.2 Header <socket_address> synopsis

namespace std {
namespace net {
class socket_address
 /// This class represents an (IP) socket address.
 /// The address can belong either to the IPv4 or the IPv6 address
 /// family and consists of a host address and a port number.
{
public:
socket_address();
 /// Creates a wildcard (all zero) IPv4 socket_address.

socket_address(const ip_address& host, uint_16t port);
 /// Creates a socket_address from an IP address and a port number.

socket_address(const std::string& host, uint_16t port);
 /// Creates a socket_address from an IP address and a port number.
 /// The IP address must either be a domain name, or it must
 /// be in dotted decimal (IPv4) or hex string (IPv6) format.

socket_address(const std::string& host, const std::string& port);
 /// Creates a socket_address from an IP address and a
 /// service name or port number.
 /// The IP address must either be a domain name, or it must
 /// be in dotted decimal (IPv4) or hex string (IPv6) format.
 /// The given port must either be a decimal port number, or
 /// a service name (as typically returned in struct servent
 /// by the getservbyname() call.

explicit socket_address(const std::string& host_and_port);
 /// Creates a socket_address from an IP address or host name and a
 /// port number/service name. Host name/address and port number
 /// must be separated by a colon. In case of an IPv6 address, the
 /// address part must be enclosed in brackets.
 /// 
 /// Examples:
 ///     192.168.1.10:80
 ///     [::ffff:192.168.1.120]:2040
 ///     www.appinf.com:8080

socket_address(const socket_address& addr);
 /// Creates a socket_address by copying another one.

socket_address(const struct sockaddr* addr, socklen_t length);
 /// Creates a socket_address from a native socket address.

~socket_address();
 /// Destroys the socket_address.

socket_address& operator = (const socket_address& addr);
 /// Assigns another socket_address.

void swap(socket_address& addr);
 /// Swaps the socket_address with another one.

ip_address host() const;
 /// Returns the host IP address.

uint_16t port() const;
 /// Returns the port number.

socklen_t length() const;
 /// Returns the length of the internal native socket address.

const struct sockaddr* addr() const;
 /// Returns a pointer to the internal native socket address.

uint32_t af() const;
 /// Returns the address family (AF_INET or AF_INET6) of the address.

std::string to_string() const;
 /// Returns a string representation of the address.

ip_address::family family() const;
 /// Returns the address family of the host's address.

bool operator < (const socket_address& addr) const;
 /// Less than operator.

bool operator == (const socket_address& addr) const;
 /// Equal operator.

bool operator != (const socket_address& addr) const;
 /// Not equal operator.

};
}} // namespace std::net

6. Conclusion

Class interfaces for IP and socket address as well as rationale for their 
introduction in C++ Standard and usage examples were described in this 
proposal. This proposal is one of the starting points and building blocks 
for C++ Standard Networking Library. Implementation of the described 
functionality is currently available in POCO framework [6]; the 
implementation differs in naming scheme from this proposal. Given a 
positive feedback on the proposal, implementation  will be available 
in the near future as a standalone implementation in standard-compliant 
naming convention, with accompanying tests and code examples.

7. Acknowledgements

POCO original author (Günter Obiltschnig)
POCO project contributors and users

References

[1] RFC 791
[2] RFC 2460
[3] RFC 4193
[4] RFC 3513
[5] RFC 3879
[6] C++ Portable Components: http://pocoproject.org
[7] List of known POCO users: http://pocoproject.org/forum/viewtopic.php?f=11&t=3826

C++ Internet Protocol and Socket Address Classes

Tukiyooo 0 C++, Internet, IP address, IPv4, IPv4/IPv6, IPv6, Protocol, Socket 19:18

C++ Internet Protocol and Socket Address Classes Document Number: TBD Date: TBD Author: Aleksandar Fabijanic Günter Obiltschnig Content 1. Revision History 2. Motivation and Scope 3. IP Address 3.1. Usage Examples 3.1.1. IPv4 3.1.2. IPv… Read more »

31May2014

Konfigurasi IPV4 ke IPV6 tugas kuliah

Tukiyooo 0 128-bit, 16 bit = 65534, 255.255.255.255, address, Internet Protokol, IP address, IPv4, IPv6, Protokol, Range, router 00:03

Internet Protokol Versi 4  (IPv4)  dan  Internet Protokol Versi 6 (IPv6) I. <a href="http://ipv4-ipv6.blogspot.com/2013/11/konfigurasi-ipv4-ke-ipv6-tugas-kuliah.html">Internet Protokol Versi</a> 4 (IPv4) IPv4 adalah sebuah jenis pengalamatan jaringan yang digunakan di dalam protokol jaringan TCP/IP yang menggunakan protokol IP versi 4. IP versi ini memiliki keterbatasan yakni hanya mampu mengalamati sebanyak 4 miliar host komputer di seluruh dunia. Contoh alamat IPv4 adalah 192.168.0.3 Pada IPv4 ada 3 jenis Kelas, tergantung dari besarnya bagian host, yaitu kelas A (bagian host sepanjang 24 bit , IP address dapat diberikan pada 16,7 juta host) , kelas B (bagian host sepanjang 16 bit = 65534 host) dan kelas C (bagian host sepanjang 8 bit = 254 host ). Administrator jaringan mengajukan permohonan jenis kelas berdasarkan skala jaringan yang dikelolanya. Konsep kelas ini memiliki keuntungan yaitu : pengelolaan rute informasi tidak memerlukan seluruh 32 bit tersebut, melainkan cukup hanya bagian jaringannya saja, sehingga besar informasi rute yang disimpan di router, menjadi kecil. Setelah address jaringan diperoleh, maka organisasi tersebut dapat secara bebas memberikan address bagian host pada masingmasing hostnya. Perbandingan IPv4 dan IPv6 Pemberian alamat dalam internet mengikuti format IP address (RFC 1166). Alamat ini dinyatakan dengan 32 bit (bilangan 1 dan 0) yang dibagi atas 4 kelompok (setiap kelompok terdiri dari 8 bit atau oktet) dan tiap kelompok dipisahkan oleh sebuah tanda titik. Untuk memudahkan pembacaan, penulisan alamat dilakukan dengan angka desimal, misalnya 100.3.1.100 yang jika dinyatakan dalam binary menjadi 01100100.00000011.00000001.01100100. Dari 32 bit ini berarti banyaknya jumlah maksimum alamat yang dapat dituliskan adalah 2 pangkat 32, atau 4.294.967.296 alamat. Format alamat ini terdiri dari 2 bagian, netid dan hostid. Netid sendiri menyatakan alamat jaringan sedangkan hostid menyatakan alamat lokal (host/router). Dari 32 bit ini, tidak boleh semuanya angka 0 atau 1 (0.0.0.0 digunakan untuk jaringan yang tidak dikenal dan 255.255.255.255 digunakan untuk broadcast). Dalam penerapannya, alamat internet ini diklasifikasikan ke dalam kelas (A-E).. Alasan klasifikasi ini antara lain : · Memudahkan sistem pengelolaan dan pengaturan alamat-alamat. · Memanfaatkan jumlah alamat yang ada secara optimum (tidak ada alamat yang terlewat). · Memudahkan pengorganisasian jaringan di seluruh dunia dengan membedakan jaringan tersebut termasuk kategori besar, menengah, atau kecil. · Membedakan antara alamat untuk jaringan dan alamat untuk host/router. Pada tabel dibawah dijelaskan mengenai ketersediaan IPv4 berdasarkan data dari APNIC sampai akhir tahun 1999 yang lalu dan total IP yang sudah dialokasikan ke tiap – tiap negara di Asia Pasifik. II.5 Internet Protokol Versi 6 (IPv6) Transisi IPv4 ke IPv6 merupakan fenomena yang tidak dapat dielakan oleh semua kalangan. Walaupun IPv4 tetap dapat digunakan, IPv6 memiliki versi design berbeda dan memiliki kegunaan lebih dibanding IPv4. Disertai dengan tumbuhnya inovasi-inovasi perangkat berteknologi, maka Negara-negara di dunia dituntut mampu bersaing atau setidaknya secara bertahap mulai untuk mengimplementasikan IPv6. Menurut jurnal Internet Protocol, diperkirakan tak sampai tahun 2011, jatah alamat IP yang masih belum digunakan saat ini akan habis. Maka muncullah suatu metode peangalamatan baru yang dikenal dengan sebutan IPv6. Di Indonesia, salah satu penyedia jasa Internet, Indosat Mega Media (Indosat M2), sejak 2004 telah siap menyewakan jaringan IPv6 ini. IPv6 merupakan metode pengalamatan IP yang perlahan-lahan mulai menggantikan IPv4. IPv6 digunakan sebagai pengalamatan karena keterbatasan jumlah IP yang dimiliki oleh IPv4, mengingat semakin bertambahnya perangkat berbasis IP saat ini. IPv6 atau Internet Protocol version 6 adalah protokol Internet terbaru yang merupakan pengembangan lebih lanjut dari protokol yang dipakai saat ini, IPv4 (Internet Protocol version 4). Pengalamatan IPv6 menggunakan 128-bit alamat yang jauh lebih banyak dibandingkan dengan pengalamatan 32-bit milik IPv4. Dengan kapasitas alamat IP yang sangat besar pada IPv6, setiap perangkat yang dapat terhubung ke Internet (komputer desktop, laptop, personal digital assistant, atau telepon seluler GPRS/3G) bisa memiliki alamat IP yang tetap. Sehingga, cepat atau lambat setiap perangkat elektronik yang ada dapat terhubung dengan Internet melalui alamat IP yang unik. Protokol IPv6 ini memiliki beberapa fitur baru yang merupakan perbaikan dari IPv4,diantaranya : •Memiliki format header baru Header pada IPv6 memiliki format baru yang didesain untuk menjaga agar overhead header minimum, dengan menghilangkan field-field yang tidak diperlukan serta beberapa field opsional Perbandingan IPv4 dan IPv6 yang ditempatkan setelah header IPv6. Header IPv6 sendiri besarnya adalah dua kali dari besar header dari IPv4. •Range alamat yang sangat besar IPv6 memiliki 128-bit atau 16-byte untuk masing-masing alamat IP source dan destination. Sehingga secara logika IPv6 dapat menampung sekitar 3.4 x 1038 kemungkinan kombinasi alamat. •Pengalamatan secara efisien dan hierarkis serta infrastruktur routing Alamat global dari IPv6 yang digunakan pada porsi IPv6 di Internet, didesain untuk menciptakan infrastruktur routing yang efisien, hierarkis, dan mudah dipahami oleh pengembang. • Konfigurasi pengalamatan secara stateless dan statefull IPv6 mendukung konfigurasi pengalamatan secara statefull, seperti konfigurasi alamat menggunakan server DHCP, atau secara stateless yang tanpa menggunakan server DHCP. Pada konfigurasi kedua, host secara otomatis mengkonfigurasi dirinya sendiri dengan alamat IPv6 untuk link yang disebut dengan alamat link-lokal dan alamat yang diturunkan dari prefik yang ditransmisikan oleh router local. •Built-in security Dukungan terhadap IPsec memberikan dukungan terhadap keamanan jaringan dan menawarkan interoperabilitas antara implementasi IPv6 yang berbeda. • Dukungan yang lebih baik dalam hal QoS Pada header IPv6 terdapat trafik yang di identifikasi menggunakan field Flow Label, sehingga dukungan QoS dapat tetap diimplementasikan meskipun payload paket terenkripsi melalui IPsec. • Protokol baru untuk interaksi node Pada IPv6 terdapat Protokol Neighbor Discovery yang menggantikan Address Resolution Protokol. • EkstensibilitasIPv6 dapat dengan mudah ditambahkan fitur baru dengan menambahkan header ekstensi setelah header IPv6. Ukuran dari header ekstensi IPv6 ini hanya terbatasi oleh ukuran dari paket IPv6 itu sendiri.

Konfigurasi IPV4 ke IPV6 tugas kuliah

Tukiyooo 0 128-bit, 16 bit = 65534, 255.255.255.255, address, Internet Protokol, IP address, IPv4, IPv6, Protokol, Range, router 00:03

Internet Protokol Versi 4 (IPv4) dan Internet Protokol Versi 6 (IPv6)I. Internet Protokol Versi 4 (IPv4)IPv4 adalah sebuah jenis pengalamatan jaringan yang digunakan di dalam protokoljaringan TCP/IP yang menggunakan protokol IP versi 4. IP versi i… Read more »

24Nov2013

Address Types & Formats IPv6

Solving the IP Address Chicken-and-Egg Challenge

C++ Internet Protocol and Socket Address Classes

Konfigurasi IPV4 ke IPV6 tugas kuliah

ADV

Populars

Arsip Blog