commit d559eed93af199646f495f8ef4f91971743e480c · pyrox.dev/nixpkgs

lib/default.nix

···

       64
        
           # linux kernel configuration

     

       65
        
           kernel = callLibs ./kernel.nix;

     

       66
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       67
        
           # TODO: For consistency, all builtins should also be available from a sub-library;

     

       68
        
           # these are the only ones that are currently not

     

       69
        
           inherit (builtins) addErrorContext isPath trace;

···

       64
        
           # linux kernel configuration

     

       65
        
           kernel = callLibs ./kernel.nix;

     

       66
        
       

     

       67
       +
           # network

     

       68
       +
           network = callLibs ./network;

     

       69
       +
       

     

       70
        
           # TODO: For consistency, all builtins should also be available from a sub-library;

     

       71
        
           # these are the only ones that are currently not

     

       72
        
           inherit (builtins) addErrorContext isPath trace;

+49

lib/network/default.nix

···

       1
       +
       { lib }:

     

       2
       +
       let

     

       3
       +
         inherit (import ./internal.nix { inherit lib; }) _ipv6;

     

       4
       +
       in

     

       5
       +
       {

     

       6
       +
         ipv6 = {

     

       7
       +
           /**

     

       8
       +
             Creates an `IPv6Address` object from an IPv6 address as a string. If

     

       9
       +
             the prefix length is omitted, it defaults to 64. The parser is limited

     

       10
       +
             to the first two versions of IPv6 addresses addressed in RFC 4291.

     

       11
       +
             The form "x:x:x:x:x:x:d.d.d.d" is not yet implemented. Addresses are

     

       12
       +
             NOT compressed, so they are not always the same as the canonical text

     

       13
       +
             representation of IPv6 addresses defined in RFC 5952.

     

       14
       +
       

     

       15
       +
             # Type

     

       16
       +
       

     

       17
       +
             ```

     

       18
       +
             fromString :: String -> IPv6Address

     

       19
       +
             ```

     

       20
       +
       

     

       21
       +
             # Examples

     

       22
       +
       

     

       23
       +
             ```nix

     

       24
       +
             fromString "2001:DB8::ffff/32"

     

       25
       +
             => {

     

       26
       +
               address = "2001:db8:0:0:0:0:0:ffff";

     

       27
       +
               prefixLength = 32;

     

       28
       +
             }

     

       29
       +
             ```

     

       30
       +
       

     

       31
       +
             # Arguments

     

       32
       +
       

     

       33
       +
             - [addr] An IPv6 address with optional prefix length.

     

       34
       +
           */

     

       35
       +
           fromString =

     

       36
       +
             addr:

     

       37
       +
             let

     

       38
       +
               splittedAddr = _ipv6.split addr;

     

       39
       +
       

     

       40
       +
               addrInternal = splittedAddr.address;

     

       41
       +
               prefixLength = splittedAddr.prefixLength;

     

       42
       +
       

     

       43
       +
               address = _ipv6.toStringFromExpandedIp addrInternal;

     

       44
       +
             in

     

       45
       +
             {

     

       46
       +
               inherit address prefixLength;

     

       47
       +
             };

     

       48
       +
         };

     

       49
       +
       }

+209

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
       +
       }

+117

lib/tests/network.sh

