lib/network/internal.nix

   1 {
   2   lib ? import ../.,
   3 }:
   4 let
   5   inherit (builtins)
   6     map
   7     match
   8     genList
   9     length
  10     concatMap
  11     head
  12     toString
  13     ;
  14
  15   inherit (lib) lists strings trivial;
  16
  17   inherit (lib.lists) last;
  18
  19   /*
  20     IPv6 addresses are 128-bit identifiers. The preferred form is 'x:x:x:x:x:x:x:x',
  21     where the 'x's are one to four hexadecimal digits of the eight 16-bit pieces of
  22     the address. See RFC 4291.
  23   */
  24   ipv6Bits = 128;
  25   ipv6Pieces = 8; # 'x:x:x:x:x:x:x:x'
  26   ipv6PieceBits = 16; # One piece in range from 0 to 0xffff.
  27   ipv6PieceMaxValue = 65535; # 2^16 - 1
  28 in
  29 let
  30   /**
  31     Expand an IPv6 address by removing the "::" compression and padding them
  32     with the necessary number of zeros. Converts an address from the string to
  33     the list of strings which then can be parsed using `_parseExpanded`.
  34     Throws an error when the address is malformed.
  35
  36     # Type: String -> [ String ]
  37
  38     # Example:
  39
  40     ```nix
  41     expandIpv6 "2001:DB8::ffff"
  42     => ["2001" "DB8" "0" "0" "0" "0" "0" "ffff"]
  43     ```
  44   */
  45   expandIpv6 =
  46     addr:
  47     if match "^[0-9A-Fa-f:]+$" addr == null then
  48       throw "${addr} contains malformed characters for IPv6 address"
  49     else
  50       let
  51         pieces = strings.splitString ":" addr;
  52         piecesNoEmpty = lists.remove "" pieces;
  53         piecesNoEmptyLen = length piecesNoEmpty;
  54         zeros = genList (_: "0") (ipv6Pieces - piecesNoEmptyLen);
  55         hasPrefix = strings.hasPrefix "::" addr;
  56         hasSuffix = strings.hasSuffix "::" addr;
  57         hasInfix = strings.hasInfix "::" addr;
  58       in
  59       if addr == "::" then
  60         zeros
  61       else if
  62         let
  63           emptyCount = length pieces - piecesNoEmptyLen;
  64           emptyExpected =
  65             # splitString produces two empty pieces when "::" in the beginning
  66             # or in the end, and only one when in the middle of an address.
  67             if hasPrefix || hasSuffix then
  68               2
  69             else if hasInfix then
  70               1
  71             else
  72               0;
  73         in
  74         emptyCount != emptyExpected
  75         || (hasInfix && piecesNoEmptyLen >= ipv6Pieces) # "::" compresses at least one group of zeros.
  76         || (!hasInfix && piecesNoEmptyLen != ipv6Pieces)
  77       then
  78         throw "${addr} is not a valid IPv6 address"
  79       # Create a list of 8 elements, filling some of them with zeros depending
  80       # on where the "::" was found.
  81       else if hasPrefix then
  82         zeros ++ piecesNoEmpty
  83       else if hasSuffix then
  84         piecesNoEmpty ++ zeros
  85       else if hasInfix then
  86         concatMap (piece: if piece == "" then zeros else [ piece ]) pieces
  87       else
  88         pieces;
  89
  90   /**
  91     Parses an expanded IPv6 address (see `expandIpv6`), converting each part
  92     from a string to an u16 integer. Returns an internal representation of IPv6
  93     address (list of integers) that can be easily processed by other helper
  94     functions.
  95     Throws an error some element is not an u16 integer.
  96
  97     # Type: [ String ] -> IPv6
  98
  99     # Example:
 100
 101     ```nix
 102     parseExpandedIpv6 ["2001" "DB8" "0" "0" "0" "0" "0" "ffff"]
 103     => [8193 3512 0 0 0 0 0 65535]
 104     ```
 105   */
 106   parseExpandedIpv6 =
 107     addr:
 108     assert lib.assertMsg (
 109       length addr == ipv6Pieces
 110     ) "parseExpandedIpv6: expected list of integers with ${ipv6Pieces} elements";
 111     let
 112       u16FromHexStr =
 113         hex:
 114         let
 115           parsed = trivial.fromHexString hex;
 116         in
 117         if 0 <= parsed && parsed <= ipv6PieceMaxValue then
 118           parsed
 119         else
 120           throw "0x${hex} is not a valid u16 integer";
 121     in
 122     map (piece: u16FromHexStr piece) addr;
 123 in
 124 let
 125   /**
 126     Parses an IPv6 address from a string to the internal representation (list
 127     of integers).
 128
 129     # Type: String -> IPv6
 130
 131     # Example:
 132
 133     ```nix
 134     parseIpv6FromString "2001:DB8::ffff"
 135     => [8193 3512 0 0 0 0 0 65535]
 136     ```
 137   */
 138   parseIpv6FromString = addr: parseExpandedIpv6 (expandIpv6 addr);
 139 in
 140 {
 141   /*
 142     Internally, an IPv6 address is stored as a list of 16-bit integers with 8
 143     elements. Wherever you see `IPv6` in internal functions docs, it means that
 144     it is a list of integers produced by one of the internal parsers, such as
 145     `parseIpv6FromString`
 146   */
 147   _ipv6 = {
 148     /**
 149       Converts an internal representation of an IPv6 address (i.e, a list
 150       of integers) to a string. The returned string is not a canonical
 151       representation as defined in RFC 5952, i.e zeros are not compressed.
 152
 153       # Type: IPv6 -> String
 154
 155       # Example:
 156
 157       ```nix
 158       parseIpv6FromString [8193 3512 0 0 0 0 0 65535]
 159       => "2001:db8:0:0:0:0:0:ffff"
 160       ```
 161     */
 162     toStringFromExpandedIp =
 163       pieces: strings.concatMapStringsSep ":" (piece: strings.toLower (trivial.toHexString piece)) pieces;
 164
 165     /**
 166       Extract an address and subnet prefix length from a string. The subnet
 167       prefix length is optional and defaults to 128. The resulting address and
 168       prefix length are validated and converted to an internal representation
 169       that can be used by other functions.
 170
 171       # Type: String -> [ {address :: IPv6, prefixLength :: Int} ]
 172
 173       # Example:
 174
 175       ```nix
 176       split "2001:DB8::ffff/32"
 177       => {
 178         address = [8193 3512 0 0 0 0 0 65535];
 179         prefixLength = 32;
 180       }
 181       ```
 182     */
 183     split =
 184       addr:
 185       let
 186         splitted = strings.splitString "/" addr;
 187         splittedLength = length splitted;
 188       in
 189       if splittedLength == 1 then # [ ip ]
 190         {
 191           address = parseIpv6FromString addr;
 192           prefixLength = ipv6Bits;
 193         }
 194       else if splittedLength == 2 then # [ ip subnet ]
 195         {
 196           address = parseIpv6FromString (head splitted);
 197           prefixLength =
 198             let
 199               n = strings.toInt (last splitted);
 200             in
 201             if 1 <= n && n <= ipv6Bits then
 202               n
 203             else
 204               throw "${addr} IPv6 subnet should be in range [1;${toString ipv6Bits}], got ${toString n}";
 205         }
 206       else
 207         throw "${addr} is not a valid IPv6 address in CIDR notation";
 208   };
 209 }