commit 195521350ae6035b561e5d0227f83dee6effa5f7 · pyrox.dev/nixpkgs

+9 -9

nixos/modules/config/nsswitch.nix

···

       17
       17
        
         resolved = canLoadExternalModules && config.services.resolved.enable;

     

       18
       18
        
       

     

       19
       19
        
         hostArray = [ "files" ]

     

       20
       20
       -
           ++ optionals mymachines [ "mymachines" ]

     

       21
       21
       -
           ++ optionals nssmdns [ "mdns_minimal [NOTFOUND=return]" ]

     

       22
       22
       -
           ++ optionals nsswins [ "wins" ]

     

       23
       23
       -
           ++ optionals resolved ["resolve [!UNAVAIL=return]"]

     

       20
       20
       +
           ++ optional mymachines "mymachines"

     

       21
       21
       +
           ++ optional nssmdns "mdns_minimal [NOTFOUND=return]"

     

       22
       22
       +
           ++ optional nsswins "wins"

     

       23
       23
       +
           ++ optional resolved "resolve [!UNAVAIL=return]"

     

       24
       24
        
           ++ [ "dns" ]

     

       25
       25
       -
           ++ optionals nssmdns [ "mdns" ]

     

       26
       26
       -
           ++ optionals myhostname ["myhostname" ];

     

       25
       25
       +
           ++ optional nssmdns "mdns"

     

       26
       26
       +
           ++ optional myhostname "myhostname";

     

       27
       27
        
       

     

       28
       28
        
         passwdArray = [ "files" ]

     

       29
       29
        
           ++ optional sssd "sss"

     

       30
       30
       -
           ++ optionals ldap [ "ldap" ]

     

       31
       31
       -
           ++ optionals mymachines [ "mymachines" ]

     

       30
       30
       +
           ++ optional ldap "ldap"

     

       31
       31
       +
           ++ optional mymachines "mymachines"

     

       32
       32
        
           ++ [ "systemd" ];

     

       33
       33
        
       

     

       34
       34
        
         shadowArray = [ "files" ]

     

       35
       35
        
           ++ optional sssd "sss"

     

       36
       36
       -
           ++ optionals ldap [ "ldap" ];

     

       36
       36
       +
           ++ optional ldap "ldap";

     

       37
       37
        
       

     

       38
       38
        
         servicesArray = [ "files" ]

     

       39
       39
        
           ++ optional sssd "sss";

+23 -29

nixos/modules/config/users-groups.nix