···

       1
       +
       #!/usr/bin/env bash

     

       2
       +
       

     

       3
       +
       # Tests lib/network.nix

     

       4
       +
       # Run:

     

       5
       +
       # [nixpkgs]$ lib/tests/network.sh

     

       6
       +
       # or:

     

       7
       +
       # [nixpkgs]$ nix-build lib/tests/release.nix

     

       8
       +
       

     

       9
       +
       set -euo pipefail

     

       10
       +
       shopt -s inherit_errexit

     

       11
       +
       

     

       12
       +
       if [[ -n "${TEST_LIB:-}" ]]; then

     

       13
       +
         NIX_PATH=nixpkgs="$(dirname "$TEST_LIB")"

     

       14
       +
       else

     

       15
       +
         NIX_PATH=nixpkgs="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.."; pwd)"

     

       16
       +
       fi

     

       17
       +
       export NIX_PATH

     

       18
       +
       

     

       19
       +
       die() {

     

       20
       +
         echo >&2 "test case failed: " "$@"

     

       21
       +
         exit 1

     

       22
       +
       }

     

       23
       +
       

     

       24
       +
       tmp="$(mktemp -d)"

     

       25
       +
       clean_up() {

     

       26
       +
           rm -rf "$tmp"

     

       27
       +
       }

     

       28
       +
       trap clean_up EXIT SIGINT SIGTERM

     

       29
       +
       work="$tmp/work"

     

       30
       +
       mkdir "$work"

     

       31
       +
       cd "$work"

     

       32
       +
       

     

       33
       +
       prefixExpression='

     

       34
       +
         let

     

       35
       +
           lib = import <nixpkgs/lib>;

     

       36
       +
           internal = import <nixpkgs/lib/network/internal.nix> {

     

       37
       +
             inherit lib;

     

       38
       +
           };

     

       39
       +
         in

     

       40
       +
         with lib;

     

       41
       +
         with lib.network;

     

       42
       +
       '

     

       43
       +
       

     

       44
       +
       expectSuccess() {

     

       45
       +
           local expr=$1

     

       46
       +
           local expectedResult=$2

     

       47
       +
           if ! result=$(nix-instantiate --eval --strict --json --show-trace \

     

       48
       +
               --expr "$prefixExpression ($expr)"); then

     

       49
       +
               die "$expr failed to evaluate, but it was expected to succeed"

     

       50
       +
           fi

     

       51
       +
           if [[ ! "$result" == "$expectedResult" ]]; then

     

       52
       +
               die "$expr == $result, but $expectedResult was expected"

     

       53
       +
           fi

     

       54
       +
       }

     

       55
       +
       

     

       56
       +
       expectSuccessRegex() {

     

       57
       +
           local expr=$1

     

       58
       +
           local expectedResultRegex=$2

     

       59
       +
           if ! result=$(nix-instantiate --eval --strict --json --show-trace \

     

       60
       +
               --expr "$prefixExpression ($expr)"); then

     

       61
       +
               die "$expr failed to evaluate, but it was expected to succeed"

     

       62
       +
           fi

     

       63
       +
           if [[ ! "$result" =~ $expectedResultRegex ]]; then

     

       64
       +
               die "$expr == $result, but $expectedResultRegex was expected"

     

       65
       +
           fi

     

       66
       +
       }

     

       67
       +
       

     

       68
       +
       expectFailure() {

     

       69
       +
           local expr=$1

     

       70
       +
           local expectedErrorRegex=$2

     

       71
       +
           if result=$(nix-instantiate --eval --strict --json --show-trace 2>"$work/stderr" \

     

       72
       +
               --expr "$prefixExpression ($expr)"); then

     

       73
       +
               die "$expr evaluated successfully to $result, but it was expected to fail"

     

       74
       +
           fi

     

       75
       +
           if [[ ! "$(<"$work/stderr")" =~ $expectedErrorRegex ]]; then

     

       76
       +
               die "Error was $(<"$work/stderr"), but $expectedErrorRegex was expected"

     

       77
       +
           fi

     

       78
       +
       }

     

       79
       +
       

     

       80
       +
       # Internal functions

     

       81
       +
       expectSuccess '(internal._ipv6.split "0:0:0:0:0:0:0:0").address'                         '[0,0,0,0,0,0,0,0]'

     

       82
       +
       expectSuccess '(internal._ipv6.split "000a:000b:000c:000d:000e:000f:ffff:aaaa").address' '[10,11,12,13,14,15,65535,43690]'

     

       83
       +
       expectSuccess '(internal._ipv6.split "::").address'                                      '[0,0,0,0,0,0,0,0]'

     

       84
       +
       expectSuccess '(internal._ipv6.split "::0000").address'                                  '[0,0,0,0,0,0,0,0]'

     

       85
       +
       expectSuccess '(internal._ipv6.split "::1").address'                                     '[0,0,0,0,0,0,0,1]'

     

       86
       +
       expectSuccess '(internal._ipv6.split "::ffff").address'                                  '[0,0,0,0,0,0,0,65535]'

     

       87
       +
       expectSuccess '(internal._ipv6.split "::000f").address'                                  '[0,0,0,0,0,0,0,15]'

     

       88
       +
       expectSuccess '(internal._ipv6.split "::1:1:1:1:1:1:1").address'                         '[0,1,1,1,1,1,1,1]'

     

       89
       +
       expectSuccess '(internal._ipv6.split "1::").address'                                     '[1,0,0,0,0,0,0,0]'

     

       90
       +
       expectSuccess '(internal._ipv6.split "1:1:1:1:1:1:1::").address'                         '[1,1,1,1,1,1,1,0]'

     

       91
       +
       expectSuccess '(internal._ipv6.split "1:1:1:1::1:1:1").address'                          '[1,1,1,1,0,1,1,1]'

     

       92
       +
       expectSuccess '(internal._ipv6.split "1::1").address'                                    '[1,0,0,0,0,0,0,1]'

     

       93
       +
       

     

       94
       +
       expectFailure 'internal._ipv6.split "0:0:0:0:0:0:0:-1"' "contains malformed characters for IPv6 address"

     

       95
       +
       expectFailure 'internal._ipv6.split "::0:"'              "is not a valid IPv6 address"

     

       96
       +
       expectFailure 'internal._ipv6.split ":0::"'              "is not a valid IPv6 address"

     

       97
       +
       expectFailure 'internal._ipv6.split "0::0:"'             "is not a valid IPv6 address"

     

       98
       +
       expectFailure 'internal._ipv6.split "0:0:"'              "is not a valid IPv6 address"

     

       99
       +
       expectFailure 'internal._ipv6.split "0:0:0:0:0:0:0:0:0"' "is not a valid IPv6 address"

     

       100
       +
       expectFailure 'internal._ipv6.split "0:0:0:0:0:0:0:0:"'  "is not a valid IPv6 address"

     

       101
       +
       expectFailure 'internal._ipv6.split "::0:0:0:0:0:0:0:0"' "is not a valid IPv6 address"

     

       102
       +
       expectFailure 'internal._ipv6.split "0::0:0:0:0:0:0:0"'  "is not a valid IPv6 address"

     

       103
       +
       expectFailure 'internal._ipv6.split "::10000"'           "0x10000 is not a valid u16 integer"

     

       104
       +
       

     

       105
       +
       expectSuccess '(internal._ipv6.split "::").prefixLength'     '128'

     

       106
       +
       expectSuccess '(internal._ipv6.split "::/1").prefixLength'   '1'

     

       107
       +
       expectSuccess '(internal._ipv6.split "::/128").prefixLength' '128'

     

       108
       +
       

     

       109
       +
       expectFailure '(internal._ipv6.split "::/0").prefixLength'   "IPv6 subnet should be in range \[1;128\], got 0"

     

       110
       +
       expectFailure '(internal._ipv6.split "::/129").prefixLength' "IPv6 subnet should be in range \[1;128\], got 129"

     

       111
       +
       expectFailure '(internal._ipv6.split "/::/").prefixLength'   "is not a valid IPv6 address in CIDR notation"

     

       112
       +
       

     

       113
       +
       # Library API

     

       114
       +
       expectSuccess 'lib.network.ipv6.fromString "2001:DB8::ffff/64"' '{"address":"2001:db8:0:0:0:0:0:ffff","prefixLength":64}'

     

       115
       +
       expectSuccess 'lib.network.ipv6.fromString "1234:5678:90ab:cdef:fedc:ba09:8765:4321/44"' '{"address":"1234:5678:90ab:cdef:fedc:ba09:8765:4321","prefixLength":44}'

     

       116
       +
       

     

       117
       +
       echo >&2 tests ok

lib/tests/test-with-nix.nix

···

       65
        
         echo "Running lib/tests/sources.sh"

     

       66
        
         TEST_LIB=$PWD/lib bash lib/tests/sources.sh

     

       67
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       68
        
         echo "Running lib/fileset/tests.sh"

     

       69
        
         TEST_LIB=$PWD/lib bash lib/fileset/tests.sh

     

       70

···

       65
        
         echo "Running lib/tests/sources.sh"

     

       66
        
         TEST_LIB=$PWD/lib bash lib/tests/sources.sh

     

       67
        
       

     

       68
       +
         echo "Running lib/tests/network.sh"

     

       69
       +
         TEST_LIB=$PWD/lib bash lib/tests/network.sh

     

       70
       +
       

     

       71
        
         echo "Running lib/fileset/tests.sh"

     

       72
        
         TEST_LIB=$PWD/lib bash lib/fileset/tests.sh

     

       73