commit c1bed05e341756f7fdfa73035c7f1e078e49be3d · pyrox.dev/nixpkgs

+1 -1

nixos/doc/manual/configuration/ipv4-config.xml

···

       12
       12
        
       follows:

     

       13
       13
        
       

     

       14
       14
        
       <programlisting>

     

       15
       15
       -
       networking.interfaces.eth0.ip4 = [ { address = "192.168.1.2"; prefixLength = 24; } ];

     

       15
       15
       +
       networking.interfaces.eth0.ipv4.addresses = [ { address = "192.168.1.2"; prefixLength = 24; } ];

     

       16
       16
        
       </programlisting>

     

       17
       17
        
       

     

       18
       18
        
       Typically you’ll also want to set a default gateway and set of name

+1 -1

nixos/doc/manual/configuration/ipv6-config.xml

···

       26
       26
        
       DHCPv6. You can configure an interface manually:

     

       27
       27
        
       

     

       28
       28
        
       <programlisting>

     

       29
       29
       -
       networking.interfaces.eth0.ip6 = [ { address = "fe00:aa:bb:cc::2"; prefixLength = 64; } ];

     

       29
       29
       +
       networking.interfaces.eth0.ipv6.addresses = [ { address = "fe00:aa:bb:cc::2"; prefixLength = 64; } ];

     

       30
       30
        
       </programlisting>

     

       31
       31
        
       </para>

     

       32
       32

+2 -2

nixos/lib/build-vms.nix

