commit fd78ff23f7dd0db1a468189672aeb85f53d4ec99 · pyrox.dev/nixpkgs

-6

nixos/modules/tasks/network-interfaces.nix

···

       940
       940
        
               source  = "${pkgs.iputils.out}/bin/ping";

     

       941
       941
        
               capabilities = "cap_net_raw+p";

     

       942
       942
        
             };

     

       943
       943
       -
       

     

       944
       944
       -
             ping6 = {

     

       945
       945
       -
               source  = "${pkgs.iputils.out}/bin/ping6";

     

       946
       946
       -
               capabilities = "cap_net_raw+p";

     

       947
       947
       -
             };

     

       948
       943
        
           } else {

     

       949
       944
        
             ping.source = "${pkgs.iputils.out}/bin/ping";

     

       950
       950
       -
             "ping6".source = "${pkgs.iputils.out}/bin/ping6";

     

       951
       945
        
           };

     

       952
       946
        
       

     

       953
       947
        
           # Set the host and domain names in the activation script.  Don't

+6 -6

nixos/tests/cjdns.nix

···

       109
       109
        
       

     

       110
       110
        
             # ping a few times each to let the routing table establish itself

     

       111
       111
        
       

     

       112
       112
       -
             $alice->succeed("ping6 -c 4 $carolIp6");

     

       113
       113
       -
             $bob->succeed("ping6 -c 4 $carolIp6");

     

       112
       112
       +
             $alice->succeed("ping -c 4 $carolIp6");

     

       113
       113
       +
             $bob->succeed("ping -c 4 $carolIp6");

     

       114
       114
        
       

     

       115
       115
       -
             $carol->succeed("ping6 -c 4 $aliceIp6");

     

       116
       116
       -
             $carol->succeed("ping6 -c 4 $bobIp6");

     

       115
       115
       +
             $carol->succeed("ping -c 4 $aliceIp6");

     

       116
       116
       +
             $carol->succeed("ping -c 4 $bobIp6");

     

       117
       117
        
       

     

       118
       118
       -
             $alice->succeed("ping6 -c 4 $bobIp6");

     

       119
       119
       -
             $bob->succeed("ping6 -c 4 $aliceIp6");

     

       118
       118
       +
             $alice->succeed("ping -c 4 $bobIp6");

     

       119
       119
       +
             $bob->succeed("ping -c 4 $aliceIp6");

     

       120
       120
        
       

     

       121
       121
        
             $alice->waitForUnit("httpd.service");

     

       122
       122

+1 -1

nixos/tests/containers-bridge.nix

···

       66
       66
        
             "${containerIp6}" =~ /([^\/]+)\/([0-9+])/;

     

       67
       67
        
             my $ip6 = $1;

     

       68
       68
        
             chomp $ip6;

     

       69
       69
       -
             $machine->succeed("ping6 -n -c 1 $ip6");

     

       69
       69
       +
             $machine->succeed("ping -n -c 1 $ip6");

     

       70
       70
        
             $machine->succeed("curl --fail http://[$ip6]/ > /dev/null");

     

       71
       71
        
       

     

       72
       72
        
             # Stop the container.

+1 -1

nixos/tests/containers-extra_veth.nix

···

       84
       84
        
       

     

       85
       85
        
             # Ping on main veth

     

       86
       86
        
             $machine->succeed("ping -n -c 1 192.168.0.100");

     

       87
       87
       -
             $machine->succeed("ping6 -n -c 1 fc00::2");

     

       87
       87
       +
             $machine->succeed("ping -n -c 1 fc00::2");

     

       88
       88
        
       

     

       89
       89
        
             # Ping on the first extra veth

     

       90
       90
        
             $machine->succeed("ping -n -c 1 192.168.1.100 >&2");

+1 -1

nixos/tests/containers-ipv6.nix

