Bellcore
April 1991
On the Assignment of Subnet Numbers
Status Of This Memo

This memo suggests a new procedure for assigning subnet numbers. Use of this assignment technique within a network would be a purely local matter, and would not effect other networks. Therefore, the use of these procedures is entirely discretionary.
This memo provides information for the Internet community. It does not specify an Internet standard. Distribution of this memo is unlimited.
Overview

RFC950 [2] specifies a procedure for subnetting Internet addresses using a bitmask. While RFC950 allows the "ones" in the subnet mask to be noncontiguous, RFC950 recommends that 1) they be contiguous, and 2) that they occupy the most significant bits of the "host" part of the internet address.
RFC950 did not specify whether different subnets of the same network may have different masks. This ambiguity was unfortunate, as it resulted in development of routing protocols that do not support different masks; see e.g., RIP [6]. The Gateway Requirements RFC [7] settled the issue in favor of allowing different masks, and therefore future routing protocols may be expected to support this feature; OSPF [3] is an example.
The network administrator must of course determine the mask for each subnet. This involves making an estimate of how many hosts each subnet is expected to have. As it is often impossible to predict how large each subnet will grow, inefficient choices are often made, with some subnets underutilized, and others possibly requiring renumbering because of exceeded capacity.
This memo specifies a procedure for assigning subnet numbers that eliminates the need to estimate subnet size. Essentially, host bits (mask = 0) are assigned from the least significant bit working towards the most, and subnet bits (mask = 1) are assigned from the most significant bit working towards the least. As subnets grow, more host bits are assigned. As the number of subnets grows, more subnet bits are assigned. While this process does sometimes result in new subnet masks, no host ever need change addresses.
This technique is not new, but it is also not widely known, and even less widely implemented. With the development of new routing protocols such as OSPF, it is possible to take full advantage of this technique. The purpose of this memo, then, is to make this technique widely known, and to specify it exactly.
This memo requires no changes to existing Internet standards. It does, however, require that the intradomain routing protocol handle multiple different subnet masks.
Acknowledgments

The author would like to thank Phil Karn, Charles Lynn, Jeff Mogul, and Charles Wolverton for their helpful suggestions. Special thanks go to Joel Halpern for his painstaking debugging of the detailed specification and the examples.
1. Motivation

