commit 18cce1008e8fdae525d4a3211c58a9da56628dcf · pyrox.dev/nixpkgs

+3 -2

nixos/modules/tasks/network-interfaces-scripted.nix

···

       219
       219
        
                           cidr = "${route.address}/${toString route.prefixLength}";

     

       220
       220
        
                           via = optionalString (route.via != null) ''via "${route.via}"'';

     

       221
       221
        
                           options = concatStrings (mapAttrsToList (name: val: "${name} ${val} ") route.options);

     

       222
       222
       +
                           type = toString route.type;

     

       222
       223
        
                         in

     

       223
       224
        
                         ''

     

       224
       225
        
                            echo "${cidr}" >> $state

     

       225
       226
        
                            echo -n "adding route ${cidr}... "

     

       226
       226
       -
                            if out=$(ip route add "${cidr}" ${options} ${via} dev "${i.name}" proto static 2>&1); then

     

       227
       227
       +
                            if out=$(ip route add ${type} "${cidr}" ${options} ${via} dev "${i.name}" proto static 2>&1); then

     

       227
       228
        
                              echo "done"

     

       228
       229
        
                            elif ! echo "$out" | grep "File exists" >/dev/null 2>&1; then

     

       229
       229
       -
                              echo "'ip route add "${cidr}" ${options} ${via} dev "${i.name}"' failed: $out"

     

       230
       230
       +
                              echo "'ip route add ${type} "${cidr}" ${options} ${via} dev "${i.name}"' failed: $out"

     

       230
       231
        
                              exit 1

     

       231
       232
        
                            fi

     

       232
       233
        
                         ''

+3

nixos/modules/tasks/network-interfaces-systemd.nix

···

       142
       142
        
                       optionalAttrs (route.via != null) {

     

       143
       143
        
                         Gateway = route.via;

     

       144
       144
        
                       } //

     

       145
       145
       +
                       optionalAttrs (route.type != null) {

     

       146
       146
       +
                         Type = route.type;

     

       147
       147
       +
                       } //

     

       145
       148
        
                       optionalAttrs (route.options ? onlink) {

     

       146
       149
        
                         GatewayOnLink = true;

     

       147
       150
        
                       } //

+16

nixos/modules/tasks/network-interfaces.nix

···

       90
       90
        
               '';

     

       91
       91
        
             };

     

       92
       92
        
       

     

       93
       93
       +
             type = mkOption {

     

       94
       94
       +
               type = types.nullOr (types.enum [

     

       95
       95
       +
                 "unicast" "local" "broadcast" "multicast"

     

       96
       96
       +
               ]);

     

       97
       97
       +
               default = null;

     

       98
       98
       +
               description = ''

     

       99
       99
       +
                 Type of the route.  See the <literal>Route types</literal> section

     

       100
       100
       +
                 in the <literal>ip-route(8)</literal> manual page for the details.

     

       101
       101
       +
       

     

       102
       102
       +
                 Note that <literal>prohibit</literal>, <literal>blackhole</literal>,

     

       103
       103
       +
                 <literal>unreachable</literal>, and <literal>throw</literal> cannot

     

       104
       104
       +
                 be configured per device, so they are not available here. Similarly,

     

       105
       105
       +
                 <literal>nat</literal> hasn't been supported since kernel 2.6.

     

       106
       106
       +
               '';

     

       107
       107
       +
             };

     

       108
       108
       +
       

     

       93
       109
        
             via = mkOption {

     

       94
       110
        
               type = types.nullOr types.str;

     

       95
       111
        
               default = null;

+25 -4

nixos/tests/networking.nix

···

       77
       77
        
         testCases = {

     

       78
       78
        
           loopback = {

     

       79
       79
        
             name = "Loopback";

     

       80
       80
       -
             machine.networking.useDHCP = false;

     

       81
       81
       -
             machine.networking.useNetworkd = networkd;

     

       80
       80
       +
             nodes.client = { pkgs, ... }: with pkgs.lib; {

     

       81
       81
       +
               networking.useDHCP = false;

     

       82
       82
       +
               networking.useNetworkd = networkd;

     

       83
       83
       +
             };

     

       82
       84
        
             testScript = ''

     

       83
       85
        
               start_all()

     

       84
       84
       -
               machine.wait_for_unit("network.target")

     

       85
       85
       -
               loopback_addresses = machine.succeed("ip addr show lo")

     

       86
       86
       +
               client.wait_for_unit("network.target")

     

       87
       87
       +
               loopback_addresses = client.succeed("ip addr show lo")

     

       86
       88
        
               assert "inet 127.0.0.1/8" in loopback_addresses

     

       87
       89
        
               assert "inet6 ::1/128" in loopback_addresses

     

       88
       90
        
             '';

     
···

       138
       140
        
                     router.wait_until_succeeds("ping -c 1 192.168.3.1")

     

       139
       141
        
                     client.wait_until_succeeds("ping -c 1 192.168.3.1")

     

       140
       142
        
               '';

     

       143
       143
       +
           };

     

       144
       144
       +
           routeType = {

     

       145
       145
       +
             name = "RouteType";

     

       146
       146
       +
             nodes.client = { pkgs, ... }: with pkgs.lib; {

     

       147
       147
       +
               networking = {

     

       148
       148
       +
                 useDHCP = false;

     

       149
       149
       +
                 useNetworkd = networkd;

     

       150
       150
       +
                 interfaces.eth1.ipv4.routes = [{

     

       151
       151
       +
                   address = "192.168.1.127";

     

       152
       152
       +
                   prefixLength = 32;

     

       153
       153
       +
                   type = "local";

     

       154
       154
       +
                 }];

     

       155
       155
       +
               };

     

       156
       156
       +
             };

     

       157
       157
       +
             testScript = ''

     

       158
       158
       +
               start_all()

     

       159
       159
       +
               client.wait_for_unit("network.target")

     

       160
       160
       +
               client.succeed("ip -4 route list table local | grep 'local 192.168.1.127'")

     

       161
       161
       +
             '';

     

       141
       162
        
           };

     

       142
       163
        
           dhcpDefault = {

     

       143
       164
        
             name = "useDHCP-by-default";