commit d00c91c5dab1428941c4ee61e341b01a26f14c90 · pyrox.dev/nixpkgs

+45 -21

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

···

       185
       185
        
                   path = [ pkgs.iproute ];

     

       186
       186
        
                   script =

     

       187
       187
        
                     ''

     

       188
       188
       -
                       # FIXME: shouldn't this be done in network-link?

     

       189
       189
       -
                       echo "bringing up interface..."

     

       190
       190
       -
                       ip link set "${i.name}" up

     

       188
       188
       +
                       state="/run/nixos/network/addresses/${i.name}"

     

       189
       189
       +
                       mkdir -p $(dirname "$state")

     

       191
       190
        
       

     

       192
       192
       -
                       state="/run/nixos/network/addresses/${i.name}"

     

       191
       191
       +
                       ${flip concatMapStrings ips (ip:

     

       192
       192
       +
                         let

     

       193
       193
       +
                           cidr = "${ip.address}/${toString ip.prefixLength}";

     

       194
       194
       +
                         in

     

       195
       195
       +
                         ''

     

       196
       196
       +
                           echo "${cidr}" >> $state

     

       197
       197
       +
                           echo -n "adding address ${cidr}... "

     

       198
       198
       +
                           if out=$(ip addr add "${cidr}" dev "${i.name}" 2>&1); then

     

       199
       199
       +
                             echo "done"

     

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

     

       201
       201
       +
                             echo "failed"

     

       202
       202
       +
                             exit 1

     

       203
       203
       +
                           fi

     

       204
       204
       +
                         ''

     

       205
       205
       +
                       )}

     

       193
       206
        
       

     

       207
       207
       +
                       state="/run/nixos/network/routes/${i.name}"

     

       194
       208
        
                       mkdir -p $(dirname "$state")

     

       195
       209
        
       

     

       196
       196
       -
                     '' + flip concatMapStrings (ips) (ip:

     

       197
       197
       -
                       let

     

       198
       198
       -
                         address = "${ip.address}/${toString ip.prefixLength}";

     

       199
       199
       -
                       in

     

       200
       200
       -
                       ''

     

       201
       201
       -
                         echo "${address}" >> $state

     

       202
       202
       -
                         if out=$(ip addr add "${address}" dev "${i.name}" 2>&1); then

     

       203
       203
       -
                           echo "added ip ${address}"

     

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

     

       205
       205
       -
                           echo "failed to add ${address}"

     

       206
       206
       -
                           exit 1

     

       207
       207
       -
                         fi

     

       208
       208
       -
                       '');

     

       210
       210
       +
                       ${flip concatMapStrings (i.ipv4Routes ++ i.ipv6Routes) (route:

     

       211
       211
       +
                         let

     

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

     

       213
       213
       +
                           nextHop = optionalString (route.nextHop != null) ''via "${route.nextHop}"'';

     

       214
       214
       +
                         in

     

       215
       215
       +
                         ''

     

       216
       216
       +
                            echo "${cidr}" >> $state

     

       217
       217
       +
                            echo -n "adding route ${cidr}... "

     

       218
       218
       +
                            if out=$(ip route add "${cidr}" ${route.options} ${nextHop} dev "${i.name}" 2>&1); then

     

       219
       219
       +
                              echo "done"

     

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

     

       221
       221
       +
                              echo "failed"

     

       222
       222
       +
                              exit 1

     

       223
       223
       +
                            fi

     

       224
       224
       +
                         ''

     

       225
       225
       +
                       )}

     

       226
       226
       +
                     '';

     

       209
       227
        
                   preStop = ''

     

       228
       228
       +
                     state="/run/nixos/network/routes/${i.name}"

     

       229
       229
       +
                     while read cidr; do

     

       230
       230
       +
                       echo -n "deleting route $cidr... "

     

       231
       231
       +
                       ip route del "$cidr" dev "${i.name}" >/dev/null 2>&1 && echo "done" || echo "failed"

     

       232
       232
       +
                     done < "$state"

     

       233
       233
       +
                     rm -f "$state"

     

       234
       234
       +
       

     

       210
       235
        
                     state="/run/nixos/network/addresses/${i.name}"

     

       211
       211
       -
                     while read address; do

     

       212
       212
       -
                       echo -n "deleting $address..."

     

       213
       213
       -
                       ip addr del "$address" dev "${i.name}" >/dev/null 2>&1 || echo -n " Failed"

     

       214
       214
       -
                       echo ""

     

       236
       236
       +
                     while read cidr; do

     

       237
       237
       +
                       echo -n "deleting address $cidr... "

     

       238
       238
       +
                       ip addr del "$cidr" dev "${i.name}" >/dev/null 2>&1 && echo "done" || echo "failed"

     

       215
       239
        
                     done < "$state"

     

       216
       240
        
                     rm -f "$state"

     

       217
       241
        
                   '';

+62 -1

nixos/modules/tasks/network-interfaces.nix