The Subnetting standard, RFC950, specifies that the Host part of the formally 2level Internet address can be divided into two fields, Subnet and Host. This gives the Internet address a third level of hierarchy, and the concomitant firewalls and savings in routing overhead. It also introduces increased inefficiency in the allocation of addresses.
This inefficiency arises from the fact that the network administrator typically overestimates the size (number of hosts) of any single subnetwork, in order to prevent future readdressing of subnets. It may also occur if the routing protocol being used does not handle different length subnets, and the administrator must therefore give every subnet an amount of space equivalent to that received by the largest subnet. (This RFC does not help in the latter case, as the technique herein requires different length subnets.)
The administrative hassle associated with changing the subnet structure of a network can be considerable. For instance, consider the following case. A network has three subnets A, B, and C. Assume that the lowest significant byte is the host part, and the next byte is the subnet part (that is, the mask is 255.255.255.0). Assume further that A has subnet 1.0, B has subnet 2.0, and C has subnet 3.0.
Now, assume that B grows beyond its allocation of 254 hosts. Ideally, we would like to simply change B's mask without changing any of the host addresses in B. However, the subnets numerically above and below B are already taken by A and C. (If say 3.0 was not taken by C, B's mask could be changed from 255.0 (ff00) to 254.0 (fe00). In this case, all of B's existing addresses would still match the new subnet. Indeed, if noncontiguous masks were in use, it might be possible for B to find some other mask bit to change to 0. However, noncontiguous masks are generally not in favor, as they impose limitations on certain forwarding table lookup algorithms. Indeed, RFC950 discourages their use.)
So, the choices available to the network administrator are to 1) form two subnets out of the existing one, or 2) renumber the subnet so that the subnet ends up with a smaller (fewer 1's) mask. Choice 1 can either be accomplished physically or logically. Physically forming two subnets requires partitioning the subnet and inserting a gateway between the two partitions. For obvious reasons, this is not a desirable course of action. Logically forming two subnets can be done by simply assigning another subnet number (say 4.0) to the same subnet, and assigning host addresses under the new subnet. The result of this logical partition is that the hosts with different subnet numbers will not recognize that the others are on the same subnet, and will send packets to the default gateway rather than directly to the host. In fact, this is not such a bad solution, because assuming that the gateway is capable of recognizing multiple subnet numbers on the same subnet, the gateway will simply send the host an ICMP Redirect [4], and subsequent packets will go directly to the host [1] (this may not work correctly on all hosts).
If, however, neither choice is acceptable or possible, then the network administrator must assign a new subnet number to B, thus renumbering the existing hosts, modifying the Domain Name System entries, and changing any other configuration files that have hardwired addresses for hosts in subnet B.
2. A More Flexible and Efficient Technique for Assigning Subnet Numbers

In order to help explain the new technique, we shall show what is wrong with what is currently done now. Currently, most subnets are assigned by splitting the host part of the address in two fields; the subnet field and the host field. Mask bits are one for subnet field bits, and 0 for host field bits. (In all of our addresses, the least significant bit (LSB) is on the right, the most significant bit (MSB) is on the left.)
MSB LSB   subnet field  host field  
The subnet field could be different lengths for different size subnets. For instance, say a network had two large subnets and the rest small subnets (by large subnet we mean a large number of hosts). Then the network administrator might assign two types of addresses:
  subnet  host  large subnets    subnet  host  small subnets 
In this case, the full range of subnet numbers would not be available to the small subnets, as the bits in the small subnet that correspond to those in the large subnet could not have the same values as those in the large subnets. For instance, say that the large subnets had 4bit subnet numbers, and the small subnets had 8bit subnet numbers. If the large subnets had values 0001 and 0010, then subnet numbers in the range 00010000 to 00101111 could not be assigned to the small subnets, otherwise there will be addresses that would match both subnets.
In any event, a network administrator will typically assign values to the two fields in numerical order. For example, within a given subnet, hosts will be numbered 1, 2, 3, etc. Within a given network, subnets will be numbered 1, 2, 3, etc. The result is that some number of bits on the right side of the subnet and host fields will be ones for some hosts and zeros for others, and some number of bits on the left side of the subnet and host fields will be zeros for all subnets and hosts. The "all zeros" bits represent room for growth, and the "ones and zeros" bits represent bits already consumed by growth.
  subnet field  host field  +++       0's  1's & 0's  0's  1's & 0's  /\ /\   subnets can hosts can grow here grow here
Now, let's assume that the number of hosts in a certain subnet grows to the maximum allowed, but that there is still room in the subnet field to assign more addresses. We then have the following:
  subnet field  host field  ++      0's  1's & 0's  1's & 0's 
While the host field can no longer grow, there is still room in the address for growth. The problem is that because of where the growth areas are situated, the remaining growth has been effectively reserved for subnets only.
What should be done instead is to assign subnet numbers so that the ones start from the left of the subnet field and work right. In this case we get the following:
  subnet field  host field  ++      1's & 0's  0's  1's & 0's  /\  Both hosts and subnets can grow here
Now, both hosts and subnets individually have considerably more growing space than before, although the combined growing space is the same. Since one can rarely predict how many hosts might end up in a subnet, or how many subnets there might eventually be, this arrangement allows for the maximum flexibility in growth.
Actually, the previous figure is misleading. The boundary between the host and subnet fields is being shown in the middle of the growth area. However, the boundary could exist anywhere within the growth area. Note that it is the mask itself that determines where the boundary is. Ones in the mask indicate subnet bits, and zeros indicate host bits. We will show later that in fact the boundary should lie somewhere in the middle. Putting it there minimizes the number of times that the masks must be changed in hosts.
2.1 Specification of the New Technique
Having given the appropriate explanatory material, we can now specify the procedure for subnet number assignment. We need the following definitions:
Hostassigned Bits (hbits): These are the bits, contiguous from

the right, for which host values, within a given subnet, contain both ones and zeros. Different subnets may have different hbits.
Subnetassigned Bits (sbits): These are the bits, contiguous from the left, which 1) are not hbits, AND 2) are required to distinguish one subnet from another, AND 3) include all bits to the left of and including the rightmost one. Notice that different subnets may have different sbits. Growth Bits (gbits): These are the "all zeros" bits in between the hbits and sbits. smask: For a given subnet, the mask whereby all sbits are one, and all gbits and hbits are zero. gmask: For a given subnet, the mask whereby all sbits and gbits are one, and all hbits are zero. Subnet Field: These are the one bits in the subnet mask (as defined in RFC950). These bits are on the left. The subnet field must at least include all of the sbits, and may additionally include some or all of the gbits. Host Field: These are the zero bits in the subnet mask. These bits are on the right. The host field must at least include all of the hbits, and may additionally include some or all of the gbits. Mirrorimage Counting: Normal counting, in binary, causes one bits to start at the right and work left. This is how host values are assigned. However, for subnet assignment, we want the one bits to start at the left and work right. This process is the mirror image of normal counting, where the MSB is swapped with the LSB, the second MSB is swapped with the second LSB, and so on. So, where normal counting is: 0 (reserved to mean "this host") 01 10 011 100 101 : : 11...1110 11...1111 (reserved to mean "all hosts")

