commit f0bb39d4b7d0feacda4a763b85947c3caf73c6df · pyrox.dev/nixpkgs

+15

nixos/doc/manual/from_md/release-notes/rl-2205.section.xml

···

       2471
       2471
        
                 hosts.

     

       2472
       2472
        
               </para>

     

       2473
       2473
        
             </listitem>

     

       2474
       2474
       +
             <listitem>

     

       2475
       2475
       +
               <para>

     

       2476
       2476
       +
                 The option

     

       2477
       2477
       +
                 <link xlink:href="options.html#opt-networking.useDHCP">networking.useDHCP</link>

     

       2478
       2478
       +
                 isn’t deprecated anymore. When using

     

       2479
       2479
       +
                 <link xlink:href="options.html#opt-networking.useNetworkd"><literal>systemd-networkd</literal></link>,

     

       2480
       2480
       +
                 a generic <literal>.network</literal>-unit is added which

     

       2481
       2481
       +
                 enables DHCP for each interface matching

     

       2482
       2482
       +
                 <literal>en*</literal>, <literal>eth*</literal> or

     

       2483
       2483
       +
                 <literal>wl*</literal> with priority 99 (which means that it

     

       2484
       2484
       +
                 doesn’t have any effect if such an interface is matched by a

     

       2485
       2485
       +
                 <literal>.network-</literal>unit with a lower priority). In

     

       2486
       2486
       +
                 case of scripted networking, no behavior was changed.

     

       2487
       2487
       +
               </para>

     

       2488
       2488
       +
             </listitem>

     

       2474
       2489
        
           </itemizedlist>

     

       2475
       2490
        
         </section>

     

       2476
       2491
        
       </section>

+7

nixos/doc/manual/release-notes/rl-2205.section.md