···

       47
       47
        
             # multi-user.target, we should now be able to access it.

     

       48
       48
        
             my $ip = "${localIp}";

     

       49
       49
        
             chomp $ip;

     

       50
       50
       -
             $machine->succeed("ping6 -n -c 1 $ip");

     

       50
       50
       +
             $machine->succeed("ping -n -c 1 $ip");

     

       51
       51
        
             $machine->succeed("curl --fail http://[$ip]/ > /dev/null");

     

       52
       52
        
       

     

       53
       53
        
             # Stop the container.

+6 -6

nixos/tests/ipv6.nix

···

       54
       54
        
             }

     

       55
       55
        
       

     

       56
       56
        
             subtest "loopback address", sub {

     

       57
       57
       -
                 $client->succeed("ping6 -c 1 ::1 >&2");

     

       58
       58
       -
                 $client->fail("ping6 -c 1 ::2 >&2");

     

       57
       57
       +
                 $client->succeed("ping -c 1 ::1 >&2");

     

       58
       58
       +
                 $client->fail("ping -c 1 ::2 >&2");

     

       59
       59
        
             };

     

       60
       60
        
       

     

       61
       61
        
             subtest "local link addressing", sub {

     

       62
       62
        
                 my $clientIp = waitForAddress $client, "eth1", "link";

     

       63
       63
        
                 my $serverIp = waitForAddress $server, "eth1", "link";

     

       64
       64
       -
                 $client->succeed("ping6 -c 1 -I eth1 $clientIp >&2");

     

       65
       65
       -
                 $client->succeed("ping6 -c 1 -I eth1 $serverIp >&2");

     

       64
       64
       +
                 $client->succeed("ping -c 1 $clientIp%eth1 >&2");

     

       65
       65
       +
                 $client->succeed("ping -c 1 $serverIp%eth1 >&2");

     

       66
       66
        
             };

     

       67
       67
        
       

     

       68
       68
        
             subtest "global addressing", sub {

     

       69
       69
        
                 my $clientIp = waitForAddress $client, "eth1", "global";

     

       70
       70
        
                 my $serverIp = waitForAddress $server, "eth1", "global";

     

       71
       71
       -
                 $client->succeed("ping6 -c 1 $clientIp >&2");

     

       72
       72
       -
                 $client->succeed("ping6 -c 1 $serverIp >&2");

     

       71
       71
       +
                 $client->succeed("ping -c 1 $clientIp >&2");

     

       72
       72
       +
                 $client->succeed("ping -c 1 $serverIp >&2");

     

       73
       73
        
                 $client->succeed("curl --fail -g http://[$serverIp]");

     

       74
       74
        
                 $client->fail("curl --fail -g http://[$clientIp]");

     

       75
       75
        
             };

+12 -12

nixos/tests/networking.nix