···

       504
       504
        
             };

     

       505
       505
        
           };

     

       506
       506
        
       

     

       507
       507
       -
           # Install all the user shells

     

       508
       508
       -
           environment.systemPackages = systemShells;

     

       509
       509
       -
       

     

       510
       507
        
           users.groups = {

     

       511
       508
        
             root.gid = ids.gids.root;

     

       512
       509
        
             wheel.gid = ids.gids.wheel;

     
···

       543
       540
        
           # for backwards compatibility

     

       544
       541
        
           system.activationScripts.groups = stringAfter [ "users" ] "";

     

       545
       542
        
       

     

       546
       546
       -
           environment.etc."subuid" = {

     

       547
       547
       -
             text = subuidFile;

     

       548
       548
       -
             mode = "0644";

     

       549
       549
       -
           };

     

       550
       550
       -
           environment.etc."subgid" = {

     

       551
       551
       -
             text = subgidFile;

     

       552
       552
       -
             mode = "0644";

     

       553
       553
       -
           };

     

       543
       543
       +
           # Install all the user shells

     

       544
       544
       +
           environment.systemPackages = systemShells;

     

       545
       545
       +
       

     

       546
       546
       +
           environment.etc = {

     

       547
       547
       +
             "subuid" = {

     

       548
       548
       +
               text = subuidFile;

     

       549
       549
       +
               mode = "0644";

     

       550
       550
       +
             };

     

       551
       551
       +
             "subgid" = {

     

       552
       552
       +
               text = subgidFile;

     

       553
       553
       +
               mode = "0644";

     

       554
       554
       +
             };

     

       555
       555
       +
           } // (mapAttrs' (name: { packages, ... }: {

     

       556
       556
       +
             name = "profiles/per-user/${name}";

     

       557
       557
       +
             value.source = pkgs.buildEnv {

     

       558
       558
       +
               name = "user-environment";

     

       559
       559
       +
               paths = packages;

     

       560
       560
       +
               inherit (config.environment) pathsToLink extraOutputsToInstall;

     

       561
       561
       +
               inherit (config.system.path) ignoreCollisions postBuild;

     

       562
       562
       +
             };

     

       563
       563
       +
           }) (filterAttrs (_: u: u.packages != []) cfg.users));

     

       564
       564
       +
       

     

       565
       565
       +
           environment.profiles = [ "/etc/profiles/per-user/$USER" ];

     

       554
       566
        
       

     

       555
       567
        
           assertions = [

     

       556
       568
        
             { assertion = !cfg.enforceIdUniqueness || (uidsAreUnique && gidsAreUnique);

     
···

       581
       593
        
       

     

       582
       594
        
         };

     

       583
       595
        
       

     

       584
       584
       -
         imports =

     

       585
       585
       -
           [ (mkAliasOptionModule [ "users" "extraUsers" ] [ "users" "users" ])

     

       586
       586
       -
             (mkAliasOptionModule [ "users" "extraGroups" ] [ "users" "groups" ])

     

       587
       587
       -
             {

     

       588
       588
       -
               environment = {

     

       589
       589
       -
                 etc = mapAttrs' (name: { packages, ... }: {

     

       590
       590
       -
                   name = "profiles/per-user/${name}";

     

       591
       591
       -
                   value.source = pkgs.buildEnv {

     

       592
       592
       -
                     name = "user-environment";

     

       593
       593
       -
                     paths = packages;

     

       594
       594
       -
                     inherit (config.environment) pathsToLink extraOutputsToInstall;

     

       595
       595
       -
                     inherit (config.system.path) ignoreCollisions postBuild;

     

       596
       596
       -
                   };

     

       597
       597
       -
                 }) (filterAttrs (_: { packages, ... }: packages != []) cfg.users);

     

       598
       598
       -
                 profiles = ["/etc/profiles/per-user/$USER"];

     

       599
       599
       -
               };

     

       600
       600
       -
             }

     

       601
       601
       -
           ];

     

       602
       596
        
       }

nixos/modules/rename.nix

