RFC 8135

Complex Addressing in IPv6

📅 published April 2017, from ietf

Complex Addressing in IPv6 🦋

Okay bestie, let's get into this 💖 Here's the title block, pulled out so you don't have to squint at columns:

  • Number and title: RFC 8135, Complex Addressing in IPv6 🎀
  • Authors: M. Danielson (Net Insight AB) and M. Nilsson (Besserwisser Networks) 👑
  • Stream and category: Independent Submission, and it's Experimental 🧪
  • ISSN: 2070-1721
  • Date: 1 April 2017 (iykyk 💀)
  • Obsoletes or updates: the title block doesn't list anything for either one 🫶

Abstract ✨

okay so the 128-bit length of IPv6 addresses (RFC 4291) lets people cook up brand new, innovative address schemes that can handle today's complex network world 🌈 It also opens the door to new and improved security measures and supports advanced cloud computing challenges. main character energy fr 💅

Status of This Memo 📝

This document is not an Internet Standards Track specification. It's published for examination, experimental implementation, and evaluation 🔍

This document defines an Experimental Protocol for the Internet community. It's a contribution to the RFC Series, independently of any other RFC stream. The RFC Editor chose to publish it at their discretion, and they make no statement about its value for implementation or deployment. Documents approved for publication by the RFC Editor are not a candidate for any level of Internet Standard, see Section 2 of RFC 7841 🙈

For info on the current status of this document, any errata, and how to give feedback, check http://www.rfc-editor.org/info/rfc8135.

Copyright (c) 2017 IETF Trust and the persons identified as the document authors. All rights reserved.

This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, since they describe your rights and restrictions with respect to this document 📜

Table of Contents 🗂️

1. Introduction ....................................................3
2. Requirements Language ...........................................3
3. Natural Addresses ...............................................3
   3.1. Integer Addresses ..........................................3
   3.2. Prime Addresses ............................................3
   3.3. Composite Addresses ........................................4
4. Complex Addresses ...............................................4
   4.1. Floating Addresses .........................................4
   4.2. Real Addresses .............................................5
   4.3. Imaginary Addresses ........................................5
   4.4. Flying Addresses ...........................................5
   4.5. Complex Addresses ..........................................6
5. Supported Addressing Schemes ....................................6
   5.1. Absolute Addresses .........................................6
   5.2. Address Argument ...........................................6
   5.3. Safe Addresses .............................................6
   5.4. Virtual Addresses ..........................................7
   5.5. Rational Addresses .........................................7
   5.6. Irrational Addresses .......................................7
   5.7. Transcendent Addresses .....................................8
6. Geometric Addresses .............................................8
   6.1. Round Addresses ............................................8
   6.2. Square Addresses ...........................................8
   6.3. Polar Addresses ............................................9
   6.4. Root Server ................................................9
   6.5. Implementation Considerations ..............................9
7. IPv6 Address Mapping ...........................................10
8. IANA Considerations ............................................10
9. Security Considerations ........................................10
10. References ....................................................11
   10.1. Normative References .....................................11
   10.2. Informative References ...................................12
Appendix A.  Square Pi ............................................13
Appendix B.  Implementation Example ...............................14
Authors' Addresses ................................................16

1. Introduction ✨

this doc introduces the fundamental concepts of complex addressing in IPv6, so a whole wide range of complex addressing schemes can be supported and developed further 🦋

Traditional network addressing like IPv4 [RFC791] and IPv6 [RFC4291] has been stuck with unsigned or integer numbers, which basically means fixed-point numbers 😩 That gave us natural numbers in the early days, but it's not really built for the challenges of future networks. Also, these fixed addresses have proven unsuitable for mobility and virtualization in today's world, where cloud computing totally defies the traditional fixed addressing model ☁️ The bigger addresses IPv6 allows, the big drop in the price of floating-point hardware, and a well-established floating-point format in IEEE 754 [IEEE754] make it possible to take not just the step to floating-point addressing but also the step to complex addressing. iconic 💅