···

       877
       877
        
         `true` starting with NixOS 22.11. Enable it explicitly if you need to control

     

       878
       878
        
         Snapserver remotely or connect streamig clients from other hosts.

     

       879
       879
        
       

     

       880
       880
       +
       - The option [networking.useDHCP](options.html#opt-networking.useDHCP) isn't deprecated anymore.

     

       881
       881
       +
         When using [`systemd-networkd`](options.html#opt-networking.useNetworkd), a generic

     

       882
       882
       +
         `.network`-unit is added which enables DHCP for each interface matching `en*`, `eth*`

     

       883
       883
       +
         or `wl*` with priority 99 (which means that it doesn't have any effect if such an interface is matched

     

       884
       884
       +
         by a `.network-`unit with a lower priority). In case of scripted networking, no behavior

     

       885
       885
       +
         was changed.

     

       886
       886
       +
       

     

       880
       887
        
       <!-- To avoid merge conflicts, consider adding your item at an arbitrary place in the list instead. -->

+7 -5

nixos/modules/installer/tools/nixos-generate-config.pl

···

       581
       581
        
       EOF

     

       582
       582
        
       

     

       583
       583
        
       sub generateNetworkingDhcpConfig {

     

       584
       584
       +
           # FIXME disable networking.useDHCP by default when switching to networkd.

     

       584
       585
        
           my $config = <<EOF;

     

       585
       585
       -
         # The global useDHCP flag is deprecated, therefore explicitly set to false here.

     

       586
       586
       -
         # Per-interface useDHCP will be mandatory in the future, so this generated config

     

       587
       587
       -
         # replicates the default behaviour.

     

       588
       588
       -
         networking.useDHCP = lib.mkDefault false;

     

       586
       586
       +
         # Enables DHCP on each ethernet and wireless interface. In case of scripted networking

     

       587
       587
       +
         # (the default) this is the recommended approach. When using systemd-networkd it's

     

       588
       588
       +
         # still possible to use this option, but it's recommended to use it in conjunction

     

       589
       589
       +
         # with explicit per-interface declarations with `networking.interfaces.<interface>.useDHCP`.

     

       590
       590
       +
         networking.useDHCP = lib.mkDefault true;

     

       589
       591
        
       EOF

     

       590
       592
        
       

     

       591
       593
        
           foreach my $path (glob "/sys/class/net/*") {

     

       592
       594
        
               my $dev = basename($path);

     

       593
       595
        
               if ($dev ne "lo") {

     

       594
       594
       -
                   $config .= "  networking.interfaces.$dev.useDHCP = lib.mkDefault true;\n";

     

       596
       596
       +
                   $config .= "  # networking.interfaces.$dev.useDHCP = lib.mkDefault true;\n";

     

       595
       597
        
               }

     

       596
       598
        
           }

     

       597
       599

+1

nixos/modules/system/boot/networkd.nix

···

       779
       779
        
                 "RouteDenyList"

     

       780
       780
        
                 "RouteAllowList"

     

       781
       781
        
                 "DHCPv6Client"

     

       782
       782
       +
                 "RouteMetric"

     

       782
       783
        
               ])

     

       783
       784
        
               (assertValueOneOf "UseDNS" boolValues)

     

       784
       785
        
               (assertValueOneOf "UseDomains" (boolValues ++ ["route"]))

+36 -6

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

···

       43
       43
        
           } {

     

       44
       44
        
             assertion = cfg.defaultGateway6 == null || cfg.defaultGateway6.interface == null;

     

       45
       45
        
             message = "networking.defaultGateway6.interface is not supported by networkd.";

     

       46
       46
       -
           } {

     

       47
       47
       -
             assertion = cfg.useDHCP == false;

     

       48
       48
       -
             message = ''

     

       49
       49
       -
               networking.useDHCP is not supported by networkd.

     

       50
       50
       -
               Please use per interface configuration and set the global option to false.

     

       51
       51
       -
             '';

     

       52
       46
        
           } ] ++ flip mapAttrsToList cfg.bridges (n: { rstp, ... }: {

     

       53
       47
        
             assertion = !rstp;

     

       54
       48
        
             message = "networking.bridges.${n}.rstp is not supported by networkd.";

     
···

       80
       74
        
             in mkMerge [ {

     

       81
       75
        
               enable = true;

     

       82
       76
        
             }

     

       77
       77
       +
             (mkIf cfg.useDHCP {

     

       78
       78
       +
               networks."99-ethernet-default-dhcp" = lib.mkIf cfg.useDHCP {

     

       79
       79
       +
                 # We want to match physical ethernet interfaces as commonly

     

       80
       80
       +
                 # found on laptops, desktops and servers, to provide an

     

       81
       81
       +
                 # "out-of-the-box" setup that works for common cases.  This

     

       82
       82
       +
                 # heuristic isn't perfect (it could match interfaces with

     

       83
       83
       +
                 # custom names that _happen_ to start with en or eth), but

     

       84
       84
       +
                 # should be good enough to make the common case easy and can

     

       85
       85
       +
                 # be overridden on a case-by-case basis using

     

       86
       86
       +
                 # higher-priority networks or by disabling useDHCP.

     

       87
       87
       +
       

     

       88
       88
       +
                 # Type=ether matches veth interfaces as well, and this is

     

       89
       89
       +
                 # more likely to result in interfaces being configured to

     

       90
       90
       +
                 # use DHCP when they shouldn't.

     

       91
       91
       +
       

     

       92
       92
       +
                 # We set RequiredForOnline to false, because it's fairly

     

       93
       93
       +
                 # common for such devices to have multiple interfaces and

     

       94
       94
       +
                 # only one of them to be connected (e.g. a laptop with

     

       95
       95
       +
                 # ethernet and WiFi interfaces). Maybe one day networkd will

     

       96
       96
       +
                 # support "any"-style RequiredForOnline...

     

       97
       97
       +
                 matchConfig.Name = ["en*" "eth*"];

     

       98
       98
       +
                 DHCP = "yes";

     

       99
       99
       +
                 linkConfig.RequiredForOnline = lib.mkDefault false;

     

       100
       100
       +
               };

     

       101
       101
       +
               networks."99-wireless-client-dhcp" = lib.mkIf cfg.useDHCP {

     

       102
       102
       +
                 # Like above, but this is much more likely to be correct.

     

       103
       103
       +
                 matchConfig.WLANInterfaceType = "station";

     

       104
       104
       +
                 DHCP = "yes";

     

       105
       105
       +
                 linkConfig.RequiredForOnline = lib.mkDefault false;

     

       106
       106
       +
                 # We also set the route metric to one more than the default

     

       107
       107
       +
                 # of 1024, so that Ethernet is preferred if both are

     

       108
       108
       +
                 # available.

     

       109
       109
       +
                 dhcpV4Config.RouteMetric = 1025;

     

       110
       110
       +
                 ipv6AcceptRAConfig.RouteMetric = 1025;

     

       111
       111
       +
               };

     

       112
       112
       +
             })

     

       83
       113
        
             (mkMerge (forEach interfaces (i: {

     

       84
       114
        
               netdevs = mkIf i.virtual ({

     

       85
       115
        
                 "40-${i.name}" = {

-5

nixos/modules/tasks/network-interfaces.nix

···

       1254
       1254
        
               Whether to use DHCP to obtain an IP address and other

     

       1255
       1255
        
               configuration for all network interfaces that are not manually

     

       1256
       1256
        
               configured.

     

       1257
       1257
       -
       

     

       1258
       1258
       -
               Using this option is highly discouraged and also incompatible with

     

       1259
       1259
       -
               <option>networking.useNetworkd</option>. Please use

     

       1260
       1260
       -
               <option>networking.interfaces.&lt;name&gt;.useDHCP</option> instead

     

       1261
       1261
       -
               and set this to false.

     

       1262
       1257
        
             '';

     

       1263
       1258
        
           };

     

       1264
       1259

+20

nixos/tests/networking.nix

···

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

     

       140
       140
        
               '';

     

       141
       141
        
           };

     

       142
       142
       +
           dhcpDefault = {

     

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

     

       144
       144
       +
             nodes.router = router;

     

       145
       145
       +
             nodes.client = { lib, ... }: {

     

       146
       146
       +
               # Disable test driver default config

     

       147
       147
       +
               networking.interfaces = lib.mkForce {};

     

       148
       148
       +
               networking.useNetworkd = networkd;

     

       149
       149
       +
               virtualisation.vlans = [ 1 ];

     

       150
       150
       +
             };

     

       151
       151
       +
             testScript = ''

     

       152
       152
       +
               start_all()

     

       153
       153
       +
               client.wait_for_unit("multi-user.target")

     

       154
       154
       +
               client.wait_until_succeeds("ip addr show dev eth1 | grep '192.168.1'")

     

       155
       155
       +
               client.shell_interact()

     

       156
       156
       +
               client.succeed("ping -c 1 192.168.1.1")

     

       157
       157
       +
               router.succeed("ping -c 1 192.168.1.1")

     

       158
       158
       +
               router.succeed("ping -c 1 192.168.1.2")

     

       159
       159
       +
               client.succeed("ping -c 1 192.168.1.2")

     

       160
       160
       +
             '';

     

       161
       161
       +
           };

     

       142
       162
        
           dhcpSimple = {

     

       143
       163
        
             name = "SimpleDHCP";

     

       144
       164
        
             nodes.router = router;