···

       101
       101
        
               address = mkOption {

     

       102
       102
        
                 type = types.str;

     

       103
       103
        
                 description = ''

     

       104
       104
       -
                   IPv${toString v} address of the interface.  Leave empty to configure the

     

       104
       104
       +
                   IPv${toString v} address of the interface. Leave empty to configure the

     

       105
       105
        
                   interface using DHCP.

     

       106
       106
        
                 '';

     

       107
       107
        
               };

     
···

       115
       115
        
               };

     

       116
       116
        
             };

     

       117
       117
        
           };

     

       118
       118
       +
       

     

       119
       119
       +
         routeOpts = v:

     

       120
       120
       +
         { options = {

     

       121
       121
       +
             address = mkOption {

     

       122
       122
       +
               type = types.str;

     

       123
       123
       +
               description = "IPv${toString v} address of the network.";

     

       124
       124
       +
             };

     

       125
       125
       +
       

     

       126
       126
       +
             prefixLength = mkOption {

     

       127
       127
       +
               type = types.addCheck types.int (n: n >= 0 && n <= (if v == 4 then 32 else 128));

     

       128
       128
       +
               description = ''

     

       129
       129
       +
                 Subnet mask of the network, specified as the number of

     

       130
       130
       +
                 bits in the prefix (<literal>${if v == 4 then "24" else "64"}</literal>).

     

       131
       131
       +
               '';

     

       132
       132
       +
             };

     

       133
       133
       +
       

     

       134
       134
       +
             nextHop = mkOption {

     

       135
       135
       +
               type = types.nullOr types.str;

     

       136
       136
       +
               default = null;

     

       137
       137
       +
               description = "IPv${toString v} address of the next hop.";

     

       138
       138
       +
             };

     

       139
       139
       +
       

     

       140
       140
       +
             options = mkOption {

     

       141
       141
       +
               type = types.str;

     

       142
       142
       +
               default = "";

     

       143
       143
       +
               example = "mtu 1492 window 524288";

     

       144
       144
       +
               description = ''

     

       145
       145
       +
                 Other route options. See the symbol <literal>OPTION</literal>

     

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

     

       147
       147
       +
               '';

     

       148
       148
       +
             };

     

       149
       149
       +
       

     

       150
       150
       +
           };

     

       151
       151
       +
         };

     

       118
       152
        
       

     

       119
       153
        
         gatewayCoerce = address: { inherit address; };

     

       120
       154
        
       

     
···

       196
       230
        
               type = with types; listOf (submodule (addrOpts 6));

     

       197
       231
        
               description = ''

     

       198
       232
        
                 List of IPv6 addresses that will be statically assigned to the interface.

     

       233
       233
       +
               '';

     

       234
       234
       +
             };

     

       235
       235
       +
       

     

       236
       236
       +
             ipv4Routes = mkOption {

     

       237
       237
       +
               default = [];

     

       238
       238
       +
               example = [

     

       239
       239
       +
                 { address = "10.0.0.0"; prefixLength = 16; }

     

       240
       240
       +
                 { address = "192.168.2.0"; prefixLength = 24; nextHop = "192.168.1.1"; }

     

       241
       241
       +
               ];

     

       242
       242
       +
               type = with types; listOf (submodule (routeOpts 4));

     

       243
       243
       +
               description = ''

     

       244
       244
       +
                 List of extra IPv4 static routes that will be assigned to the interface.

     

       245
       245
       +
               '';

     

       246
       246
       +
             };

     

       247
       247
       +
       

     

       248
       248
       +
             ipv6Routes = mkOption {

     

       249
       249
       +
               default = [];

     

       250
       250
       +
               example = [

     

       251
       251
       +
                 { address = "fdfd:b3f0::"; prefixLength = 48; }

     

       252
       252
       +
                 { address = "2001:1470:fffd:2098::"; prefixLength = 64; nextHop = "fdfd:b3f0::1"; }

     

       253
       253
       +
               ];

     

       254
       254
       +
               type = with types; listOf (submodule (routeOpts 6));

     

       255
       255
       +
               description = ''

     

       256
       256
       +
                 List of extra IPv6 static routes that will be assigned to the interface.

     

       199
       257
        
               '';

     

       200
       258
        
             };

     

       201
       259
        
       

     
···

       1089
       1147
        
                 '' + optionalString (i.mtu != null) ''

     

       1090
       1148
        
                   echo "setting MTU to ${toString i.mtu}..."

     

       1091
       1149
        
                   ip link set "${i.name}" mtu "${toString i.mtu}"

     

       1150
       1150
       +
                 '' + ''

     

       1151
       1151
       +
                   echo -n "bringing up interface... "

     

       1152
       1152
       +
                   ip link set "${i.name}" up && echo "done" || (echo "failed"; exit 1)

     

       1092
       1153
        
                 '';

     

       1093
       1154
        
             })));

     

       1094
       1155