···

       51
       51
        
                   let

     

       52
       52
        
                     interfacesNumbered = zipLists config.virtualisation.vlans (range 1 255);

     

       53
       53
        
                     interfaces = flip map interfacesNumbered ({ fst, snd }:

     

       54
       54
       -
                       nameValuePair "eth${toString snd}" { ip4 =

     

       54
       54
       +
                       nameValuePair "eth${toString snd}" { ipv4.addresses =

     

       55
       55
        
                         [ { address = "192.168.${toString fst}.${toString m.snd}";

     

       56
       56
        
                             prefixLength = 24;

     

       57
       57
        
                         } ];

     
···

       64
       64
        
                         networking.interfaces = listToAttrs interfaces;

     

       65
       65
        
       

     

       66
       66
        
                         networking.primaryIPAddress =

     

       67
       67
       -
                           optionalString (interfaces != []) (head (head interfaces).value.ip4).address;

     

       67
       67
       +
                           optionalString (interfaces != []) (head (head interfaces).value.ipv4.addresses).address;

     

       68
       68
        
       

     

       69
       69
        
                         # Put the IP addresses of all VMs in this machine's

     

       70
       70
        
                         # /etc/hosts file.  If a machine has multiple

+1 -1

nixos/modules/services/networking/dhcpcd.nix

···

       16
       16
        
         # Don't start dhcpcd on explicitly configured interfaces or on

     

       17
       17
        
         # interfaces that are part of a bridge, bond or sit device.

     

       18
       18
        
         ignoredInterfaces =

     

       19
       19
       -
           map (i: i.name) (filter (i: if i.useDHCP != null then !i.useDHCP else i.ip4 != [ ] || i.ipAddress != null) interfaces)

     

       19
       19
       +
           map (i: i.name) (filter (i: if i.useDHCP != null then !i.useDHCP else i.ipv4.addresses != [ ]) interfaces)

     

       20
       20
        
           ++ mapAttrsToList (i: _: i) config.networking.sits

     

       21
       21
        
           ++ concatLists (attrValues (mapAttrs (n: v: v.interfaces) config.networking.bridges))

     

       22
       22
        
           ++ concatLists (attrValues (mapAttrs (n: v: v.interfaces) config.networking.vswitches))

+3 -9

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

···

       20
       20
        
           "sys-subsystem-net-devices-${escapeSystemdPath interface}.device";

     

       21
       21
        
       

     

       22
       22
        
         interfaceIps = i:

     

       23
       23
       -
           i.ip4 ++ optionals cfg.enableIPv6 i.ip6

     

       24
       24
       -
           ++ optional (i.ipAddress != null) {

     

       25
       25
       -
             address = i.ipAddress;

     

       26
       26
       -
             prefixLength = i.prefixLength;

     

       27
       27
       -
           } ++ optional (cfg.enableIPv6 && i.ipv6Address != null) {

     

       28
       28
       -
             address = i.ipv6Address;

     

       29
       29
       -
             prefixLength = i.ipv6PrefixLength;

     

       30
       30
       -
           };

     

       23
       23
       +
           i.ipv4.addresses

     

       24
       24
       +
           ++ optionals cfg.enableIPv6 i.ipv6.addresses;

     

       31
       25
        
       

     

       32
       26
        
         destroyBond = i: ''

     

       33
       27
        
           while true; do

     
···

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

     

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

     

       209
       203
        
       

     

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

     

       204
       204
       +
                       ${flip concatMapStrings (i.ipv4.routes ++ i.ipv6.routes) (route:

     

       211
       205
        
                         let

     

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

     

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

+2 -8

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

···

       9
       9
        
         interfaces = attrValues cfg.interfaces;

     

       10
       10
        
       

     

       11
       11
        
         interfaceIps = i:

     

       12
       12
       -
           i.ip4 ++ optionals cfg.enableIPv6 i.ip6

     

       13
       13
       -
           ++ optional (i.ipAddress != null) {

     

       14
       14
       -
             address = i.ipAddress;

     

       15
       15
       -
             prefixLength = i.prefixLength;

     

       16
       16
       -
           } ++ optional (cfg.enableIPv6 && i.ipv6Address != null) {

     

       17
       17
       -
             address = i.ipv6Address;

     

       18
       18
       -
             prefixLength = i.ipv6PrefixLength;

     

       19
       19
       -
           };

     

       12
       12
       +
           i.ipv4.addresses

     

       13
       13
       +
           ++ optionals cfg.enableIPv6 i.ipv6.addresses;

     

       20
       14
        
       

     

       21
       15
        
         dhcpStr = useDHCP: if useDHCP == true || useDHCP == null then "both" else "none";

     

       22
       16

+35 -60

nixos/modules/tasks/network-interfaces.nix

···

       1
       1
       -
       { config, lib, pkgs, utils, stdenv, ... }:

     

       1
       1
       +
       { config, options, lib, pkgs, utils, stdenv, ... }:

     

       2
       2
        
       

     

       3
       3
        
       with lib;

     

       4
       4
        
       with utils;

     
···

       182
       182
        
         interfaceOpts = { name, ... }: {

     

       183
       183
        
       

     

       184
       184
        
           options = {

     

       185
       185
       -
       

     

       186
       185
        
             name = mkOption {

     

       187
       186
        
               example = "eth0";

     

       188
       187
        
               type = types.str;

     
···

       209
       208
        
               '';

     

       210
       209
        
             };

     

       211
       210
        
       

     

       212
       212
       -
             ip4 = mkOption {

     

       211
       211
       +
             ipv4.addresses = mkOption {

     

       213
       212
        
               default = [ ];

     

       214
       213
        
               example = [

     

       215
       214
        
                 { address = "10.0.0.1"; prefixLength = 16; }

     
···

       221
       220
        
               '';

     

       222
       221
        
             };

     

       223
       222
        
       

     

       224
       224
       -
             ip6 = mkOption {

     

       223
       223
       +
             ipv6.addresses = mkOption {

     

       225
       224
        
               default = [ ];

     

       226
       225
        
               example = [

     

       227
       226
        
                 { address = "fdfd:b3f0:482::1"; prefixLength = 48; }

     
···

       233
       232
        
               '';

     

       234
       233
        
             };

     

       235
       234
        
       

     

       236
       236
       -
             ipv4Routes = mkOption {

     

       235
       235
       +
             ipv4.routes = mkOption {

     

       237
       236
        
               default = [];

     

       238
       237
        
               example = [

     

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

     
···

       245
       244
        
               '';

     

       246
       245
        
             };

     

       247
       246
        
       

     

       248
       248
       -
             ipv6Routes = mkOption {

     

       247
       247
       +
             ipv6.routes = mkOption {

     

       249
       248
        
               default = [];

     

       250
       249
        
               example = [

     

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

     
···

       257
       256
        
               '';

     

       258
       257
        
             };

     

       259
       258
        
       

     

       260
       260
       -
             ipAddress = mkOption {

     

       261
       261
       -
               default = null;

     

       262
       262
       -
               example = "10.0.0.1";

     

       263
       263
       -
               type = types.nullOr types.str;

     

       264
       264
       -
               description = ''

     

       265
       265
       -
                 IP address of the interface.  Leave empty to configure the

     

       266
       266
       -
                 interface using DHCP.

     

       267
       267
       -
               '';

     

       268
       268
       -
             };

     

       269
       269
       -
       

     

       270
       270
       -
             prefixLength = mkOption {

     

       271
       271
       -
               default = null;

     

       272
       272
       -
               example = 24;

     

       273
       273
       -
               type = types.nullOr types.int;

     

       274
       274
       -
               description = ''

     

       275
       275
       -
                 Subnet mask of the interface, specified as the number of

     

       276
       276
       -
                 bits in the prefix (<literal>24</literal>).

     

       277
       277
       -
               '';

     

       278
       278
       -
             };

     

       279
       279
       -
       

     

       280
       280
       -
             subnetMask = mkOption {

     

       281
       281
       -
               default = null;

     

       282
       282
       -
               description = ''

     

       283
       283
       -
                 Defunct, supply the prefix length instead.

     

       284
       284
       -
               '';

     

       285
       285
       -
             };

     

       286
       286
       -
       

     

       287
       287
       -
             ipv6Address = mkOption {

     

       288
       288
       -
               default = null;

     

       289
       289
       -
               example = "2001:1470:fffd:2098::e006";

     

       290
       290
       -
               type = types.nullOr types.str;

     

       291
       291
       -
               description = ''

     

       292
       292
       -
                 IPv6 address of the interface.  Leave empty to configure the

     

       293
       293
       -
                 interface using NDP.

     

       294
       294
       -
               '';

     

       295
       295
       -
             };

     

       296
       296
       -
       

     

       297
       297
       -
             ipv6PrefixLength = mkOption {

     

       298
       298
       -
               default = 64;

     

       299
       299
       -
               example = 64;

     

       300
       300
       -
               type = types.int;

     

       301
       301
       -
               description = ''

     

       302
       302
       -
                 Subnet mask of the interface, specified as the number of

     

       303
       303
       -
                 bits in the prefix (<literal>64</literal>).

     

       304
       304
       -
               '';

     

       305
       305
       -
             };

     

       306
       306
       -
       

     

       307
       259
        
             macAddress = mkOption {

     

       308
       260
        
               default = null;

     

       309
       261
        
               example = "00:11:22:33:44:55";

     
···

       374
       326
        
           config = {

     

       375
       327
        
             name = mkDefault name;

     

       376
       328
        
           };

     

       329
       329
       +
       

     

       330
       330
       +
           # Renamed or removed options

     

       331
       331
       +
           imports =

     

       332
       332
       +
             let

     

       333
       333
       +
               defined = x: x != "_mkMergedOptionModule";

     

       334
       334
       +
             in [

     

       335
       335
       +
               (mkRenamedOptionModule [ "ip4" ] [ "ipv4" "addresses"])

     

       336
       336
       +
               (mkRenamedOptionModule [ "ip6" ] [ "ipv6" "addresses"])

     

       337
       337
       +
               (mkRemovedOptionModule [ "subnetMask" ] ''

     

       338
       338
       +
                 Supply a prefix length instead; use option

     

       339
       339
       +
                 networking.interfaces.<name>.ipv{4,6}.addresses'')

     

       340
       340
       +
               (mkMergedOptionModule

     

       341
       341
       +
                 [ [ "ipAddress" ] [ "prefixLength" ] ]

     

       342
       342
       +
                 [ "ipv4" "addresses" ]

     

       343
       343
       +
                 (cfg: with cfg;

     

       344
       344
       +
                   optional (defined ipAddress && defined prefixLength)

     

       345
       345
       +
                   { address = ipAddress; prefixLength = prefixLength; }))

     

       346
       346
       +
               (mkMergedOptionModule

     

       347
       347
       +
                 [ [ "ipv6Address" ] [ "ipv6PrefixLength" ] ]

     

       348
       348
       +
                 [ "ipv6" "addresses" ]

     

       349
       349
       +
                 (cfg: with cfg;

     

       350
       350
       +
                   optional (defined ipv6Address && defined ipv6PrefixLength)

     

       351
       351
       +
                   { address = ipv6Address; prefixLength = ipv6PrefixLength; }))

     

       352
       352
       +
       

     

       353
       353
       +
               ({ options.warnings = options.warnings; })

     

       354
       354
       +
             ];

     

       377
       355
        
       

     

       378
       356
        
         };

     

       379
       357
        
       

     
···

       511
       489
        
           networking.interfaces = mkOption {

     

       512
       490
        
             default = {};

     

       513
       491
        
             example =

     

       514
       514
       -
               { eth0.ip4 = [ {

     

       492
       492
       +
               { eth0.ipv4 = [ {

     

       515
       493
        
                   address = "131.211.84.78";

     

       516
       494
        
                   prefixLength = 25;

     

       517
       495
        
                 } ];

     
···

       990
       968
        
       

     

       991
       969
        
         config = {

     

       992
       970
        
       

     

       971
       971
       +
           warnings = concatMap (i: i.warnings) interfaces;

     

       972
       972
       +
       

     

       993
       973
        
           assertions =

     

       994
       974
        
             (flip map interfaces (i: {

     

       995
       995
       -
               assertion = i.subnetMask == null;

     

       996
       996
       -
               message = ''

     

       997
       997
       -
                 The networking.interfaces."${i.name}".subnetMask option is defunct. Use prefixLength instead.

     

       998
       998
       -
               '';

     

       999
       999
       -
             })) ++ (flip map interfaces (i: {

     

       1000
       975
        
               # With the linux kernel, interface name length is limited by IFNAMSIZ

     

       1001
       976
        
               # to 16 bytes, including the trailing null byte.

     

       1002
       977
        
               # See include/linux/if.h in the kernel sources

     
···

       1005
       980
        
                 The name of networking.interfaces."${i.name}" is too long, it needs to be less than 16 characters.

     

       1006
       981
        
               '';

     

       1007
       982
        
             })) ++ (flip map slaveIfs (i: {

     

       1008
       1008
       -
               assertion = i.ip4 == [ ] && i.ipAddress == null && i.ip6 == [ ] && i.ipv6Address == null;

     

       983
       983
       +
               assertion = i.ipv4.addresses == [ ] && i.ipv6.addresses == [ ];

     

       1009
       984
        
               message = ''

     

       1010
       985
        
                 The networking.interfaces."${i.name}" must not have any defined ips when it is a slave.

     

       1011
       986
        
               '';

+27 -29

nixos/tests/networking.nix

···

       21
       21
        
               firewall.allowedUDPPorts = [ 547 ];

     

       22
       22
        
               interfaces = mkOverride 0 (listToAttrs (flip map vlanIfs (n:

     

       23
       23
        
                 nameValuePair "eth${toString n}" {

     

       24
       24
       -
                   ipAddress = "192.168.${toString n}.1";

     

       25
       25
       -
                   prefixLength = 24;

     

       26
       26
       -
                   ipv6Address = "fd00:1234:5678:${toString n}::1";

     

       27
       27
       -
                   ipv6PrefixLength = 64;

     

       24
       24
       +
                   ipv4.addresses = [ { address = "192.168.${toString n}.1"; prefixLength = 24;} ];

     

       25
       25
       +
                   ipv6.addresses = [ { address = "fd00:1234:5678:${toString n}::1"; prefixLength = 64;} ];

     

       28
       26
        
                 })));

     

       29
       27
        
             };

     

       30
       28
        
             services.dhcpd4 = {

     
···

       90
       88
        
                 firewall.allowPing = true;

     

       91
       89
        
                 useDHCP = false;

     

       92
       90
        
                 defaultGateway = "192.168.1.1";

     

       93
       93
       -
                 interfaces.eth1.ip4 = mkOverride 0 [

     

       91
       91
       +
                 interfaces.eth1.ipv4.addresses = mkOverride 0 [

     

       94
       92
        
                   { address = "192.168.1.2"; prefixLength = 24; }

     

       95
       93
        
                   { address = "192.168.1.3"; prefixLength = 32; }

     

       96
       94
        
                   { address = "192.168.1.10"; prefixLength = 32; }

     

       97
       95
        
                 ];

     

       98
       98
       -
                 interfaces.eth2.ip4 = mkOverride 0 [

     

       96
       96
       +
                 interfaces.eth2.ipv4.addresses = mkOverride 0 [

     

       99
       97
        
                   { address = "192.168.2.2"; prefixLength = 24; }

     

       100
       98
        
                 ];

     

       101
       99
        
               };

     
···

       143
       141
        
                 firewall.allowPing = true;

     

       144
       142
        
                 useDHCP = true;

     

       145
       143
        
                 interfaces.eth1 = {

     

       146
       146
       -
                   ip4 = mkOverride 0 [ ];

     

       147
       147
       -
                   ip6 = mkOverride 0 [ ];

     

       144
       144
       +
                   ipv4.addresses = mkOverride 0 [ ];

     

       145
       145
       +
                   ipv6.addresses = mkOverride 0 [ ];

     

       148
       146
        
                 };

     

       149
       147
        
                 interfaces.eth2 = {

     

       150
       150
       -
                   ip4 = mkOverride 0 [ ];

     

       151
       151
       -
                   ip6 = mkOverride 0 [ ];

     

       148
       148
       +
                   ipv4.addresses = mkOverride 0 [ ];

     

       149
       149
       +
                   ipv6.addresses = mkOverride 0 [ ];

     

       152
       150
        
                 };

     

       153
       151
        
               };

     

       154
       152
        
             };

     
···

       198
       196
        
                 firewall.allowPing = true;

     

       199
       197
        
                 useDHCP = false;

     

       200
       198
        
                 interfaces.eth1 = {

     

       201
       201
       -
                   ip4 = mkOverride 0 [ ];

     

       199
       199
       +
                   ipv4.addresses = mkOverride 0 [ ];

     

       202
       200
        
                   useDHCP = true;

     

       203
       201
        
                 };

     

       204
       204
       -
                 interfaces.eth2.ip4 = mkOverride 0 [ ];

     

       202
       202
       +
                 interfaces.eth2.ipv4.addresses = mkOverride 0 [ ];

     

       205
       203
        
               };

     

       206
       204
        
             };

     

       207
       205
        
             testScript = { nodes, ... }:

     
···

       241
       239
        
                   interfaces = [ "eth1" "eth2" ];

     

       242
       240
        
                   driverOptions.mode = "balance-rr";

     

       243
       241
        
                 };

     

       244
       244
       -
                 interfaces.eth1.ip4 = mkOverride 0 [ ];

     

       245
       245
       -
                 interfaces.eth2.ip4 = mkOverride 0 [ ];

     

       246
       246
       -
                 interfaces.bond.ip4 = mkOverride 0

     

       242
       242
       +
                 interfaces.eth1.ipv4.addresses = mkOverride 0 [ ];

     

       243
       243
       +
                 interfaces.eth2.ipv4.addresses = mkOverride 0 [ ];

     

       244
       244
       +
                 interfaces.bond.ipv4.addresses = mkOverride 0

     

       247
       245
        
                   [ { inherit address; prefixLength = 30; } ];

     

       248
       246
        
               };

     

       249
       247
        
             };

     
···

       274
       272
        
                 useNetworkd = networkd;

     

       275
       273
        
                 firewall.allowPing = true;

     

       276
       274
        
                 useDHCP = false;

     

       277
       277
       -
                 interfaces.eth1.ip4 = mkOverride 0

     

       275
       275
       +
                 interfaces.eth1.ipv4.addresses = mkOverride 0

     

       278
       276
        
                   [ { inherit address; prefixLength = 24; } ];

     

       279
       277
        
               };

     

       280
       278
        
             };

     
···

       289
       287
        
                 firewall.allowPing = true;

     

       290
       288
        
                 useDHCP = false;

     

       291
       289
        
                 bridges.bridge.interfaces = [ "eth1" "eth2" ];

     

       292
       292
       -
                 interfaces.eth1.ip4 = mkOverride 0 [ ];

     

       293
       293
       -
                 interfaces.eth2.ip4 = mkOverride 0 [ ];

     

       294
       294
       -
                 interfaces.bridge.ip4 = mkOverride 0

     

       290
       290
       +
                 interfaces.eth1.ipv4.addresses = mkOverride 0 [ ];

     

       291
       291
       +
                 interfaces.eth2.ipv4.addresses = mkOverride 0 [ ];

     

       292
       292
       +
                 interfaces.bridge.ipv4.addresses = mkOverride 0

     

       295
       293
        
                   [ { address = "192.168.1.1"; prefixLength = 24; } ];

     

       296
       294
        
               };

     

       297
       295
        
             };

     
···

       328
       326
        
                 firewall.allowPing = true;

     

       329
       327
        
                 useDHCP = true;

     

       330
       328
        
                 macvlans.macvlan.interface = "eth1";

     

       331
       331
       -
                 interfaces.eth1.ip4 = mkOverride 0 [ ];

     

       329
       329
       +
                 interfaces.eth1.ipv4.addresses = mkOverride 0 [ ];

     

       332
       330
        
               };

     

       333
       331
        
             };

     

       334
       332
        
             testScript = { nodes, ... }:

     
···

       369
       367
        
                   local = address4;

     

       370
       368
        
                   dev = "eth1";

     

       371
       369
        
                 };

     

       372
       372
       -
                 interfaces.eth1.ip4 = mkOverride 0

     

       370
       370
       +
                 interfaces.eth1.ipv4.addresses = mkOverride 0

     

       373
       371
        
                   [ { address = address4; prefixLength = 24; } ];

     

       374
       374
       -
                 interfaces.sit.ip6 = mkOverride 0

     

       372
       372
       +
                 interfaces.sit.ipv6.addresses = mkOverride 0

     

       375
       373
        
                   [ { address = address6; prefixLength = 64; } ];

     

       376
       374
        
               };

     

       377
       375
        
             };

     
···

       410
       408
        
                   id = 1;

     

       411
       409
        
                   interface = "eth0";

     

       412
       410
        
                 };

     

       413
       413
       -
                 interfaces.eth0.ip4 = mkOverride 0 [ ];

     

       414
       414
       -
                 interfaces.eth1.ip4 = mkOverride 0 [ ];

     

       415
       415
       -
                 interfaces.vlan.ip4 = mkOverride 0

     

       411
       411
       +
                 interfaces.eth0.ipv4.addresses = mkOverride 0 [ ];

     

       412
       412
       +
                 interfaces.eth1.ipv4.addresses = mkOverride 0 [ ];

     

       413
       413
       +
                 interfaces.vlan.ipv4.addresses = mkOverride 0

     

       416
       414
        
                   [ { inherit address; prefixLength = 24; } ];

     

       417
       415
        
               };

     

       418
       416
        
             };

     
···

       538
       536
        
             machine = {

     

       539
       537
        
               networking.useDHCP = false;

     

       540
       538
        
               networking.interfaces."eth0" = {

     

       541
       541
       -
                 ip4 = [ { address = "192.168.1.2"; prefixLength = 24; } ];

     

       542
       542
       -
                 ip6 = [ { address = "2001:1470:fffd:2097::"; prefixLength = 64; } ];

     

       543
       543
       -
                 ipv6Routes = [

     

       539
       539
       +
                 ipv4.addresses = [ { address = "192.168.1.2"; prefixLength = 24; } ];

     

       540
       540
       +
                 ipv6.addresses = [ { address = "2001:1470:fffd:2097::"; prefixLength = 64; } ];

     

       541
       541
       +
                 ipv6.routes = [

     

       544
       542
        
                   { address = "fdfd:b3f0::"; prefixLength = 48; }

     

       545
       543
        
                   { address = "2001:1470:fffd:2098::"; prefixLength = 64; via = "fdfd:b3f0::1"; }

     

       546
       544
        
                 ];

     

       547
       547
       -
                 ipv4Routes = [

     

       545
       545
       +
                 ipv4.routes = [

     

       548
       546
        
                   { address = "10.0.0.0"; prefixLength = 16; options = { mtu = "1500"; }; }

     

       549
       547
        
                   { address = "192.168.2.0"; prefixLength = 24; via = "192.168.1.1"; }

     

       550
       548
        
                 ];