2. Requirements Language 📖

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 [RFC2119] 🎀

3. Natural Addresses 🌿

3.1. Integer Addresses 🔢

Traditional addresses are integer addresses, and they can be written in a three-dot format. For example, 113.129.213.11 is the integer 1904334091, a rare IPv4 double-palindromic address 🤯 Fixed-point addresses were a great fit for early network usage, when every computer on the Internet had a fixed location and therefore a fixed address. These addresses are also known as natural addresses. As computers got more powerful and could handle bigger numbers (and so bigger addresses), they also got more transportable, like laptops and mobile phones 📱 That transportable aspect makes fixed-point addresses moot, because machines can move around instead of being stuck at one relatively fixed point 🚶‍♀️

3.2. Prime Addresses 💎

The prime address (that's the primary address of a recipient) is an important subclass of integer addresses. Such an address is not divisible by anything but the recipient itself, which means it must be regarded as a unique address. Lots of prime addresses have been identified experimentally, but it's been really hard to pick out a prime address from the others without time-consuming computations 😮‍💨 Current use includes security and intelligence, where post boxes are hidden among others by using large prime addresses 🕵️‍♀️

3.3. Composite Addresses 🧩

Composite addresses are formed from two or more prime addresses, so they're a shared address that can be home to multiple prime addresses 🏠 Large composite addresses can be hard to tell apart from prime addresses, which can be a factor to consider. Composite addresses are also a big deal in addressing new light structures, and they're used in airplanes to make them lightweight and durable ✈️ This is important for connecting to the cloud. obsessed 😭

4. Complex Addresses 🌈

4.1. Floating Addresses 🎈

Floating-point addresses allow a more flexible addressing scheme that's better suited to today's mobile computers, which is what enables mobile IP [RFC5944]. Floating-point support is well established through floating numbers as described in IEEE 754 [IEEE754]. That lets both 32-bit and 64-bit floating-point numbers be represented, which is a great match for fitting into a 128-bit IPv6 address 💜

Using floating addresses does not, however, mean devices will be watertight. Please download the watertight app from your app store or distribution server 📲 Also, keep your device well patched, because the long-term durability of duct tape is limited, especially if you expect exposure to salt water 🧂 Apply suitable environmentally sound lubricants for the best sliding performance 🧴

Duct tape can be used to affix a floating address to a fixed address, such as a physical address. For long-term outdoor adhesion, please use UV-stable, nuclear-grade duct tape in layers: Layer 1 [OSI], the physical layer, for affixing the floating address to the physical address, and then the final layer, called Layer 7, for applying UV protection ☀️ Intermediate layers can be added depending on how complex you need it to be. 🔥

4.2. Real Addresses 🏡

An important thing about floating-point addresses is that you need to establish the real address of a device that has a floating address, so IP packets can be routed to it through the network 🗺️ Letting part of the address act as the real floating-point value lets you express real addresses within this scheme, which solves a complex addressing problem. genius, honestly 👑

Real addresses are typically assigned to real estate. Multi-homing is supported when the real estate connects to two or more road networks over individual road interfaces 🛣️ Each road interface can often handle multiple real addresses. Mobile homes get assigned their current real address 🚐

4.3. Imaginary Addresses 🔮

Another important thing about floating-point addresses is that they can be in several possible locations, so you have to be able to imagine the address somewhere other than where the real address would make you believe. The imaginary address gives you this orthogonal property 📐 When the imaginary address is found to be 0, the imaginary address and the real address are considered equal, and the real address has been found 🎯

Imaginary addresses matter for home locations above the normal real estate, which is to say cloud computing ☁️ The cloud can be identified using the imaginary address, whose floating address gets adapted to a real address as the cloud gently floats by 🫧 During windy conditions this may be difficult to achieve, and during network storms the real address of a cloud can become very unstable 🌪️ Storms can occasionally get so strong that they impact real estate and rearrange homes, which makes the real address quite surreal 🙃

4.4. Flying Addresses 🦅

The flying address format is an extension of the imaginary address, and it's adapted to the mobility of avian carriers 🐦 Avian carriers and their datagrams, as described in [RFC6214], are best addressed with flying addresses. These typically take up ICAO Class G [ICAO-A11] airspace, below the cloud, which is what you'd expect from a lower-layer technology 🪶

4.5. Complex Addresses 🌈

okay so once the real and imaginary address parts are in, the full width of complex addresses finally gets to shine ✨ Both parts are stored as 64-bit floating-point numbers, as described in [IEEE754], which is what makes the floating-point side of addresses work 💖 The real address part is the real address of a device. The imaginary part gives you orthogonal addressing for that floating-point address 🦋 Put them together and you get complex addressing schemes where both the real and imaginary addresses can be found, which is literally iconic.

Complex addresses still do address arithmetic the usual way, but now they can go beyond the fixed-point limitations 🔥 Adding imaginary parts to an address wasn't really possible before, because early floating-point hardware was so expensive, and that kinda hampered imagination 💀

5. Supported Addressing Schemes 👑

5.1. Absolute Addresses 🎀

Establishing the absolute address of a device has become SO important for lots of reasons, including but not limited to use by law enforcement 🚨 Fixed-point addresses made it manageable, but it's gotten harder with more address mobility and floating-point addresses 😭 The complex address scheme gives you a method for getting the absolute address by performing the absolute function on the complex address.

5.2. Address Argument 🧚

It's becoming super obvious that people argue about the address of certain services or functions, and that's how we get address arguments 🙈 Fixed-point addresses struggle here because their one-dimensional form doesn't let an argument be resolved. The complex addressing scheme is an elegant fix, since the result of the address argument can trivially be found by taking the argument (i.e., arctan or atan) function of the complex address. With the appropriate function, full argument resolution can be found without signs of ambiguity 💅

5.3. Safe Addresses 🫶

A safe address is the address of a safe house 🏠 It's used in various security scenarios. The safety is that people in need can reach the safe house at the safe address, but there's no indication that the address has this role 🤫 By using imagination, the address can be made less real by making the imaginary part large enough that it can't be taken as a real address. Since it's a floating address, the real address can be set to 0, which makes it completely imaginary. The address argument is then orthogonal to any real address, so it's hard to establish its real address. It's still naturally possible to establish the absolute address when needed.

5.4. Virtual Addresses 🌸

Virtual addresses, where the same network interface can have multiple addresses, have traditionally been a huge deal 🍓 With the complex addressing scheme, the imaginary part allows for a much wider range of virtualization than just normal multiple real addresses on one interface. This goes beyond normal cloud computing, where virtualization just lets you operate somebody else's computer ☁️ The new imaginative address capabilities and higher altitude addresses, thanks to the increased range, let you operate a cloud within a cloud, so you just run on top of somebody else's cloud 🤯 That high altitude allows for supersonic cruise speed for high-performance computing 🚀

5.5. Rational Addresses 💜

Engineers always look at problems rationally, addressing included 🧠 The traditional fixed-point address has only supported a subset of rational addresses. With the new complex addressing scheme, a larger subset of rational addresses can be reached or approximated, allowing for a larger rationale to be found ✨

The rationale here is that with floating addresses, the power of 2 can now divide perfectly. Approximations for other dividends can often be sufficiently precise. The full scope of rational numbers hasn't been reached yet, though, because the committee was quite imprecise on the use of floating addresses. They did agree that this initial support for rational addresses could be acknowledged and helpful while its usage is TBD 🤷‍♀️

5.6. Irrational Addresses 🌙

Support for irrational addresses has been very poor in the traditional scheme, since fixed-point addresses didn't support any irrational behavior by design, even if proofs for irrational addresses have been known to be jotted down 📝 The new scheme allows approximations of irrational addresses to be supported. No rationale for why this would be needed could be found, but it's a neat feature for handling the irrationality of the world today 🌍

5.7. Transcendent Addresses 🌌

As a natural extension of irrational addresses, you can include approximations to transcendent addresses, which transcend beyond the physical address or even the real address 👻 They're only approximated due to limited precision, but they can still be used to locate the floating address for the life of Pi [PI], as Pi's life floats by 🥧

6. Geometric Addresses 📐

6.1. Round Addresses 🔵

To cope with the complexity of the real world, real addresses (both rational and irrational) have always needed to be rounded up so they can be represented. This rounding gives what's known as round addresses, and it's achieved using a rounding function 🎯 The complex addressing scheme keeps this practice, and it's a necessity for supporting rational and irrational addresses.

Round addresses are needed to efficiently forward packets around ring-type networks like Token Ring [IEEE-802.5] or Resilient Packet Ring (RPR) [IEEE-802.17] 💍

Common round words include "ring", "circle", and "sphere". Other round words are discouraged, especially when using the network 🙅

6.2. Square Addresses ⬜

As is well established, some addresses regularly in use cannot be directly used on the Internet 😤 Addresses in text form are often called square addresses, because the characters traditionally take up a square on the screen and because they act as a square peg in the round hole of Internet addresses 🟦 To convert these square addresses into round floating-point numbers, the Domain Name Service (DNS) was introduced to replace the host tables.

Host tables were the old-school way of looking up a square number and converting it to round form 📚 Such tables were published for all known square numbers, but they were inherently out of date, because new square numbers kept occurring. New round numbers had to be calculated from these square numbers, and then tabulated and published, over and over again 🥲

Square addresses often use square pi (see Appendix A) 🥧⬜

6.3. Polar Addresses 🧭

A misconception about square addresses is that they represent the world as a flat earth 🌍 While the complex addressing scheme supports Cartesian coordinates, alternative polar addresses can be formed too. Since a flat earth wouldn't have poles for the rotation axis to fit through, this proves that the earth is not flat in terms of square addresses, and only has a square address representation 🙃 Polar addresses are trivially achieved using the absolute address and address argument methods. Recovering the complex address is trivially achieved using the exponential function on the complex polar address.

The polar address also has a use for addressing Santa Claus, who is well known for living at the North Pole 🎅 This address can only be reached by use of the imaginary address, because it takes a certain amount of imagination to address Santa Claus 🎄 Traditional integer and fixed addressing schemes don't allow for such imaginative addresses, but the complex addressing scheme trivially handles it. The North American Aerospace Defense Command (NORAD) Santa Tracker would not have been possible without imaginative use of polar addresses when their secret phone address was revealed 📞

6.4. Root Server 🌳

The DNS system uses a small set of known root servers, which provide the root service in order to attain the address of a node. The complex address provides a solution where each client can act as a root server itself, since it can use built-in floating-point hardware or software to get the root address from the squared address 💪 This offloads the root servers for common benefit, and the traditional root servers can still operate in parallel, which eases the transition to the complex address system.

6.5. Implementation Considerations 🛠️

Implementing floating-point addresses and complex addresses, as complex addressing schemes need, is trivial in today's context ✅ IEEE 754 [IEEE754] allows for a common and agreed-upon format for representing floating-point numbers. The 64-bit floating-point representation is well established and supported across a wide range of devices. Support also exists in a wide range of computer languages, including C and FORTRAN 💻 The C standard library (or libc) essentially makes all modern languages support it in a consistent manner. An independent implementation exists for Intercal 🤪 With ISO C99 [C99], the <complex.h> include provides even more direct support for complex numbers, enabling efficient handling of all aspects of complex addressing with minimal implementation effort.

7. IPv6 Address Mapping 🗺️

To carry complex addresses inside the IPv6 address format, here's the mapping:

 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|6                                                             3|
|3               complex address (real part)                   2|
+---------------------------------------------------------------+
|3                                                              |
|1               complex address (real part)                   0|
+---------------------------------------------------------------+
|6                                                             3|
|3            complex address (imaginary part)                 2|
+---------------------------------------------------------------+
|3                                                              |
|1            complex address (imaginary part)                 0|
+---------------------------------------------------------------+

The 128-bit IPv6 address is split into two 64-bit parts 🪞 The upper half holds the real part of the address, while the lower half holds the imaginary part of the complex address. These are represented as 64-bit floating-point numbers defined in [IEEE754], so the real and imaginary address MUST be in the format described in IEEE 754 ✨

Since the real address is held in the real part of the complex address, and the imaginary address is held in the imaginary part, the proposed representation lets a compiler optimize these operations so they run without performance hits, which you could otherwise expect with any real or complex addressing scheme 🏎️

8. IANA Considerations 🦄

This document does not require any IANA actions, though IANA may find it mildly amusing 😂

9. Security Considerations 🔐✨

okay bestie, security time, and this one is SERIOUS 💀 complex addressing is considered unsafe, because dividing by 0 still gives you a Not a Number (NaN) value. users have to be careful and spot the NaN, since it can point to infinity addresses. those are unrealistic, because you have to keep the address length inside the address space 🙈

lowkey though, a lot of the old-school unsafe stuff for fixed-point addresses has been fixed 🫶 for example, the error where you get the square address of -1 is easily handled, because the root address turns into the complex address i. it has a real part of 0, which is valid for an address that isn't real, and an imaginary part of 1, which makes sense because you can totally picture this error happening 🦋

division by 0 and other floating-point address calculations can cause a floating-point interrupt 😭 that makes the execution address drift off course. the address usually gets pushed onto a stack and swapped out for the interrupt handler's address. recovering from these interrupts may need more recursive calls, so the total computation time is unpredictable ⏳ it can even cause a complete core dump, and dumping the core can seriously affect the propulsion system and how long it takes to reach anywhere in the address space 💀 so be careful and avoid stuff like this, or engineering is gonna be SO upset 😤 dumping the core also breaks security protocols widely, because leaks can have huge consequences. and NaN is also known as "No Agency Number", to remind everyone how important it is to keep things secure 🔒💜

10. References 📚

10.1. Normative References

10.2. Informative References

  • [ICAO-A11] ICAO, "Air Traffic Services, Annex 11 to the Convention on International Civil Aviation", July 2001, <http://www.icao.int/secretariat/PostalHistory/annex_11_air_traffic_services.htm>.
  • [IEEE-802.17] IEEE, "IEEE Standard for Information Technology - Telecommunications and Information Exchange between Systems - Local and Metropolitan Area Networks - Specific Requirements Part 17: Resilient Packet Ring (RPR) Access Method and Physical Layer Specifications", IEEE 802.17, DOI 10.1109/IEEESTD.2011.6026209.
  • [IEEE-802.5] IEEE, "IEEE Standard for Information Technology - Telecommunications and Information Exchange between Systems - Local and Metropolitan Area Networks - Part 5: Token Ring Access Method and Physical Layer Specifications", IEEE 802.5, DOI 10.1109/IEEESTD.1992.7438701.
  • [PI] "Life of Pi", 20th Century Fox, 2012.
  • [pibill] Wikipedia, "Indiana Pi Bill", March 2017, <https://en.wikipedia.org/w/index.php?title=Indiana_Pi_Bill&oldid=770393894>.
  • [RFC5944] Perkins, C., Ed., "IP Mobility Support for IPv4, Revised", RFC 5944, DOI 10.17487/RFC5944, November 2010, <http://www.rfc-editor.org/info/rfc5944>.

Appendix A. Square Pi 🟦💖

when you're working with square numbers, it's customary to use square pi 🙌 it doesn't show up much in regular textbooks, but it's everywhere in computer science. so it's only right to share a few notes on square pi, so that people using square addresses know how to use it properly 🎀

okay so regular pi, or round pi, is an irrational number 🌀 you can round it to 3.14 or 3.14159, and it has an absurd number of decimals, which is honestly not a vibe for a round number. but every time we round it to fit our needs, we're kind of making it rational, even though it's irrational underneath 🥹

the radius of an object is the closest distance from the center to the object 🎯 the circumference is the radius times 2 pi. the diameter is the shortest distance across the object, which is the radius times 2. the area is pi times the square of the radius 📐

for a round circle, the radius reaches anywhere on the circumference ⭕ but for a square circle, the radius only touches the circumference at the four points closest to the center 🟪 those points are usually lined up so the real and imaginary axes go right through them, which is super helpful for calculations, and you don't have to think about rotation symmetries 🧚

square pi does the same job as round pi, except it's built for square objects instead of round ones 💅 for a square circle, the math works out exactly the same as for round circles, as long as you use square pi with square circles and round pi with round circles. don't mix them up, bestie 🙅‍♀️

the value of square pi is 4 🌸

square pi fits really well with how computers calculate, which is also why computer results often come out as square numbers, giving that little square feeling ✨ people also often use the square root of pi, and the square root of square pi is naturally 2. that's super easy to work with in calculations and cuts down the risk of irrational numbers 👑

please note that square pi should not be mixed up with the Indiana Pi Bill [pibill] 🙃 that bill doesn't talk about square pi at all. it's about a failed attempt to do square calculations of the area and circumference of a round circle using traditional tools like rulers and compasses 💀

Appendix B. Implementation Example 🍓💻

this is a simple implementation example that shows how some core concepts can be built in <complex.h> (as defined in ISO C99 [C99]) 🧚‍♀️

#include <complex.h>
#include <math.h>
#include <stdio.h>

// Define type for complex address
typedef complex ca;

// Create complex address
ca ca_create_complex_address(double real_address,
        double imaginary_address)
{
        return real_address + I * imaginary_address;
}

// Get real address
double  ca_get_real_address(ca ca_val)
{
        return creal(ca_val);
}

// Get imaginary address
double  ca_get_imaginary_address(ca ca_val)
{
        return cimag(ca_val);
}

// Get complex address
complex ca_get_complex_address(ca ca_val)
{
        return ca_val;
}

// Get floating address
double  ca_get_floating_address(ca ca_val)
{
        return creal(ca_val);
}

// Get physical address
double  ca_get_physical_address(ca ca_val)
{
        return cimag(ca_val);

}

// Get absolute address
double  ca_get_absolute_address(ca ca_val)
{
        return cabs(ca_val);
}

// Get address argument
double  ca_get_address_argument(ca ca_val)
{
        return carg(ca_val)*360/(2*M_PI);
}

int main()
{
        ca ca1, ca2;

        ca1 = ca_create_complex_address(1.0, 0.0);
        printf("The complex address (%f,%f)\n",
                creal(ca1), cimag(ca1));
        printf("has the real address %f and imaginary address %f\n",
                ca_get_real_address(ca1),
                ca_get_imaginary_address(ca1));
        printf("This represents the floating address %e and \
physical address %f\n", \
                ca_get_floating_address(ca1),
                ca_get_physical_address(ca1));
        ca2 = ca_create_complex_address(0.0, 1.0);
        printf("The complex address (%f,%f)\n",
                creal(ca2), cimag(ca2));
        printf("This represents the absolute address %f\n",
                ca_get_absolute_address(ca2));
        printf("The address argument resolution is %f\n",
                ca_get_address_argument(ca2));
        return 0;
}

Authors' Addresses 💌

Magnus Danielson
Net Insight AB
Vastberga Alle 9
Hagersten  12630
Sweden

Email: magda@netinsight.net


Mans Nilsson
Besserwisser Networks

Email: mansaxel@besserwisser.org

That's the whole RFC, bestie! 🌈💖 Thanks for slaying it with me 👑✨

📦 where this page comes from