···

       4
       4
        
       

     

       5
       5
        
       {

     

       6
       6
        
         imports = [

     

       7
       7
       +
           (mkRenamedOptionModule [ "dysnomia" ] [ "services" "dysnomia" ])

     

       7
       8
        
           (mkRenamedOptionModule [ "environment" "x11Packages" ] [ "environment" "systemPackages" ])

     

       8
       9
        
           (mkRenamedOptionModule [ "environment" "enableBashCompletion" ] [ "programs" "bash" "enableCompletion" ])

     

       9
       10
        
           (mkRenamedOptionModule [ "environment" "nix" ] [ "nix" "package" ])

     
···

       202
       203
        
           (mkRenamedOptionModule [ "config" "system" "nixosRevision" ] [ "config" "system" "nixos" "revision" ])

     

       203
       204
        
           (mkRenamedOptionModule [ "config" "system" "nixosCodeName" ] [ "config" "system" "nixos" "codeName" ])

     

       204
       205
        
           (mkRenamedOptionModule [ "config" "system" "nixosLabel" ] [ "config" "system" "nixos" "label" ])

     

       206
       206
       +
       

     

       207
       207
       +
           # Users

     

       208
       208
       +
           (mkAliasOptionModule [ "users" "extraUsers" ] [ "users" "users" ])

     

       209
       209
       +
           (mkAliasOptionModule [ "users" "extraGroups" ] [ "users" "groups" ])

     

       205
       210
        
       

     

       206
       211
        
           # Options that are obsolete and have no replacement.

     

       207
       212
        
           (mkRemovedOptionModule [ "boot" "initrd" "luks" "enable" ] "")

+1 -1

nixos/modules/services/misc/disnix.nix

···

       57
       57
        
         ###### implementation

     

       58
       58
        
       

     

       59
       59
        
         config = mkIf cfg.enable {

     

       60
       60
       -
           dysnomia.enable = true;

     

       60
       60
       +
           services.dysnomia.enable = true;

     

       61
       61
        
       

     

       62
       62
        
           environment.systemPackages = [ pkgs.disnix ] ++ optional cfg.useWebServiceInterface pkgs.DisnixWebService;

     

       63
       63

+29 -29

nixos/modules/services/misc/dysnomia.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
       -
         cfg = config.dysnomia;

     

       7
       7
       -
         

     

       6
       6
       +
         cfg = config.services.dysnomia;

     

       7
       7
       +
       

     

       8
       8
        
         printProperties = properties:

     

       9
       9
        
           concatMapStrings (propertyName:

     

       10
       10
        
             let

     
···

       13
       13
        
             if isList property then "${propertyName}=(${lib.concatMapStrings (elem: "\"${toString elem}\" ") (properties."${propertyName}")})\n"

     

       14
       14
        
             else "${propertyName}=\"${toString property}\"\n"

     

       15
       15
        
           ) (builtins.attrNames properties);

     

       16
       16
       -
         

     

       16
       16
       +
       

     

       17
       17
        
         properties = pkgs.stdenv.mkDerivation {

     

       18
       18
        
           name = "dysnomia-properties";

     

       19
       19
        
           buildCommand = ''

     
···

       22
       22
        
             EOF

     

       23
       23
        
           '';

     

       24
       24
        
         };

     

       25
       25
       -
         

     

       25
       25
       +
       

     

       26
       26
        
         containersDir = pkgs.stdenv.mkDerivation {

     

       27
       27
        
           name = "dysnomia-containers";

     

       28
       28
        
           buildCommand = ''

     

       29
       29
        
             mkdir -p $out

     

       30
       30
        
             cd $out

     

       31
       31
       -
             

     

       31
       31
       +
       

     

       32
       32
        
             ${concatMapStrings (containerName:

     

       33
       33
        
               let

     

       34
       34
        
                 containerProperties = cfg.containers."${containerName}";

     
···

       42
       42
        
             ) (builtins.attrNames cfg.containers)}

     

       43
       43
        
           '';

     

       44
       44
        
         };

     

       45
       45
       -
         

     

       45
       45
       +
       

     

       46
       46
        
         linkMutableComponents = {containerName}:

     

       47
       47
        
           ''

     

       48
       48
        
             mkdir ${containerName}

     

       49
       49
       -
             

     

       49
       49
       +
       

     

       50
       50
        
             ${concatMapStrings (componentName:

     

       51
       51
        
               let

     

       52
       52
        
                 component = cfg.components."${containerName}"."${componentName}";

     
···

       54
       54
        
               "ln -s ${component} ${containerName}/${componentName}\n"

     

       55
       55
        
             ) (builtins.attrNames (cfg.components."${containerName}" or {}))}

     

       56
       56
        
           '';

     

       57
       57
       -
         

     

       57
       57
       +
       

     

       58
       58
        
         componentsDir = pkgs.stdenv.mkDerivation {

     

       59
       59
        
           name = "dysnomia-components";

     

       60
       60
        
           buildCommand = ''

     

       61
       61
        
             mkdir -p $out

     

       62
       62
        
             cd $out

     

       63
       63
       -
             

     

       63
       63
       +
       

     

       64
       64
        
             ${concatMapStrings (containerName:

     

       65
       65
        
               let

     

       66
       66
        
                 components = cfg.components."${containerName}";

     
···

       72
       72
        
       in

     

       73
       73
        
       {

     

       74
       74
        
         options = {

     

       75
       75
       -
           dysnomia = {

     

       76
       76
       -
             

     

       75
       75
       +
           services.dysnomia = {

     

       76
       76
       +
       

     

       77
       77
        
             enable = mkOption {

     

       78
       78
        
               type = types.bool;

     

       79
       79
        
               default = false;

     

       80
       80
        
               description = "Whether to enable Dysnomia";

     

       81
       81
        
             };

     

       82
       82
       -
             

     

       82
       82
       +
       

     

       83
       83
        
             enableAuthentication = mkOption {

     

       84
       84
        
               type = types.bool;

     

       85
       85
        
               default = false;

     

       86
       86
        
               description = "Whether to publish privacy-sensitive authentication credentials";

     

       87
       87
        
             };

     

       88
       88
       -
             

     

       88
       88
       +
       

     

       89
       89
        
             package = mkOption {

     

       90
       90
        
               type = types.path;

     

       91
       91
        
               description = "The Dysnomia package";

     

       92
       92
        
             };

     

       93
       93
       -
             

     

       93
       93
       +
       

     

       94
       94
        
             properties = mkOption {

     

       95
       95
        
               description = "An attribute set in which each attribute represents a machine property. Optionally, these values can be shell substitutions.";

     

       96
       96
        
               default = {};

     

       97
       97
        
             };

     

       98
       98
       -
             

     

       98
       98
       +
       

     

       99
       99
        
             containers = mkOption {

     

       100
       100
        
               description = "An attribute set in which each key represents a container and each value an attribute set providing its configuration properties";

     

       101
       101
        
               default = {};

     

       102
       102
        
             };

     

       103
       103
       -
             

     

       103
       103
       +
       

     

       104
       104
        
             components = mkOption {

     

       105
       105
        
               description = "An atttribute set in which each key represents a container and each value an attribute set in which each key represents a component and each value a derivation constructing its initial state";

     

       106
       106
        
               default = {};

     

       107
       107
        
             };

     

       108
       108
       -
             

     

       108
       108
       +
       

     

       109
       109
        
             extraContainerProperties = mkOption {

     

       110
       110
        
               description = "An attribute set providing additional container settings in addition to the default properties";

     

       111
       111
        
               default = {};

     

       112
       112
        
             };

     

       113
       113
       -
             

     

       113
       113
       +
       

     

       114
       114
        
             extraContainerPaths = mkOption {

     

       115
       115
        
               description = "A list of paths containing additional container configurations that are added to the search folders";

     

       116
       116
        
               default = [];

     

       117
       117
        
             };

     

       118
       118
       -
             

     

       118
       118
       +
       

     

       119
       119
        
             extraModulePaths = mkOption {

     

       120
       120
        
               description = "A list of paths containing additional modules that are added to the search folders";

     

       121
       121
        
               default = [];

     

       122
       122
        
             };

     

       123
       123
        
           };

     

       124
       124
        
         };

     

       125
       125
       -
         

     

       125
       125
       +
       

     

       126
       126
        
         config = mkIf cfg.enable {

     

       127
       127
       -
         

     

       127
       127
       +
       

     

       128
       128
        
           environment.etc = {

     

       129
       129
        
             "dysnomia/containers" = {

     

       130
       130
        
               source = containersDir;

     
···

       136
       136
        
               source = properties;

     

       137
       137
        
             };

     

       138
       138
        
           };

     

       139
       139
       -
           

     

       139
       139
       +
       

     

       140
       140
        
           environment.variables = {

     

       141
       141
        
             DYSNOMIA_STATEDIR = "/var/state/dysnomia-nixos";

     

       142
       142
        
             DYSNOMIA_CONTAINERS_PATH = "${lib.concatMapStrings (containerPath: "${containerPath}:") cfg.extraContainerPaths}/etc/dysnomia/containers";

     

       143
       143
        
             DYSNOMIA_MODULES_PATH = "${lib.concatMapStrings (modulePath: "${modulePath}:") cfg.extraModulePaths}/etc/dysnomia/modules";

     

       144
       144
        
           };

     

       145
       145
       -
           

     

       145
       145
       +
       

     

       146
       146
        
           environment.systemPackages = [ cfg.package ];

     

       147
       147
       -
           

     

       148
       148
       -
           dysnomia.package = pkgs.dysnomia.override (origArgs: {

     

       147
       147
       +
       

     

       148
       148
       +
           services.dysnomia.package = pkgs.dysnomia.override (origArgs: {

     

       149
       149
        
             enableApacheWebApplication = config.services.httpd.enable;

     

       150
       150
        
             enableAxis2WebService = config.services.tomcat.axis2.enable;

     

       151
       151
        
             enableEjabberdDump = config.services.ejabberd.enable;

     
···

       155
       155
        
             enableTomcatWebApplication = config.services.tomcat.enable;

     

       156
       156
        
             enableMongoDatabase = config.services.mongodb.enable;

     

       157
       157
        
           });

     

       158
       158
       -
           

     

       159
       159
       -
           dysnomia.properties = {

     

       158
       158
       +
       

     

       159
       159
       +
           services.dysnomia.properties = {

     

       160
       160
        
             hostname = config.networking.hostName;

     

       161
       161
        
             system = if config.nixpkgs.system == "" then builtins.currentSystem else config.nixpkgs.system;

     

       162
       162
        
       

     
···

       173
       173
        
               '';

     

       174
       174
        
             }}");

     

       175
       175
        
           };

     

       176
       176
       -
           

     

       177
       177
       -
           dysnomia.containers = lib.recursiveUpdate ({

     

       176
       176
       +
       

     

       177
       177
       +
           services.dysnomia.containers = lib.recursiveUpdate ({

     

       178
       178
        
             process = {};

     

       179
       179
        
             wrapper = {};

     

       180
       180
        
           }

+5 -5

nixos/modules/services/networking/tcpcrypt.nix

···

       44
       44
        
             path = [ pkgs.iptables pkgs.tcpcrypt pkgs.procps ];

     

       45
       45
        
       

     

       46
       46
        
             preStart = ''

     

       47
       47
       -
               mkdir -p /var/run/tcpcryptd

     

       48
       48
       -
               chown tcpcryptd /var/run/tcpcryptd

     

       49
       49
       -
               sysctl -n net.ipv4.tcp_ecn >/run/pre-tcpcrypt-ecn-state

     

       47
       47
       +
               mkdir -p /run/tcpcryptd

     

       48
       48
       +
               chown tcpcryptd /run/tcpcryptd

     

       49
       49
       +
               sysctl -n net.ipv4.tcp_ecn > /run/tcpcryptd/pre-tcpcrypt-ecn-state

     

       50
       50
        
               sysctl -w net.ipv4.tcp_ecn=0

     

       51
       51
        
       

     

       52
       52
        
               iptables -t raw -N nixos-tcpcrypt

     
···

       61
       61
        
             script = "tcpcryptd -x 0x10";

     

       62
       62
        
       

     

       63
       63
        
             postStop = ''

     

       64
       64
       -
               if [ -f /run/pre-tcpcrypt-ecn-state ]; then

     

       65
       65
       -
                 sysctl -w net.ipv4.tcp_ecn=$(cat /run/pre-tcpcrypt-ecn-state)

     

       64
       64
       +
               if [ -f /run/tcpcryptd/pre-tcpcrypt-ecn-state ]; then

     

       65
       65
       +
                 sysctl -w net.ipv4.tcp_ecn=$(cat /run/tcpcryptd/pre-tcpcrypt-ecn-state)

     

       66
       66
        
               fi

     

       67
       67
        
       

     

       68
       68
        
               iptables -t mangle -D POSTROUTING -j nixos-tcpcrypt || true

+1 -1

pkgs/applications/networking/browsers/firefox/wrapper.nix

···

       30
       30
        
           }:

     

       31
       31
        
       

     

       32
       32
        
           let

     

       33
       33
       -
             cfg = stdenv.lib.attrByPath [ browserName ] {} config;

     

       33
       33
       +
             cfg = config.${browserName} or {};

     

       34
       34
        
             enableAdobeFlash = cfg.enableAdobeFlash or false;

     

       35
       35
        
             ffmpegSupport = browser.ffmpegSupport or false;

     

       36
       36
        
             gssSupport = browser.gssSupport or false;