and so on, Mirrorimage, or MI counting, is:
0 (reserved to mean "this subnet") 10 01 110 001 101 : : 011...11 111...11 (reserved to mean "all subnets")

and so on. If the current MI counting value is, say, 001, the "next" MI value is 101, and the "previous" MI value is 11.
Now we can specify the algorithm. We have the following functions: Initialize(), AddSubnet(), RemoveSubnet(subnet#), AddHost(subnet#), and RemoveHost(subnet#,host#).
Notice that the algorithm is described as though one state machine is executing it. In reality, there may be a root Address Authority (RootAA) that assigns subnet numbers (Initialize, AddSubnet, and RemoveSubnet), and subnet AA, that assign host numbers within a subnet (AddHost and RemoveHost). While in general the AAs can act independently, there are two cases where "coordination" is required between the rootAA and a subnetAA. These are the cases where either the rootAA or the subnetAA "grabs" the last growth bit (in the former case because another subnet has been added, and in the latter because another host has been added). Since it is impossible for the rootAA and a subnetAA to simultaneously grab the last growth bit, either one or the other must do it.
Finally, note that the following C language style notation is used:
& bitwise AND function == is equal to != is not equal to xmask(X) the xmask of X (where x is s or g)
Initialize():

Assign the first subnet value to be 0 (the value reserved to mean "this subnet"). This is not assigned to any real subnet.
AddSubnet():
1. Find the lowest nonzero (in MI counting) nonassigned subnet number S such that (S & gmask(Y)) != (Y & gmask(Y)) for all existing subnet numbers Y, (Y != S). 2. If all bits in S from the rightmost one bit left are ones, then label all bits to the left of and including one bit position to the right of the rightmost one bit in S to be sbits. Else, label all bits to the left of and including the rightmost one bit in S to be sbits. This prevents the "all ones" value (which is the "all subnets" broadcast address) from being assigned to a subnet. (Since no hosts have been added, the rightmost one bit is a subnet bit.) 3. Label all other bits in the address to be gbits. (By address, we mean that part of the IP address not including the network number.) 4. Set the subnet mask to include at least all sbits, and optionally some gbits. The subnet mask must be contiguous. (Section 2.2 discusses the pros and cons of choosing a mask.) 5. For all existing subnet numbers Y (Y != S): 51. If (S & smask(Y)) == (Y & smask(Y)), then: 511. Change the leftmost gbit of Y to an sbit. If the rootAA and YAA (the address authority for Y) are separate AAs, then the YAA must be informed of the change of bit status. If this is the last gbit, then this change must be coordinated with YAA. 512. Expand the subnet mask for all hosts in Y if necessary (that is, if the subnet mask no longer includes all sbits).
RemoveSubnet(S):

1. Consider B to be the bit position of the rightmost sbit in S. 2. Remove S.
3. For all existing subnet numbers Y:
31. If the bit in position B is not an sbit, or if the bit in bit position B is a one, or if the bit in bit position B is a zero and all bits to the left of bit position B are ones, then do nothing (skip steps 32 and 33). 32. Change the sbit in position B to a gbit. 33. If for any other existing subnet numbers X (X & smask(Y)) == (Y & smask(Y)), then change the gbit in position B back into an sbit for Y. Else, inform YAA that of the change of bit status.
AddHost(S):
1. Create an address A consisting of subnet number S concatenated with zeros. 2. Assign to A the same hbits, gbits, and sbits as the other host addresses. 3. Find the lowest nonzero (using normal counting) nonassigned host number H. 4. If all bits from the leftmost one bit to bit position 0 are ones, then execute steps 5 and 6 using bit position B equals one bit position to the left of the leftmost one bit in H. Else, execute steps 5 and 6 with bit position B equals the leftmost one bit in H. This prevents the "all ones" value (which is the "all hosts" broadcast address) from being assigned to a host. 5. If bit position B is an sbit, then the host cannot be added. Skip the remaining steps. 6. If bit position B is a gbit: 61. Change the gbit to an hbit for all hosts in S. Note that if this is the last gbit, this change must be coordinated with the address authority assigning subnet numbers (see section 2.2). 62. Modify the subnet mask in all hosts if necessary. 7. Create a new address A consisting of S concatenated with H 8. Assign A to the host.
RemoveHost(S,H):

1. Remove H.
2. If for all remaining host numbers in S, the value of the bit
position of the leftmost hbit is zero, and there is a zero in at least one of the bit positions to the right of the leftmost hbit, then for all hosts change the leftmost hbit into a gbit.
It is worth noting here that this technique is a 2level subset of the more general nlevel kampai addressing [5]. The main difference here is that nlevel kampai results in noncontiguous masks, while 2level does not. In the description of kampai addressing in [5], gbits are called abits, hbits are called gbits, and sbits are called ibits.

2.2 An Example
For this example, we assume a class C network, so we will only need to work with 8 bits. We start with 3 subnets, A, B, and C. Our nomenclature is h for hbit and g for gbit. Note that hbits can be one or zero, but gbits are all zero. The remaining bits are sbits, but are shown as 1's and 0's according to the subnet number assignment. The space is just to make the addresses and masks easier to read. Finally, we number our bits 0 to 7 from right to left as shown below.
Subnet Address Mask A 10gg ghhh 1111 0000 B 01gg ghhh 1111 0000 C 110g ghhh 1111 0000 bit 7 bit 0
We see that each subnet has at most 6 hosts (because of the three h bits). Notice that we have chosen the masks so that there is room for growth in both hosts and subnets without requiring a mask change.
However, we have generally allowed for more growth in subnets than in hosts because adding new subnets can cause mask changes in existing subnets, while adding new hosts in a subnet only causes that subnet's mask to change.
Further, if a subnet's mask must change, but not all hosts are reconfigured at the same time, then it is less damaging if the not yet reconfigured hosts have too large a mask (too many ones) than if they have too small a mask. This is because with too large a mask, a host may think that another host which is in fact on the subnet is on another subnet. In this case, the host will send packets to the gateway, and will be redirected to the host.
However, with too small a mask, a host may think that another host which is in fact not on the subnet is on the subnet, and will ARP for that host but receive no reply. (Note that broadcasts may fail if all masks do not match.)
Finally, notice that subnet C requires three sbits instead of just two. This is because with just two, the subnet address of C could be "11" (rather than "110"), which is a broadcast value. Step 2 of AddSubnet checks for this case.
Now, a fourth subnet, D, also with 6 hosts, is added. We get:
Subnet Addr Mask A 10gg ghhh 1111 0000 B 01gg ghhh 1111 0000 C 110g ghhh 1111 0000 D 001g ghhh 1111 0000
Notice that none of the original subnets required a change in any of their status bits. This is because, when D compared its subnet number with the others (step 5 of AddSubnet(), using the smask), they were all different. In other words, a router would be able to distinguish an address in D from addresses in A, B, and C.
Next, a fifth subnet, E, is added. We get:
Subnet Addr Mask A 100g ghhh 1111 0000 B 01gg ghhh 1111 0000 C 110g ghhh 1111 0000 D 001g ghhh 1111 0000 E 101g ghhh 1111 0000
Notice that this time, A was forced to change its leftmost gbit (bit 5) into an sbit, because bit 5 is needed to distinguish subnet A from subnet E (step 511 of AddSubnet()). Changing bit 5 into an s bit prevents hosts from being added to A to the point where bit 5 would be changed into a one (that is, step 5 of AddHost() would fail).
Notice also that if the masks in A, B, and C were originally set to 1100.0000, then the addition of E would have caused A's mask to change to 1110.0000 (Step 512 of AddSubnet()).
Next, 8 hosts each are added to subnets A and C, thus causing the rightmost gbit in each to change to an hbit.
Subnet Addr Mask A 100g hhhh 1111 0000 B 01gg ghhh 1111 0000 C 110g hhhh 1111 0000 D 001g ghhh 1111 0000 E 101g ghhh 1111 0000
Notice again that no masks have changed. If the masks for A, B, and C were originally set to 1111 1000, then they would have required changing (step 62 of AddHost()).
Next, enough hosts are added to subnet B that all of its remaining gbits become hbits.
Subnet Addr Mask A 100g hhhh 1111 0000 B 01hh hhhh 1100 0000 C 110g hhhh 1111 0000 D 001g ghhh 1111 0000 E 101g ghhh 1111 0000
Notice here that the masks in B's subnet had to be changed to accommodate the new hbits (step 62 of AddHost()). Notice also that if the person assigning host addresses for B (B Address Authority, or BAA) is different than the person assigning network numbers (RootAA), then BAA must coordinate the change of its last gbit to an hbit with the RootAA. This allows the RootAA to properly assign additional subnet numbers, as in the next step, where we add another subnet F:
Subnet Addr Mask A 100g hhhh 1111 0000 B 01hh hhhh 1100 0000 C 110g hhhh 1111 0000 D 001g ghhh 1111 0000 E 101g ghhh 1111 0000 F 1110 ghhh 1111 0000
Notice that F received subnet number 1110 rather than subnet number 011 (which is what comes after 101 in MI counting). The reason is that 1) 011 is not distinguishable from B's subnet address using B's mask, and 2) we can't increase B's mask to make it distinguishable because B has already assigned hosts at bit position 5. In other words, when the comparison of step 1 in AddSubnet() was tried on number 011, the two values were equal, and so the next number was tried. In fact, no subnet numbers with 01 in bit positions 7 and 6 can be assigned (unless B loses hosts).
Next, subnet E is removed:
Subnet Addr Mask A 10gg hhhh 1111 0000 B 01hh hhhh 1100 0000 C 110g hhhh 1111 0000 D 001g ghhh 1111 0000 F 1110 ghhh 1111 0000
Notice that this caused subnet A to change an sbit back into a g bit. This is because the equality of step 33 of RemoveSubnet() did not hold true for subnet A with respect to the remaining subnets.

References

[1] Braden, R., "Requirements for Internet Hosts  Communication Layers", RFC 1122, USC/Information Sciences Institute, October 1989. [2] Mogul, J., and J. Postel, "Internet Standard Subnetting Procedure", RFC 950, USC/Information Sciences Institute, August 1985.
[3] Moy, J., "OSPF Specification", RFC 1131, Proteon, October 1989.
[4] Postel, J., "Internet Control Message Protocol", RFC 792, USC/Information Sciences Institute, September 1981. [5] Tsuchiya, P., "Efficient and Flexible Hierarchical Address Assignment", TMARH018495, Bellcore, February 1991. [6] Hedrick, C., "Routing Information Protocol" RFC 1058, Rutgers University, June 1988. [7] Braden, R., and J. Postel, "Requirements for Internet Gateways", RFC 1009, USC/Information Sciences Institute, June 1987.
Security Considerations

Security issues are not discussed in this memo.
Author's Address

Paul F. Tsuchiya
Bellcore
435 South St.5 South St.
MRE 2L281
Morristown, NJ 07960Phone:


 8294484

EMail: tsuchiya@thumper.bellcore.com