···

       166
       166
        
                 # Test vlan 1

     

       167
       167
        
                 $client->waitUntilSucceeds("ping -c 1 192.168.1.1");

     

       168
       168
        
                 $client->waitUntilSucceeds("ping -c 1 192.168.1.2");

     

       169
       169
       -
                 $client->waitUntilSucceeds("ping6 -c 1 fd00:1234:5678:1::1");

     

       170
       170
       -
                 $client->waitUntilSucceeds("ping6 -c 1 fd00:1234:5678:1::2");

     

       169
       169
       +
                 $client->waitUntilSucceeds("ping -c 1 fd00:1234:5678:1::1");

     

       170
       170
       +
                 $client->waitUntilSucceeds("ping -c 1 fd00:1234:5678:1::2");

     

       171
       171
        
       

     

       172
       172
        
                 $router->waitUntilSucceeds("ping -c 1 192.168.1.1");

     

       173
       173
        
                 $router->waitUntilSucceeds("ping -c 1 192.168.1.2");

     

       174
       174
       -
                 $router->waitUntilSucceeds("ping6 -c 1 fd00:1234:5678:1::1");

     

       175
       175
       -
                 $router->waitUntilSucceeds("ping6 -c 1 fd00:1234:5678:1::2");

     

       174
       174
       +
                 $router->waitUntilSucceeds("ping -c 1 fd00:1234:5678:1::1");

     

       175
       175
       +
                 $router->waitUntilSucceeds("ping -c 1 fd00:1234:5678:1::2");

     

       176
       176
        
       

     

       177
       177
        
                 # Test vlan 2

     

       178
       178
        
                 $client->waitUntilSucceeds("ping -c 1 192.168.2.1");

     

       179
       179
        
                 $client->waitUntilSucceeds("ping -c 1 192.168.2.2");

     

       180
       180
       -
                 $client->waitUntilSucceeds("ping6 -c 1 fd00:1234:5678:2::1");

     

       181
       181
       -
                 $client->waitUntilSucceeds("ping6 -c 1 fd00:1234:5678:2::2");

     

       180
       180
       +
                 $client->waitUntilSucceeds("ping -c 1 fd00:1234:5678:2::1");

     

       181
       181
       +
                 $client->waitUntilSucceeds("ping -c 1 fd00:1234:5678:2::2");

     

       182
       182
        
       

     

       183
       183
        
                 $router->waitUntilSucceeds("ping -c 1 192.168.2.1");

     

       184
       184
        
                 $router->waitUntilSucceeds("ping -c 1 192.168.2.2");

     

       185
       185
       -
                 $router->waitUntilSucceeds("ping6 -c 1 fd00:1234:5678:2::1");

     

       186
       186
       -
                 $router->waitUntilSucceeds("ping6 -c 1 fd00:1234:5678:2::2");

     

       185
       185
       +
                 $router->waitUntilSucceeds("ping -c 1 fd00:1234:5678:2::1");

     

       186
       186
       +
                 $router->waitUntilSucceeds("ping -c 1 fd00:1234:5678:2::2");

     

       187
       187
        
               '';

     

       188
       188
        
           };

     

       189
       189
        
           dhcpOneIf = {

     
···

       390
       390
        
                 $client2->succeed("ip addr >&2");

     

       391
       391
        
       

     

       392
       392
        
                 # Test ipv6

     

       393
       393
       -
                 $client1->waitUntilSucceeds("ping6 -c 1 fc00::1");

     

       394
       394
       -
                 $client1->waitUntilSucceeds("ping6 -c 1 fc00::2");

     

       393
       393
       +
                 $client1->waitUntilSucceeds("ping -c 1 fc00::1");

     

       394
       394
       +
                 $client1->waitUntilSucceeds("ping -c 1 fc00::2");

     

       395
       395
        
       

     

       396
       396
       -
                 $client2->waitUntilSucceeds("ping6 -c 1 fc00::1");

     

       397
       397
       -
                 $client2->waitUntilSucceeds("ping6 -c 1 fc00::2");

     

       396
       396
       +
                 $client2->waitUntilSucceeds("ping -c 1 fc00::1");

     

       397
       397
       +
                 $client2->waitUntilSucceeds("ping -c 1 fc00::2");

     

       398
       398
        
               '';

     

       399
       399
        
           };

     

       400
       400
        
           vlan = let

+2 -2

pkgs/servers/monitoring/nagios/plugins/official-2.x.nix

···

       16
       16
        
         # configured on the build machine).

     

       17
       17
        
         preConfigure= "

     

       18
       18
        
           configureFlagsArray=(

     

       19
       19
       -
             --with-ping-command='/run/wrappers/bin/ping -n -U -w %d -c %d %s'

     

       20
       20
       -
             --with-ping6-command='/run/wrappers/bin/ping6 -n -U -w %d -c %d %s'

     

       19
       19
       +
             --with-ping-command='/run/wrappers/bin/ping -4 -n -U -w %d -c %d %s'

     

       20
       20
       +
             --with-ping6-command='/run/wrappers/bin/ping -6 -n -U -w %d -c %d %s'

     

       21
       21
        
           )

     

       22
       22
        
         ";

     

       23
       23