Merge branch 'master' into staging-next

doc/languages-frameworks/agda.section.md

···
 ## How to use Agda
 
 Agda can be installed from `agda`:
-```
+```ShellSession
 $ nix-env -iA agda
 ```
 
···
 
 For example, suppose we wanted a version of Agda which has access to the standard library. This can be obtained with the expressions:
 
-```
+```nix
 agda.withPackages [ agdaPackages.standard-library ]
 ```
 
 or
 
-```
+```nix
 agda.withPackages (p: [ p.standard-library ])
 ```
 
···
 Agda will not by default use these libraries. To tell Agda to use the library we have some options:
 
 * Call `agda` with the library flag:
-```
+```ShellSession
 $ agda -l standard-library -i . MyFile.agda
 ```
 * Write a `my-library.agda-lib` file for the project you are working on which may look like:
···
 Agda modules can be compiled with the `--compile` flag. A version of `ghc` with `ieee754` is made available to the Agda program via the `--with-compiler` flag.
 This can be overridden by a different version of `ghc` as follows:
 
-```
+```nix
 agda.withPackages {
   pkgs = [ ... ];
   ghc = haskell.compiler.ghcHEAD;
···
 ## Adding Agda packages to Nixpkgs
 
 To add an Agda package to `nixpkgs`, the derivation should be written to `pkgs/development/libraries/agda/${library-name}/` and an entry should be added to `pkgs/top-level/agda-packages.nix`. Here it is called in a scope with access to all other Agda libraries, so the top line of the `default.nix` can look like:
-```
+```nix
 { mkDerivation, standard-library, fetchFromGitHub }:
 ```
 and `mkDerivation` should be called instead of `agdaPackages.mkDerivation`. Here is an example skeleton derivation for iowa-stdlib:
 
-```
+```nix
 mkDerivation {
   version = "1.5.0";
   pname = "iowa-stdlib";

doc/languages-frameworks/dotnet.section.md

···
 
 For local development, it's recommended to use nix-shell to create a dotnet environment:
 
-```
+```nix
 # shell.nix
 with import <nixpkgs> {};
 
···
 
 It's very likely that more than one sdk will be needed on a given project. Dotnet provides several different frameworks (E.g dotnetcore, aspnetcore, etc.) as well as many versions for a given framework. Normally, dotnet is able to fetch a framework and install it relative to the executable. However, this would mean writing to the nix store in nixpkgs, which is read-only. To support the many-sdk use case, one can compose an environment using `dotnetCorePackages.combinePackages`:
 
-```
+```nix
 with import <nixpkgs> {};
 
 mkShell {
···
 
 This will produce a dotnet installation that has the dotnet 3.1, 3.0, and 2.1 sdk. The first sdk listed will have it's cli utility present in the resulting environment. Example info output:
 
-```
+```ShellSesssion
 $ dotnet --info
 .NET Core SDK (reflecting any global.json):
  Version:   3.1.101

doc/languages-frameworks/idris.section.md

···
 
 The easiest way to get a working idris version is to install the `idris` attribute:
 
-```
+```ShellSesssion
 $ # On NixOS
 $ nix-env -i nixos.idris
 $ # On non-NixOS
···
 
 And then:
 
-```
+```ShellSesssion
 $ # On NixOS
 $ nix-env -iA nixos.myIdris
 $ # On non-NixOS
···
 ```
 
 To see all available Idris packages:
-```
+```ShellSesssion
 $ # On NixOS
 $ nix-env -qaPA nixos.idrisPackages
 $ # On non-NixOS
···
 ```
 
 Similarly, entering a `nix-shell`:
-```
+```ShellSesssion
 $ nix-shell -p 'idrisPackages.with-packages (with idrisPackages; [ contrib pruviloj ])'
 ```
 
···
 
 To have access to these libraries in idris, call it with an argument `-p <library name>` for each library:
 
-```
+```ShellSesssion
 $ nix-shell -p 'idrisPackages.with-packages (with idrisPackages; [ contrib pruviloj ])'
 [nix-shell:~]$ idris -p contrib -p pruviloj
 ```
 
 A listing of all available packages the Idris binary has access to is available via `--listlibs`:
 
-```
+```ShellSesssion
 $ idris --listlibs
 00prelude-idx.ibc
 pruviloj
···
 
 Assuming this file is saved as `yaml.nix`, it's buildable using
 
-```
+```ShellSesssion
 $ nix-build -E '(import <nixpkgs> {}).idrisPackages.callPackage ./yaml.nix {}'
 ```
 
···
 
 in another file (say `default.nix`) to be able to build it with
 
-```
+```ShellSesssion
 $ nix-build -A yaml
 ```
 
···
 
 For example you could set
 
-```
+```nix
 build-idris-package {
   idrisBuildOptions = [ "--log" "1" "--verbose" ]
 

doc/languages-frameworks/python.section.md

···
 By default `nix-shell` will start a `bash` session with this interpreter in our
 `PATH`, so if we then run:
 
-```
+```Python console
 [nix-shell:~/src/nixpkgs]$ python3
 Python 3.8.1 (default, Dec 18 2019, 19:06:26)
 [GCC 9.2.0] on linux
···
 Note that no other modules are in scope, even if they were imperatively
 installed into our user environment as a dependency of a Python application:
 
-```
+```Python console
 >>> import requests
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
···
 Executing this script requires a `python3` that has `numpy`. Using what we learned
 in the previous section, we could startup a shell and just run it like so:
 
-```
-nix-shell -p 'python38.withPackages(ps: with ps; [ numpy ])' --run 'python3 foo.py'
+```ShellSesssion
+$ nix-shell -p 'python38.withPackages(ps: with ps; [ numpy ])' --run 'python3 foo.py'
 The dot product of [1 2] and [3 4] is: 11
 ```
 

doc/languages-frameworks/qt.section.md

···
 ### Example adding a Qt library {#qt-library-all-packages-nix}
 
 The following represents the contents of `qt5-packages.nix`.
-```
+```nix
 {
   # ...
 
···
 ### Example adding a Qt application {#qt-application-all-packages-nix}
 
 The following represents the contents of `qt5-packages.nix`.
-```
+```nix
 {
   # ...
 
···
 ```
 
 The following represents the contents of `all-packages.nix`.
-```
+```nix
 {
   # ...
 

doc/languages-frameworks/rust.section.md

···
 
 To install the rust compiler and cargo put
 
-```
-rustc
-cargo
+```nix
+environment.systemPackages = [
+  rustc
+  cargo
+];
 ```
 
-into the `environment.systemPackages` or bring them into
-scope with `nix-shell -p rustc cargo`.
+into your `configuration.nix` or bring them into scope with `nix-shell -p rustc cargo`.
 
 For other versions such as daily builds (beta and nightly),
 use either `rustup` from nixpkgs (which will manage the rust installation in your home directory),
···
 
 Rust applications are packaged by using the `buildRustPackage` helper from `rustPlatform`:
 
-```
+```nix
 { lib, rustPlatform }:
 
 rustPlatform.buildRustPackage rec {
···
 such as the one in the example above. `cargoHash` should instead be
 used for [SRI](https://www.w3.org/TR/SRI/) hashes. For example:
 
-```
+```nix
   cargoHash = "sha256-l1vL2ZdtDRxSGvP0X/l3nMw8+6WF67KPutJEzUROjg8=";
 ```
 
···
 then be taken from the failed build. A fake hash can be used for
 `cargoSha256` as follows:
 
-```
+```nix
   cargoSha256 = lib.fakeSha256;
 ```
 
 For `cargoHash` you can use:
 
-```
+```nix
   cargoHash = lib.fakeHash;
 ```
 
···
 source code in a reproducible way. If it is missing or out-of-date one can use
 the `cargoPatches` attribute to update or add it.
 
-```
+```nix
 rustPlatform.buildRustPackage rec {
   (...)
   cargoPatches = [
···
 
 Now, the file produced by the call to `carnix`, called `hello.nix`, looks like:
 
-```
+```nix
 # Generated by carnix 0.6.5: carnix -o hello.nix --src ./. Cargo.lock --standalone
 { stdenv, buildRustCrate, fetchgit }:
 let kernel = stdenv.buildPlatform.parsed.kernel.name;
···
 `Cargo.lock`. Then, `carnix` needs to be run again, and produces the
 following nix file:
 
-```
+```nix
 # Generated by carnix 0.6.5: carnix -o hello.nix --src ./. Cargo.lock --standalone
 { stdenv, buildRustCrate, fetchgit }:
 let kernel = stdenv.buildPlatform.parsed.kernel.name;
···
 Starting from that file, one can add more overrides, to add features
 or build inputs by overriding the hello crate in a seperate file.
 
-```
+```nix
 with import <nixpkgs> {};
 ((import ./hello.nix).hello {}).override {
   crateOverrides = defaultCrateOverrides // {
···
 the override above can be read, as in the following example, which
 patches the derivation:
 
-```
+```nix
 with import <nixpkgs> {};
 ((import ./hello.nix).hello {}).override {
   crateOverrides = defaultCrateOverrides // {
···
 `libc` in the example above, where `libc` is a dependency of the main
 crate, we could do:
 
-```
+```nix
 with import <nixpkgs> {};
 ((import hello.nix).hello {}).override {
   crateOverrides = defaultCrateOverrides // {
···
 
 - The version of rustc used to compile the crate:
 
-  ```
+  ```nix
   (hello {}).override { rust = pkgs.rust; };
   ```
 
 - Whether to build in release mode or debug mode (release mode by
   default):
 
-  ```
+  ```nix
   (hello {}).override { release = false; };
   ```
 
 - Whether to print the commands sent to rustc when building
   (equivalent to `--verbose` in cargo:
 
-  ```
+  ```nix
   (hello {}).override { verbose = false; };
   ```
 
 - Extra arguments to be passed to `rustc`:
 
-  ```
+  ```nix
   (hello {}).override { extraRustcOpts = "-Z debuginfo=2"; };
   ```
 
···
   `postInstall`. As an example, here is how to create a new module
   before running the build script:
 
-  ```
+  ```nix
   (hello {}).override {
     preConfigure = ''
        echo "pub const PATH=\"${hi.out}\";" >> src/path.rs"
···
 compile `diesel_cli` only with the `postgres` feature, and no default
 features, we would write:
 
-```
+```nix
 (callPackage ./diesel.nix {}).diesel {
   default = false;
   postgres = true;
···
 
 A typical `shell.nix` might look like:
 
-```
+```nix
 with import <nixpkgs> {};
 
 stdenv.mkDerivation {
···
 ```
 
 You should now be able to run the following:
-```
+```ShellSesssion
 $ nix-shell --pure
 $ cargo build
 $ cargo test
···
 To control your rust version (i.e. use nightly) from within `shell.nix` (or
 other nix expressions) you can use the following `shell.nix`
 
-```
+```nix
 # Latest Nightly
 with import <nixpkgs> {};
 let src = fetchFromGitHub {
···
 ```
 
 Now run:
-```
+```ShellSession
 $ rustc --version
 rustc 1.26.0-nightly (188e693b3 2018-03-26)
 ```
···
 
 Add the following to your `configuration.nix`, `home-configuration.nix`, `shell.nix`, or similar:
 
-```
+```nix
 { pkgs ? import <nixpkgs> {
     overlays = [
       (import (builtins.fetchTarball https://github.com/mozilla/nixpkgs-mozilla/archive/master.tar.gz))

doc/languages-frameworks/vim.section.md

···
 
 First create a vim-scripts file having one plugin name per line. Example:
 
-```
+```vim
 "tlib"
 {'name': 'vim-addon-sql'}
 {'filetype_regex': '\%(vim)$', 'names': ['reload', 'vim-dev-plugin']}
···
 You should get a Vim buffer with the nix derivations (output1) and vam.pluginDictionaries (output2).
 You can add your Vim to your system's configuration file like this and start it by "vim-my":
 
-```
+```nix
 my-vim =
   let plugins = let inherit (vimUtils) buildVimPluginFrom2Nix; in {
     copy paste output1 here
···
 
 Sample output1:
 
-```
+```nix
 "reload" = buildVimPluginFrom2Nix { # created by nix#NixDerivation
   name = "reload";
   src = fetchgit {
···
 
 Some plugins require overrides in order to function properly. Overrides are placed in [overrides.nix](/pkgs/misc/vim-plugins/overrides.nix). Overrides are most often required when a plugin requires some dependencies, or extra steps are required during the build process. For example `deoplete-fish` requires both `deoplete-nvim` and `vim-fish`, and so the following override was added:
 
-```
+```nix
 deoplete-fish = super.deoplete-fish.overrideAttrs(old: {
   dependencies = with super; [ deoplete-nvim vim-fish ];
 });

lib/trivial.nix

···
     seq deepSeq genericClosure;
 
 
-  ## nixpks version strings
+  ## nixpkgs version strings
 
   /* Returns the current full nixpkgs version number. */
   version = release + versionSuffix;

maintainers/maintainer-list.nix

···
     githubId = 1078530;
     name = "Alexandre Peyroux";
   };
+  applePrincess = {
+    email = "[e-mail]";
+    github = "applePrincess";
+    githubId = 17154507;
+    name = "Lein Matsumaru";
+    keys = [{
+      longkeyid = "rsa4096/0xAAA50652F0479205";
+      fingerprint = "BF8B F725 DA30 E53E 7F11  4ED8 AAA5 0652 F047 9205";
+   }];
+  };
   ar1a = {
     email = "[e-mail]";
     github = "ar1a";
···
     github = "boj";
     githubId = 50839;
     name = "Brian Jones";
+  };
+  bootstrap-prime = {
+    email = "[e-mail]";
+    github = "bootstrap-prime";
+    githubId = 68566724;
+    name = "bootstrap-prime";
   };
   commandodev = {
     email = "[e-mail]";
···
     githubId = 10913120;
     name = "Dje4321";
   };
+  djwf = {
+    email = "[e-mail]";
+    github = "djwf";
+    githubId = 73162;
+    name = "David J. Weller-Fahy";
+  };
   dkabot = {
     email = "[e-mail]";
     github = "dkabot";
···
     githubId = 1753498;
     name = "Dejan Lukan";
   };
+  electrified = {
+    email = "[e-mail]";
+    github = "electrified";
+    githubId = 103082;
+    name = "Ed Brindley";
+  };
   elliottvillars = {
     email = "[e-mail]";
     github = "elliottvillars";
···
     github = "groodt";
     githubId = 343415;
     name = "Greg Roodt";
+  };
+  gschwartz = {
+    email = "[e-mail]";
+    github = "GregorySchwartz";
+    githubId = 2490088;
+    name = "Gregory Schwartz";
   };
   gtrunsec = {
     email = "[e-mail]";
···
     github = "KibaFox";
     githubId = 16481032;
     name = "Kiba Fox";
+  };
+  kidd = {
+    email = "[e-mail]";
+    github = "kidd";
+    githubId = 25607;
+    name = "Raimon Grau";
   };
   kierdavis = {
     email = "[e-mail]";
···
     github = "seb314";
     githubId = 19472270;
     name = "Sebastian";
+  };
+  sebbadk = {
+    email = "[e-mail]";
+    github = "SEbbaDK";
+    githubId = 1567527;
+    name = "Sebastian Hyberts";
   };
   sellout = {
     email = "[e-mail]";

nixos/modules/config/users-groups.nix

···
         # password or an SSH authorized key. Privileged accounts are
         # root and users in the wheel group.
         assertion = !cfg.mutableUsers ->
-          any id ((mapAttrsToList (name: cfg:
-            (name == "root"
+          any id ((mapAttrsToList (_: cfg:
+            (cfg.name == "root"
              || cfg.group == "wheel"
              || elem "wheel" cfg.extraGroups)
             &&
···
         assertion = (user.hashedPassword != null)
                     -> (builtins.match ".*:.*" user.hashedPassword == null);
         message = ''
-          The password hash of user "${name}" contains a ":" character.
+          The password hash of user "${user.name}" contains a ":" character.
           This is invalid and would break the login system because the fields
           of /etc/shadow (file where hashes are stored) are colon-separated.
-          Please check the value of option `users.users."${name}".hashedPassword`.'';
+          Please check the value of option `users.users."${user.name}".hashedPassword`.'';
       }
     );
 
     warnings =
       builtins.filter (x: x != null) (
-        flip mapAttrsToList cfg.users (name: user:
+        flip mapAttrsToList cfg.users (_: user:
         # This regex matches a subset of the Modular Crypto Format (MCF)[1]
         # informal standard. Since this depends largely on the OS or the
         # specific implementation of crypt(3) we only support the (sane)
···
             && user.hashedPassword != ""  # login without password
             && builtins.match mcf user.hashedPassword == null)
         then ''
-          The password hash of user "${name}" may be invalid. You must set a
+          The password hash of user "${user.name}" may be invalid. You must set a
           valid hash or the user will be locked out of their account. Please
-          check the value of option `users.users."${name}".hashedPassword`.''
+          check the value of option `users.users."${user.name}".hashedPassword`.''
         else null
       ));
 

nixos/modules/module-list.nix

···
   ./programs/dconf.nix
   ./programs/digitalbitbox/default.nix
   ./programs/dmrconfig.nix
+  ./programs/droidcam.nix
   ./programs/environment.nix
   ./programs/evince.nix
   ./programs/file-roller.nix
···
   ./services/audio/alsa.nix
   ./services/audio/jack.nix
   ./services/audio/icecast.nix
+  ./services/audio/jmusicbot.nix
   ./services/audio/liquidsoap.nix
   ./services/audio/mpd.nix
   ./services/audio/mpdscribble.nix

nixos/modules/programs/droidcam.nix

···
+{ lib, pkgs, config, ... }:
+
+with lib;
+
+{
+  options.programs.droidcam = {
+    enable = mkEnableOption "DroidCam client";
+  };
+
+  config = lib.mkIf config.programs.droidcam.enable {
+    environment.systemPackages = [ pkgs.droidcam ];
+
+    boot.extraModulePackages = [ config.boot.kernelPackages.v4l2loopback ];
+    boot.kernelModules = [ "v4l2loopback" "snd-aloop" ];
+  };
+}

nixos/modules/programs/mininet.nix

···
   cfg  = config.programs.mininet;
 
   generatedPath = with pkgs; makeSearchPath "bin"  [
-    iperf ethtool iproute socat
+    iperf ethtool iproute2 socat
   ];
 
   pyEnv = pkgs.python.withPackages(ps: [ ps.mininet-python ]);

nixos/modules/services/audio/jmusicbot.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+let
+  cfg = config.services.jmusicbot;
+in
+{
+  options = {
+    services.jmusicbot = {
+      enable = mkEnableOption "jmusicbot, a Discord music bot that's easy to set up and run yourself";
+
+      stateDir = mkOption {
+        type = types.path;
+        description = ''
+          The directory where config.txt and serversettings.json is saved.
+          If left as the default value this directory will automatically be created before JMusicBot starts, otherwise the sysadmin is responsible for ensuring the directory exists with appropriate ownership and permissions.
+          Untouched by the value of this option config.txt needs to be placed manually into this directory.
+        '';
+        default = "/var/lib/jmusicbot/";
+      };
+    };
+  };
+
+  config = mkIf cfg.enable {
+    systemd.services.jmusicbot = {
+      wantedBy = [ "multi-user.target" ];
+      after = [ "network-online.target" ];
+      description = "Discord music bot that's easy to set up and run yourself!";
+      serviceConfig = mkMerge [{
+        ExecStart = "${pkgs.jmusicbot}/bin/JMusicBot";
+        WorkingDirectory = cfg.stateDir;
+        Restart = "always";
+        RestartSec = 20;
+        DynamicUser = true;
+      }
+        (mkIf (cfg.stateDir == "/var/lib/jmusicbot") { StateDirectory = "jmusicbot"; })];
+    };
+  };
+
+  meta.maintainers = with maintainers; [ SuperSandro2000 ];
+}

nixos/modules/services/hardware/sane.nix

···
   };
 
   backends = [ pkg netConf ] ++ optional config.services.saned.enable sanedConf ++ config.hardware.sane.extraBackends;
-  saneConfig = pkgs.mkSaneConfig { paths = backends; };
+  saneConfig = pkgs.mkSaneConfig { paths = backends; inherit (config.hardware.sane) disabledDefaultBackends; };
 
   enabled = config.hardware.sane.enable || config.services.saned.enable;
 
···
         </para></note>
       '';
       example = literalExample "[ pkgs.hplipWithPlugin ]";
+    };
+
+    hardware.sane.disabledDefaultBackends = mkOption {
+      type = types.listOf types.str;
+      default = [];
+      example = [ "v4l" ];
+      description = ''
+        Names of backends which are enabled by default but should be disabled.
+        See <literal>$SANE_CONFIG_DIR/dll.conf</literal> for the list of possible names.
+      '';
     };
 
     hardware.sane.configDir = mkOption {

nixos/modules/services/logging/vector.nix

···
 with lib;
 let cfg = config.services.vector;
 
-in {
+in
+{
   options.services.vector = {
     enable = mkEnableOption "Vector";
 
···
       wantedBy = [ "multi-user.target" ];
       after = [ "network-online.target" ];
       requires = [ "network-online.target" ];
-      serviceConfig = let
-        format = pkgs.formats.toml { };
-        conf = format.generate "vector.toml" cfg.settings;
-        validateConfig = file:
-          pkgs.runCommand "validate-vector-conf" { } ''
-            ${pkgs.vector}/bin/vector validate --no-topology --no-environment "${file}"
-            ln -s "${file}" "$out"
-          '';
-      in {
-        ExecStart = "${pkgs.vector}/bin/vector --config ${validateConfig conf}";
-        User = "vector";
-        Group = "vector";
-        Restart = "no";
-        StateDirectory = "vector";
-        ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
-        AmbientCapabilities = "CAP_NET_BIND_SERVICE";
-        # This group is required for accessing journald.
-        SupplementaryGroups = mkIf cfg.journaldAccess "systemd-journal";
-      };
+      serviceConfig =
+        let
+          format = pkgs.formats.toml { };
+          conf = format.generate "vector.toml" cfg.settings;
+          validateConfig = file:
+            pkgs.runCommand "validate-vector-conf" { } ''
+              ${pkgs.vector}/bin/vector validate --no-environment "${file}"
+              ln -s "${file}" "$out"
+            '';
+        in
+        {
+          ExecStart = "${pkgs.vector}/bin/vector --config ${validateConfig conf}";
+          User = "vector";
+          Group = "vector";
+          Restart = "no";
+          StateDirectory = "vector";
+          ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
+          AmbientCapabilities = "CAP_NET_BIND_SERVICE";
+          # This group is required for accessing journald.
+          SupplementaryGroups = mkIf cfg.journaldAccess "systemd-journal";
+        };
     };
   };
 }

nixos/modules/services/misc/home-assistant.nix

···
   };
 
 in {
-  meta.maintainers = with maintainers; [ dotlambda ];
+  meta.maintainers = with maintainers; [ ];
 
   options.services.home-assistant = {
     enable = mkEnableOption "Home Assistant";

nixos/modules/services/misc/mame.nix

···
       description = "MAME TUN/TAP Ethernet interface";
       after = [ "network.target" ];
       wantedBy = [ "multi-user.target" ];
-      path = [ pkgs.iproute ];
+      path = [ pkgs.iproute2 ];
       serviceConfig = {
         Type = "oneshot";
         RemainAfterExit = true;

nixos/modules/services/misc/packagekit.nix

···
 { config, lib, pkgs, ... }:
 
-with lib;
-
 let
-
   cfg = config.services.packagekit;
 
-  packagekitConf = ''
-    [Daemon]
-    DefaultBackend=${cfg.backend}
-    KeepCache=false
-  '';
+  inherit (lib)
+    mkEnableOption mkOption mkIf mkRemovedOptionModule types
+    listToAttrs recursiveUpdate;
 
-  vendorConf = ''
-    [PackagesNotFound]
-    DefaultUrl=https://github.com/NixOS/nixpkgs
-    CodecUrl=https://github.com/NixOS/nixpkgs
-    HardwareUrl=https://github.com/NixOS/nixpkgs
-    FontUrl=https://github.com/NixOS/nixpkgs
-    MimeUrl=https://github.com/NixOS/nixpkgs
-  '';
+  iniFmt = pkgs.formats.ini { };
 
-in
+  confFiles = [
+    (iniFmt.generate "PackageKit.conf" (recursiveUpdate
+      {
+        Daemon = {
+          DefaultBackend = "test_nop";
+          KeepCache = false;
+        };
+      }
+      cfg.settings))
 
+    (iniFmt.generate "Vendor.conf" (recursiveUpdate
+      {
+        PackagesNotFound = rec {
+          DefaultUrl = "https://github.com/NixOS/nixpkgs";
+          CodecUrl = DefaultUrl;
+          HardwareUrl = DefaultUrl;
+          FontUrl = DefaultUrl;
+          MimeUrl = DefaultUrl;
+        };
+      }
+      cfg.vendorSettings))
+  ];
+
+in
 {
+  imports = [
+    (mkRemovedOptionModule [ "services" "packagekit" "backend" ] "The only backend that doesn't blow up is `test_nop`.")
+  ];
 
-  options = {
+  options.services.packagekit = {
+    enable = mkEnableOption ''
+      PackageKit provides a cross-platform D-Bus abstraction layer for
+      installing software. Software utilizing PackageKit can install
+      software regardless of the package manager.
+    '';
 
-    services.packagekit = {
-      enable = mkEnableOption
-        ''
-          PackageKit provides a cross-platform D-Bus abstraction layer for
-          installing software. Software utilizing PackageKit can install
-          software regardless of the package manager.
-        '';
+    settings = mkOption {
+      type = iniFmt.type;
+      default = { };
+      description = "Additional settings passed straight through to PackageKit.conf";
+    };
 
-      # TODO: integrate with PolicyKit if the nix backend matures to the point
-      # where it will require elevated permissions
-      backend = mkOption {
-        type = types.enum [ "test_nop" ];
-        default = "test_nop";
-        description = ''
-          PackageKit supports multiple different backends and <literal>auto</literal> which
-          should do the right thing.
-          </para>
-          <para>
-          On NixOS however, we do not have a backend compatible with nix 2.0
-          (refer to <link xlink:href="https://github.com/NixOS/nix/issues/233">this issue</link> so we have to force
-          it to <literal>test_nop</literal> for now.
-        '';
-      };
+    vendorSettings = mkOption {
+      type = iniFmt.type;
+      default = { };
+      description = "Additional settings passed straight through to Vendor.conf";
     };
   };
 
···
 
     systemd.packages = with pkgs; [ packagekit ];
 
-    environment.etc."PackageKit/PackageKit.conf".text = packagekitConf;
-    environment.etc."PackageKit/Vendor.conf".text = vendorConf;
+    environment.etc = listToAttrs (map
+      (e:
+        lib.nameValuePair "PackageKit/${e.name}" { source = e; })
+      confFiles);
   };
 }

nixos/modules/services/monitoring/datadog-agent.nix

···
     };
   };
   config = mkIf cfg.enable {
-    environment.systemPackages = [ datadogPkg pkgs.sysstat pkgs.procps pkgs.iproute ];
+    environment.systemPackages = [ datadogPkg pkgs.sysstat pkgs.procps pkgs.iproute2 ];
 
     users.users.datadog = {
       description = "Datadog Agent User";
···
 
     systemd.services = let
       makeService = attrs: recursiveUpdate {
-        path = [ datadogPkg pkgs.python pkgs.sysstat pkgs.procps pkgs.iproute ];
+        path = [ datadogPkg pkgs.python pkgs.sysstat pkgs.procps pkgs.iproute2 ];
         wantedBy = [ "multi-user.target" ];
         serviceConfig = {
           User = "datadog";

nixos/modules/services/monitoring/prometheus/exporters.nix

···
     "artifactory"
     "bind"
     "bird"
+    "bitcoin"
     "blackbox"
     "collectd"
     "dnsmasq"

nixos/modules/services/monitoring/prometheus/exporters/bitcoin.nix

···
+{ config, lib, pkgs, options }:
+
+with lib;
+
+let
+  cfg = config.services.prometheus.exporters.bitcoin;
+in
+{
+  port = 9332;
+  extraOpts = {
+    rpcUser = mkOption {
+      type = types.str;
+      default = "bitcoinrpc";
+      description = ''
+        RPC user name.
+      '';
+    };
+
+    rpcPasswordFile = mkOption {
+      type = types.path;
+      description = ''
+        File containing RPC password.
+      '';
+    };
+
+    rpcScheme = mkOption {
+      type = types.enum [ "http" "https" ];
+      default = "http";
+      description = ''
+        Whether to connect to bitcoind over http or https.
+      '';
+    };
+
+    rpcHost = mkOption {
+      type = types.str;
+      default = "localhost";
+      description = ''
+        RPC host.
+      '';
+    };
+
+    rpcPort = mkOption {
+      type = types.port;
+      default = 8332;
+      description = ''
+        RPC port number.
+      '';
+    };
+
+    refreshSeconds = mkOption {
+      type = types.ints.unsigned;
+      default = 300;
+      description = ''
+        How often to ask bitcoind for metrics.
+      '';
+    };
+
+    extraEnv = mkOption {
+      type = types.attrsOf types.str;
+      default = {};
+      description = ''
+        Extra environment variables for the exporter.
+      '';
+    };
+  };
+  serviceOpts = {
+    script = ''
+      export BITCOIN_RPC_PASSWORD=$(cat ${cfg.rpcPasswordFile})
+      exec ${pkgs.prometheus-bitcoin-exporter}/bin/bitcoind-monitor.py
+    '';
+
+    environment = {
+      BITCOIN_RPC_USER = cfg.rpcUser;
+      BITCOIN_RPC_SCHEME = cfg.rpcScheme;
+      BITCOIN_RPC_HOST = cfg.rpcHost;
+      BITCOIN_RPC_PORT = toString cfg.rpcPort;
+      METRICS_ADDR = cfg.listenAddress;
+      METRICS_PORT = toString cfg.port;
+      REFRESH_SECONDS = toString cfg.refreshSeconds;
+    } // cfg.extraEnv;
+  };
+}

nixos/modules/services/monitoring/scollector.nix

···
       description = "scollector metrics collector (part of Bosun)";
       wantedBy = [ "multi-user.target" ];
 
-      path = [ pkgs.coreutils pkgs.iproute ];
+      path = [ pkgs.coreutils pkgs.iproute2 ];
 
       serviceConfig = {
         User = cfg.user;

nixos/modules/services/networking/consul.nix

···
           ExecStop = "${cfg.package}/bin/consul leave";
         });
 
-        path = with pkgs; [ iproute gnugrep gawk consul ];
+        path = with pkgs; [ iproute2 gnugrep gawk consul ];
         preStart = ''
           mkdir -m 0700 -p ${dataDir}
           chown -R consul ${dataDir}

nixos/modules/services/networking/ircd-hybrid/default.nix

···
     name = "ircd-hybrid-service";
     scripts = [ "=>/bin" ./control.in ];
     substFiles = [ "=>/conf" ./ircd.conf ];
-    inherit (pkgs) ircdHybrid coreutils su iproute gnugrep procps;
+    inherit (pkgs) ircdHybrid coreutils su iproute2 gnugrep procps;
 
     ipv6Enabled = boolToString config.networking.enableIPv6;
 

nixos/modules/services/networking/libreswan.nix

···
 
   config = mkIf cfg.enable {
 
-    environment.systemPackages = [ pkgs.libreswan pkgs.iproute ];
+    environment.systemPackages = [ pkgs.libreswan pkgs.iproute2 ];
 
     systemd.services.ipsec = {
       description = "Internet Key Exchange (IKE) Protocol Daemon for IPsec";

nixos/modules/services/networking/networkmanager.nix

···
       restartTriggers = [ configFile overrideNameserversScript ];
 
       # useful binaries for user-specified hooks
-      path = [ pkgs.iproute pkgs.util-linux pkgs.coreutils ];
+      path = [ pkgs.iproute2 pkgs.util-linux pkgs.coreutils ];
       aliases = [ "dbus-org.freedesktop.nm-dispatcher.service" ];
     };
 

nixos/modules/services/networking/openvpn.nix

···
       wantedBy = optional cfg.autoStart "multi-user.target";
       after = [ "network.target" ];
 
-      path = [ pkgs.iptables pkgs.iproute pkgs.nettools ];
+      path = [ pkgs.iptables pkgs.iproute2 pkgs.nettools ];
 
       serviceConfig.ExecStart = "@${openvpn}/sbin/openvpn openvpn --suppress-timestamps --config ${configFile}";
       serviceConfig.Restart = "always";

nixos/modules/services/networking/sslh.nix

···
           { table = "mangle"; command = "OUTPUT ! -o lo -p tcp -m connmark --mark 0x02/0x0f -j CONNMARK --restore-mark --mask 0x0f"; }
         ];
       in {
-        path = [ pkgs.iptables pkgs.iproute pkgs.procps ];
+        path = [ pkgs.iptables pkgs.iproute2 pkgs.procps ];
 
         preStart = ''
           # Cleanup old iptables entries which might be still there

nixos/modules/services/networking/strongswan-swanctl/module.nix

···
       description = "strongSwan IPsec IKEv1/IKEv2 daemon using swanctl";
       wantedBy = [ "multi-user.target" ];
       after    = [ "network-online.target" ];
-      path     = with pkgs; [ kmod iproute iptables util-linux ];
+      path     = with pkgs; [ kmod iproute2 iptables util-linux ];
       environment = {
         STRONGSWAN_CONF = pkgs.writeTextFile {
           name = "strongswan.conf";

nixos/modules/services/networking/strongswan.nix

···
     systemd.services.strongswan = {
       description = "strongSwan IPSec Service";
       wantedBy = [ "multi-user.target" ];
-      path = with pkgs; [ kmod iproute iptables util-linux ]; # XXX Linux
+      path = with pkgs; [ kmod iproute2 iptables util-linux ]; # XXX Linux
       after = [ "network-online.target" ];
       environment = {
         STRONGSWAN_CONF = strongswanConf { inherit setup connections ca secretsFile managePlugins enabledPlugins; };

nixos/modules/services/networking/wireguard.nix

···
 
       preSetup = mkOption {
         example = literalExample ''
-          ${pkgs.iproute}/bin/ip netns add foo
+          ${pkgs.iproute2}/bin/ip netns add foo
         '';
         default = "";
         type = with types; coercedTo (listOf str) (concatStringsSep "\n") lines;
···
         wantedBy = [ "multi-user.target" "wireguard-${interfaceName}.service" ];
         environment.DEVICE = interfaceName;
         environment.WG_ENDPOINT_RESOLUTION_RETRIES = "infinity";
-        path = with pkgs; [ iproute wireguard-tools ];
+        path = with pkgs; [ iproute2 wireguard-tools ];
 
         serviceConfig = {
           Type = "oneshot";
···
         after = [ "network.target" "network-online.target" ];
         wantedBy = [ "multi-user.target" ];
         environment.DEVICE = name;
-        path = with pkgs; [ kmod iproute wireguard-tools ];
+        path = with pkgs; [ kmod iproute2 wireguard-tools ];
 
         serviceConfig = {
           Type = "oneshot";

nixos/modules/services/security/fail2ban.nix

···
       restartTriggers = [ fail2banConf jailConf pathsConf ];
       reloadIfChanged = true;
 
-      path = [ cfg.package cfg.packageFirewall pkgs.iproute ];
+      path = [ cfg.package cfg.packageFirewall pkgs.iproute2 ];
 
       unitConfig.Documentation = "man:fail2ban(1)";
 

nixos/modules/services/security/sshguard.nix

···
       partOf = optional config.networking.firewall.enable "firewall.service";
 
       path = with pkgs; if config.networking.nftables.enable
-        then [ nftables iproute systemd ]
-        else [ iptables ipset iproute systemd ];
+        then [ nftables iproute2 systemd ]
+        else [ iptables ipset iproute2 systemd ];
 
       # The sshguard ipsets must exist before we invoke
       # iptables. sshguard creates the ipsets after startup if

nixos/modules/system/boot/systemd.nix

···
     systemd.services.systemd-remount-fs.unitConfig.ConditionVirtualization = "!container";
     systemd.services.systemd-random-seed.unitConfig.ConditionVirtualization = "!container";
 
-    boot.kernel.sysctl = mkIf (!cfg.coredump.enable) {
-      "kernel.core_pattern" = "core";
-    };
+    boot.kernel.sysctl."kernel.core_pattern" = mkIf (!cfg.coredump.enable) "core";
+
+    # Increase numeric PID range (set directly instead of copying a one-line file from systemd)
+    # https://github.com/systemd/systemd/pull/12226
+    boot.kernel.sysctl."kernel.pid_max" = mkIf pkgs.stdenv.is64bit (lib.mkDefault 4194304);
+
     boot.kernelParams = optional (!cfg.enableUnifiedCgroupHierarchy) "systemd.unified_cgroup_hierarchy=0";
   };
 

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

···
 
             unitConfig.ConditionCapability = "CAP_NET_ADMIN";
 
-            path = [ pkgs.iproute ];
+            path = [ pkgs.iproute2 ];
 
             serviceConfig = {
               Type = "oneshot";
···
             # Restart rather than stop+start this unit to prevent the
             # network from dying during switch-to-configuration.
             stopIfChanged = false;
-            path = [ pkgs.iproute ];
+            path = [ pkgs.iproute2 ];
             script =
               ''
                 state="/run/nixos/network/addresses/${i.name}"
···
             wantedBy = [ "network-setup.service" (subsystemDevice i.name) ];
             partOf = [ "network-setup.service" ];
             before = [ "network-setup.service" ];
-            path = [ pkgs.iproute ];
+            path = [ pkgs.iproute2 ];
             serviceConfig = {
               Type = "oneshot";
               RemainAfterExit = true;
···
             before = [ "network-setup.service" ];
             serviceConfig.Type = "oneshot";
             serviceConfig.RemainAfterExit = true;
-            path = [ pkgs.iproute ];
+            path = [ pkgs.iproute2 ];
             script = ''
               # Remove Dead Interfaces
               echo "Removing old bridge ${n}..."
···
             wants = deps; # if one or more interface fails, the switch should continue to run
             serviceConfig.Type = "oneshot";
             serviceConfig.RemainAfterExit = true;
-            path = [ pkgs.iproute config.virtualisation.vswitch.package ];
+            path = [ pkgs.iproute2 config.virtualisation.vswitch.package ];
             preStart = ''
               echo "Resetting Open vSwitch ${n}..."
               ovs-vsctl --if-exists del-br ${n} -- add-br ${n} \
···
             before = [ "network-setup.service" ];
             serviceConfig.Type = "oneshot";
             serviceConfig.RemainAfterExit = true;
-            path = [ pkgs.iproute pkgs.gawk ];
+            path = [ pkgs.iproute2 pkgs.gawk ];
             script = ''
               echo "Destroying old bond ${n}..."
               ${destroyBond n}
···
             before = [ "network-setup.service" ];
             serviceConfig.Type = "oneshot";
             serviceConfig.RemainAfterExit = true;
-            path = [ pkgs.iproute ];
+            path = [ pkgs.iproute2 ];
             script = ''
               # Remove Dead Interfaces
               ip link show "${n}" >/dev/null 2>&1 && ip link delete "${n}"
···
             before = [ "network-setup.service" ];
             serviceConfig.Type = "oneshot";
             serviceConfig.RemainAfterExit = true;
-            path = [ pkgs.iproute ];
+            path = [ pkgs.iproute2 ];
             script = ''
               # Remove Dead Interfaces
               ip link show "${n}" >/dev/null 2>&1 && ip link delete "${n}"
···
             before = [ "network-setup.service" ];
             serviceConfig.Type = "oneshot";
             serviceConfig.RemainAfterExit = true;
-            path = [ pkgs.iproute ];
+            path = [ pkgs.iproute2 ];
             script = ''
               # Remove Dead Interfaces
               ip link show "${n}" >/dev/null 2>&1 && ip link delete "${n}"

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

···
             wants = deps; # if one or more interface fails, the switch should continue to run
             serviceConfig.Type = "oneshot";
             serviceConfig.RemainAfterExit = true;
-            path = [ pkgs.iproute config.virtualisation.vswitch.package ];
+            path = [ pkgs.iproute2 config.virtualisation.vswitch.package ];
             preStart = ''
               echo "Resetting Open vSwitch ${n}..."
               ovs-vsctl --if-exists del-br ${n} -- add-br ${n} \

nixos/modules/tasks/network-interfaces.nix

···
         wantedBy = [ "network.target" ];
         after = [ "network-pre.target" ];
         unitConfig.ConditionCapability = "CAP_NET_ADMIN";
-        path = [ pkgs.iproute ];
+        path = [ pkgs.iproute2 ];
         serviceConfig.Type = "oneshot";
         serviceConfig.RemainAfterExit = true;
         script = ''
···
               ${optionalString (current.type == "mesh" && current.meshID!=null) "${pkgs.iw}/bin/iw dev ${device} set meshid ${current.meshID}"}
               ${optionalString (current.type == "monitor" && current.flags!=null) "${pkgs.iw}/bin/iw dev ${device} set monitor ${current.flags}"}
               ${optionalString (current.type == "managed" && current.fourAddr!=null) "${pkgs.iw}/bin/iw dev ${device} set 4addr ${if current.fourAddr then "on" else "off"}"}
-              ${optionalString (current.mac != null) "${pkgs.iproute}/bin/ip link set dev ${device} address ${current.mac}"}
+              ${optionalString (current.mac != null) "${pkgs.iproute2}/bin/ip link set dev ${device} address ${current.mac}"}
             '';
 
             # Udev script to execute for a new WLAN interface. The script configures the new WLAN interface.
···
               ${optionalString (new.type == "mesh" && new.meshID!=null) "${pkgs.iw}/bin/iw dev ${device} set meshid ${new.meshID}"}
               ${optionalString (new.type == "monitor" && new.flags!=null) "${pkgs.iw}/bin/iw dev ${device} set monitor ${new.flags}"}
               ${optionalString (new.type == "managed" && new.fourAddr!=null) "${pkgs.iw}/bin/iw dev ${device} set 4addr ${if new.fourAddr then "on" else "off"}"}
-              ${optionalString (new.mac != null) "${pkgs.iproute}/bin/ip link set dev ${device} address ${new.mac}"}
+              ${optionalString (new.mac != null) "${pkgs.iproute2}/bin/ip link set dev ${device} address ${new.mac}"}
             '';
 
             # Udev attributes for systemd to name the device and to create a .device target.

nixos/modules/virtualisation/brightbox-image.nix

···
       wants = [ "network-online.target" ];
       after = [ "network-online.target" ];
 
-      path = [ pkgs.wget pkgs.iproute ];
+      path = [ pkgs.wget pkgs.iproute2 ];
 
       script =
         ''

nixos/modules/virtualisation/ec2-data.nix

···
         wantedBy = [ "multi-user.target" "sshd.service" ];
         before = [ "sshd.service" ];
 
-        path = [ pkgs.iproute ];
+        path = [ pkgs.iproute2 ];
 
         script =
           ''

nixos/modules/virtualisation/google-compute-config.nix

···
   systemd.services.google-network-daemon = {
     description = "Google Compute Engine Network Daemon";
     after = [ "network-online.target" "network.target" "google-instance-setup.service" ];
-    path = with pkgs; [ iproute ];
+    path = with pkgs; [ iproute2 ];
     serviceConfig = {
       ExecStart = "${gce}/bin/google_network_daemon";
       StandardOutput="journal+console";

nixos/modules/virtualisation/nixos-containers.nix

···
 
       unitConfig.RequiresMountsFor = "/var/lib/containers/%i";
 
-      path = [ pkgs.iproute ];
+      path = [ pkgs.iproute2 ];
 
       environment = {
         root = "/var/lib/containers/%i";

nixos/modules/virtualisation/xe-guest-utilities.nix

···
       wantedBy    = [ "multi-user.target" ];
       after = [ "xe-linux-distribution.service" ];
       requires = [ "proc-xen.mount" ];
-      path = [ pkgs.coreutils pkgs.iproute ];
+      path = [ pkgs.coreutils pkgs.iproute2 ];
       serviceConfig = {
         PIDFile = "/run/xe-daemon.pid";
         ExecStart = "${pkgs.xe-guest-utilities}/bin/xe-daemon -p /run/xe-daemon.pid";

nixos/modules/virtualisation/xen-dom0.nix

···
     # Xen provides udev rules.
     services.udev.packages = [ cfg.package ];
 
-    services.udev.path = [ pkgs.bridge-utils pkgs.iproute ];
+    services.udev.path = [ pkgs.bridge-utils pkgs.iproute2 ];
 
     systemd.services.xen-store = {
       description = "Xen Store Daemon";

nixos/tests/mysql/mariadb-galera-mariabackup.nix

···
 
 let
   mysqlenv-common      = pkgs.buildEnv { name = "mysql-path-env-common";      pathsToLink = [ "/bin" ]; paths = with pkgs; [ bash gawk gnutar inetutils which ]; };
-  mysqlenv-mariabackup = pkgs.buildEnv { name = "mysql-path-env-mariabackup"; pathsToLink = [ "/bin" ]; paths = with pkgs; [ gzip iproute netcat procps pv socat ]; };
+  mysqlenv-mariabackup = pkgs.buildEnv { name = "mysql-path-env-mariabackup"; pathsToLink = [ "/bin" ]; paths = with pkgs; [ gzip iproute2 netcat procps pv socat ]; };
 
 in {
   name = "mariadb-galera-mariabackup";

nixos/tests/prometheus-exporters.nix

···
       '';
     };
 
+    bitcoin = {
+      exporterConfig = {
+        enable = true;
+        rpcUser = "bitcoinrpc";
+        rpcPasswordFile = pkgs.writeText "password" "hunter2";
+      };
+      metricProvider = {
+        services.bitcoind.default.enable = true;
+        services.bitcoind.default.rpc.users.bitcoinrpc.passwordHMAC = "e8fe33f797e698ac258c16c8d7aadfbe$872bdb8f4d787367c26bcfd75e6c23c4f19d44a69f5d1ad329e5adf3f82710f7";
+      };
+      exporterTest = ''
+        wait_for_unit("prometheus-bitcoin-exporter.service")
+        wait_for_unit("bitcoind-default.service")
+        wait_for_open_port(9332)
+        succeed("curl -sSf http://localhost:9332/metrics | grep -q '^bitcoin_blocks '")
+      '';
+    };
+
     blackbox = {
       exporterConfig = {
         enable = true;

nixos/tests/wireguard/basic.nix

···
               inherit (wg-snakeoil-keys.peer0) publicKey;
             };
 
-            postSetup = let inherit (pkgs) iproute; in ''
-              ${iproute}/bin/ip route replace 10.23.42.1/32 dev wg0
-              ${iproute}/bin/ip route replace fc00::1/128 dev wg0
+            postSetup = let inherit (pkgs) iproute2; in ''
+              ${iproute2}/bin/ip route replace 10.23.42.1/32 dev wg0
+              ${iproute2}/bin/ip route replace fc00::1/128 dev wg0
             '';
           };
         };

pkgs/applications/audio/aj-snapshot/default.nix

···
-{ lib, stdenv, fetchurl, alsaLib, jack2Full, minixml, pkg-config }:
+{ lib, stdenv, fetchurl, alsaLib, jack2, minixml, pkg-config }:
 
 stdenv.mkDerivation rec {
   name =  packageName + "-" + version ;
···
   doCheck = false;
 
   nativeBuildInputs = [ pkg-config ];
-  buildInputs = [ alsaLib minixml jack2Full ];
+  buildInputs = [ alsaLib minixml jack2 ];
 
   meta = with lib; {
     description = "Tool for storing/restoring JACK and/or ALSA connections to/from cml files";

pkgs/applications/audio/faust/faust2jack.nix

···
 { faust
 , gtk2
-, jack2Full
+, jack2
 , alsaLib
 , opencv
 , libsndfile
···
 
   propagatedBuildInputs = [
     gtk2
-    jack2Full
+    jack2
     alsaLib
     opencv
     libsndfile

pkgs/applications/audio/faust/faust2jaqt.nix

···
 { faust
-, jack2Full
+, jack2
 , qt4
 , libsndfile
 , alsaLib
···
   ];
 
   propagatedBuildInputs = [
-    jack2Full
+    jack2
     qt4
     libsndfile
     alsaLib

pkgs/applications/audio/ft2-clone/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "ft2-clone";
-  version = "1.44_fix";
+  version = "1.46";
 
   src = fetchFromGitHub {
     owner = "8bitbubsy";
     repo = "ft2-clone";
     rev = "v${version}";
-    sha256 = "sha256-2HhG2cDzAvpSm655M1KQnjbfVvqqOZDz2ty7xnttskA=";
+    sha256 = "sha256-Y6FgIbNCsxnM/B2bEB7oufBjU1BnBYaz7/oysWttIOc=";
   };
 
   # Adapt the linux-only CMakeLists to darwin (more reliable than make-macos.sh)

pkgs/applications/audio/jmusicbot/default.nix

···
+{ stdenv, lib, fetchurl, makeWrapper, jre }:
+
+stdenv.mkDerivation rec {
+  pname = "JMusicBot";
+  version = "0.3.4";
+
+  src = fetchurl {
+    url = "https://github.com/jagrosh/MusicBot/releases/download/${version}/JMusicBot-${version}.jar";
+    sha256 = "sha256-++/ot9k74pkN9Wl7IEjiMIv/q5zklIEdU6uFjam0tmU=";
+  };
+
+  dontUnpack = true;
+
+  nativeBuildInputs = [ makeWrapper ];
+
+  installPhase = ''
+    mkdir -p $out/lib
+    cp $src $out/lib/JMusicBot
+
+    makeWrapper ${jre}/bin/java $out/bin/JMusicBot \
+      --add-flags "-Xmx1G -Dnogui=true -jar $out/lib/JMusicBot"
+  '';
+
+  meta = with lib; {
+    description = "Discord music bot that's easy to set up and run yourself";
+    homepage = "https://github.com/jagrosh/MusicBot";
+    license = licenses.asl20;
+    maintainers = with maintainers; [ SuperSandro2000 ];
+    platforms = platforms.all;
+  };
+}

pkgs/applications/audio/lsp-plugins/default.nix

···
 { lib, stdenv, fetchFromGitHub, pkg-config, makeWrapper
-, libsndfile, jack2Full
+, libsndfile, jack2
 , libGLU, libGL, lv2, cairo
 , ladspaH, php }:
 
···
   };
 
   nativeBuildInputs = [ pkg-config php makeWrapper ];
-  buildInputs = [ jack2Full libsndfile libGLU libGL lv2 cairo ladspaH ];
+  buildInputs = [ jack2 libsndfile libGLU libGL lv2 cairo ladspaH ];
 
   makeFlags = [
     "PREFIX=${placeholder "out"}"

pkgs/applications/audio/netease-music-tui/cargo-lock.patch

···
 diff --git a/Cargo.lock b/Cargo.lock
 new file mode 100644
-index 0000000..45720a8
+index 0000000..f191345
 --- /dev/null
 +++ b/Cargo.lock
-@@ -0,0 +1,2303 @@
+@@ -0,0 +1,2649 @@
 +# This file is automatically @generated by Cargo.
 +# It is not intended for manual editing.
 +[[package]]
 +name = "addr2line"
-+version = "0.14.0"
++version = "0.14.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "7c0929d69e78dd9bf5408269919fcbcaeb2e35e5d43e5815517cdc6a8e11a423"
++checksum = "a55f82cfe485775d02112886f4169bde0c5894d75e79ead7eafe7e40a25e45f7"
 +dependencies = [
 + "gimli",
 +]
 +
 +[[package]]
 +name = "adler"
-+version = "0.2.3"
++version = "1.0.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "ee2a4ec343196209d6594e19543ae87a39f96d5534d7174822a3ad825dd6ed7e"
++checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
 +
 +[[package]]
 +name = "aho-corasick"
···
 +]
 +
 +[[package]]
++name = "alsa"
++version = "0.5.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "75c4da790adcb2ce5e758c064b4f3ec17a30349f9961d3e5e6c9688b052a9e18"
++dependencies = [
++ "alsa-sys",
++ "bitflags",
++ "libc",
++ "nix",
++]
++
++[[package]]
 +name = "alsa-sys"
-+version = "0.1.2"
++version = "0.3.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "b0edcbbf9ef68f15ae1b620f722180b82a98b6f0628d30baa6b8d2a5abc87d58"
++checksum = "db8fee663d06c4e303404ef5f40488a53e062f89ba8bfed81f42325aafad1527"
 +dependencies = [
 + "libc",
 + "pkg-config",
···
 + "flate2",
 + "futures-core",
 + "memchr",
-+ "pin-project-lite 0.2.0",
++ "pin-project-lite 0.2.6",
 +]
 +
 +[[package]]
···
 +
 +[[package]]
 +name = "backtrace"
-+version = "0.3.55"
++version = "0.3.56"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "ef5140344c85b01f9bbb4d4b7288a8aa4b3287ccef913a14bcc78a1063623598"
++checksum = "9d117600f438b1707d4e4ae15d3595657288f8235a0eb593e80ecc98ab34e1bc"
 +dependencies = [
 + "addr2line",
 + "cfg-if 1.0.0",
···
 +
 +[[package]]
 +name = "bumpalo"
-+version = "3.4.0"
++version = "3.6.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "2e8c087f005730276d1096a652e92a8bacee2e2472bcc9715a74d2bec38b5820"
++checksum = "63396b8a4b9de3f4fdfb320ab6080762242f66a8ef174c49d8e19b674db4cdbe"
 +
 +[[package]]
 +name = "byteorder"
-+version = "1.3.4"
++version = "1.4.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
++checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 +
 +[[package]]
 +name = "bytes"
···
 +checksum = "0e4cec68f03f32e44924783795810fa50a7035d8c8ebe78580ad7e6c703fba38"
 +
 +[[package]]
++name = "bytes"
++version = "1.0.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "b700ce4376041dcd0a327fd0097c41095743c4c8af8887265942faf1100bd040"
++
++[[package]]
 +name = "cassowary"
 +version = "0.3.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
···
 +
 +[[package]]
 +name = "cc"
-+version = "1.0.66"
++version = "1.0.67"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "4c0496836a84f8d0495758516b8621a622beb77c0fed418570e50764093ced48"
++checksum = "e3c69b077ad434294d3ce9f1f6143a2a4b89a8a2d54ef813d85003a4fd1137fd"
++dependencies = [
++ "jobserver",
++]
++
++[[package]]
++name = "cesu8"
++version = "1.1.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
 +
 +[[package]]
 +name = "cexpr"
···
 + "libc",
 + "num-integer",
 + "num-traits 0.2.14",
-+ "time 0.1.44",
++ "time 0.1.43",
 + "winapi 0.3.9",
 +]
 +
 +[[package]]
 +name = "clang-sys"
-+version = "1.0.3"
++version = "1.1.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "0659001ab56b791be01d4b729c44376edc6718cf389a502e579b77b758f3296c"
++checksum = "f54d78e30b388d4815220c8dd03fea5656b6c6d32adb59e89061552a102f8da1"
 +dependencies = [
 + "glob",
 + "libc",
···
 +checksum = "4bfbf56724aa9eca8afa4fcfadeb479e722935bb2a0900c2d37e0cc477af0688"
 +
 +[[package]]
++name = "combine"
++version = "4.5.2"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "cc4369b5e4c0cddf64ad8981c0111e7df4f7078f4d6ba98fb31f2e17c4c57b7e"
++dependencies = [
++ "bytes 1.0.1",
++ "memchr",
++]
++
++[[package]]
 +name = "config"
 +version = "0.9.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
···
 + "lazy_static 1.4.0",
 + "nom 4.2.3",
 + "rust-ini",
-+ "serde 1.0.118",
++ "serde 1.0.125",
 + "serde-hjson",
 + "serde_json",
-+ "toml",
++ "toml 0.4.10",
 + "yaml-rust",
 +]
 +
 +[[package]]
 +name = "const_fn"
-+version = "0.4.4"
++version = "0.4.6"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "cd51eab21ab4fd6a3bf889e2d0958c0a6e3a61ad04260325e919e652a2a62826"
++checksum = "076a6803b0dacd6a88cfe64deba628b01533ff5ef265687e6938280c1afd0a28"
 +
 +[[package]]
 +name = "constant_time_eq"
···
 +
 +[[package]]
 +name = "cookie"
-+version = "0.14.3"
++version = "0.14.4"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "784ad0fbab4f3e9cef09f20e0aea6000ae08d2cb98ac4c0abc53df18803d702f"
++checksum = "03a5d7b21829bc7b4bf4754a978a241ae54ea55a40f92bb20216e54096f4b951"
 +dependencies = [
 + "percent-encoding",
-+ "time 0.2.23",
-+ "version_check 0.9.2",
++ "time 0.2.26",
++ "version_check 0.9.3",
 +]
 +
 +[[package]]
···
 + "idna",
 + "log",
 + "publicsuffix",
-+ "serde 1.0.118",
++ "serde 1.0.125",
 + "serde_json",
-+ "time 0.2.23",
++ "time 0.2.26",
 + "url",
 +]
 +
···
 +
 +[[package]]
 +name = "coreaudio-rs"
-+version = "0.9.1"
++version = "0.10.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "f229761965dad3e9b11081668a6ea00f1def7aa46062321b5ec245b834f6e491"
++checksum = "11894b20ebfe1ff903cbdc52259693389eea03b94918a2def2c30c3bf227ad88"
 +dependencies = [
 + "bitflags",
 + "coreaudio-sys",
···
 +
 +[[package]]
 +name = "cpal"
-+version = "0.10.0"
++version = "0.13.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "3ded070249be850b5b59e1e3a44a70b8ae395e0e5c65b487131d8909a8208120"
++checksum = "8351ddf2aaa3c583fa388029f8b3d26f3c7035a20911fdd5f2e2ed7ab57dad25"
 +dependencies = [
-+ "alsa-sys",
++ "alsa",
 + "core-foundation-sys 0.6.2",
 + "coreaudio-rs",
-+ "failure",
++ "jni",
++ "js-sys",
 + "lazy_static 1.4.0",
 + "libc",
-+ "num-traits 0.2.14",
++ "mach",
++ "ndk",
++ "ndk-glue",
++ "nix",
++ "oboe",
++ "parking_lot",
 + "stdweb 0.1.3",
++ "thiserror",
++ "web-sys",
 + "winapi 0.3.9",
 +]
 +
···
 +
 +[[package]]
 +name = "crossbeam-utils"
-+version = "0.8.1"
++version = "0.8.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "02d96d1e189ef58269ebe5b97953da3274d83a93af647c2ddd6f9dab28cedb8d"
++checksum = "e7e9d99fa91428effe99c5c6d4634cdeba32b8cf784fc428a2a687f61a952c49"
 +dependencies = [
 + "autocfg",
 + "cfg-if 1.0.0",
···
 +]
 +
 +[[package]]
++name = "darling"
++version = "0.10.2"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "0d706e75d87e35569db781a9b5e2416cff1236a47ed380831f959382ccd5f858"
++dependencies = [
++ "darling_core",
++ "darling_macro",
++]
++
++[[package]]
++name = "darling_core"
++version = "0.10.2"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "f0c960ae2da4de88a91b2d920c2a7233b400bc33cb28453a2987822d8392519b"
++dependencies = [
++ "fnv",
++ "ident_case",
++ "proc-macro2",
++ "quote",
++ "strsim",
++ "syn",
++]
++
++[[package]]
++name = "darling_macro"
++version = "0.10.2"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "d9b5a2f4ac4969822c62224815d069952656cadc7084fdca9751e6d959189b72"
++dependencies = [
++ "darling_core",
++ "quote",
++ "syn",
++]
++
++[[package]]
 +name = "dbus"
 +version = "0.7.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
···
 +]
 +
 +[[package]]
++name = "derivative"
++version = "2.2.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
++dependencies = [
++ "proc-macro2",
++ "quote",
++ "syn",
++]
++
++[[package]]
 +name = "dirs"
 +version = "2.0.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
···
 +
 +[[package]]
 +name = "dtoa"
-+version = "0.4.6"
++version = "0.4.8"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "134951f4028bdadb9b84baf4232681efbf277da25144b9b0ad65df75946c422b"
++checksum = "56899898ce76aaf4a0f24d914c97ea6ed976d42fec6ad33fcbb0a1103e07b2b0"
 +
 +[[package]]
 +name = "either"
···
 +
 +[[package]]
 +name = "encoding_rs"
-+version = "0.8.26"
++version = "0.8.28"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "801bbab217d7f79c0062f4f7205b5d4427c6d1a7bd7aafdd1475f7c59d62b283"
++checksum = "80df024fbc5ac80f87dfef0d9f5209a252f2a497f7f42944cff24d8253cac065"
 +dependencies = [
 + "cfg-if 1.0.0",
 +]
 +
 +[[package]]
-+name = "error-chain"
-+version = "0.12.4"
-+source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "2d2f06b9cac1506ece98fe3231e3cc9c4410ec3d5b1f24ae1c8946f0742cdefc"
-+dependencies = [
-+ "version_check 0.9.2",
-+]
-+
-+[[package]]
 +name = "failure"
 +version = "0.1.8"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
···
 +
 +[[package]]
 +name = "flate2"
-+version = "1.0.19"
++version = "1.0.20"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "7411863d55df97a419aa64cb4d2f167103ea9d767e2c54a1868b7ac3f6b47129"
++checksum = "cd3aec53de10fe96d7d8c565eb17f2c687bb5518a2ec453b5b1252964526abe0"
 +dependencies = [
 + "cfg-if 1.0.0",
 + "crc32fast",
···
 +
 +[[package]]
 +name = "form_urlencoded"
-+version = "1.0.0"
++version = "1.0.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "ece68d15c92e84fa4f19d3780f1294e5ca82a78a6d515f1efaabcc144688be00"
++checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"
 +dependencies = [
 + "matches",
 + "percent-encoding",
···
 +
 +[[package]]
 +name = "futures"
-+version = "0.3.8"
++version = "0.3.13"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "9b3b0c040a1fe6529d30b3c5944b280c7f0dcb2930d2c3062bca967b602583d0"
++checksum = "7f55667319111d593ba876406af7c409c0ebb44dc4be6132a783ccf163ea14c1"
 +dependencies = [
 + "futures-channel",
 + "futures-core",
···
 +
 +[[package]]
 +name = "futures-channel"
-+version = "0.3.8"
++version = "0.3.13"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "4b7109687aa4e177ef6fe84553af6280ef2778bdb7783ba44c9dc3399110fe64"
++checksum = "8c2dd2df839b57db9ab69c2c9d8f3e8c81984781937fe2807dc6dcf3b2ad2939"
 +dependencies = [
 + "futures-core",
 + "futures-sink",
···
 +
 +[[package]]
 +name = "futures-core"
-+version = "0.3.8"
++version = "0.3.13"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "847ce131b72ffb13b6109a221da9ad97a64cbe48feb1028356b836b47b8f1748"
++checksum = "15496a72fabf0e62bdc3df11a59a3787429221dd0710ba8ef163d6f7a9112c94"
 +
 +[[package]]
 +name = "futures-executor"
-+version = "0.3.8"
++version = "0.3.13"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "4caa2b2b68b880003057c1dd49f1ed937e38f22fcf6c212188a121f08cf40a65"
++checksum = "891a4b7b96d84d5940084b2a37632dd65deeae662c114ceaa2c879629c9c0ad1"
 +dependencies = [
 + "futures-core",
 + "futures-task",
···
 +
 +[[package]]
 +name = "futures-io"
-+version = "0.3.8"
++version = "0.3.13"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "611834ce18aaa1bd13c4b374f5d653e1027cf99b6b502584ff8c9a64413b30bb"
++checksum = "d71c2c65c57704c32f5241c1223167c2c3294fd34ac020c807ddbe6db287ba59"
 +
 +[[package]]
 +name = "futures-macro"
-+version = "0.3.8"
++version = "0.3.13"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "77408a692f1f97bcc61dc001d752e00643408fbc922e4d634c655df50d595556"
++checksum = "ea405816a5139fb39af82c2beb921d52143f556038378d6db21183a5c37fbfb7"
 +dependencies = [
 + "proc-macro-hack",
 + "proc-macro2",
···
 +
 +[[package]]
 +name = "futures-sink"
-+version = "0.3.8"
++version = "0.3.13"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "f878195a49cee50e006b02b93cf7e0a95a38ac7b776b4c4d9cc1207cd20fcb3d"
++checksum = "85754d98985841b7d4f5e8e6fbfa4a4ac847916893ec511a2917ccd8525b8bb3"
 +
 +[[package]]
 +name = "futures-task"
-+version = "0.3.8"
++version = "0.3.13"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "7c554eb5bf48b2426c4771ab68c6b14468b6e76cc90996f528c3338d761a4d0d"
-+dependencies = [
-+ "once_cell",
-+]
++checksum = "fa189ef211c15ee602667a6fcfe1c1fd9e07d42250d2156382820fba33c9df80"
 +
 +[[package]]
 +name = "futures-util"
-+version = "0.3.8"
++version = "0.3.13"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "d304cff4a7b99cfb7986f7d43fbe93d175e72e704a8860787cc95e9ffd85cbd2"
++checksum = "1812c7ab8aedf8d6f2701a43e1243acdbcc2b36ab26e2ad421eb99ac963d96d1"
 +dependencies = [
 + "futures-channel",
 + "futures-core",
···
 + "futures-sink",
 + "futures-task",
 + "memchr",
-+ "pin-project 1.0.2",
++ "pin-project-lite 0.2.6",
 + "pin-utils",
 + "proc-macro-hack",
 + "proc-macro-nested",
···
 +
 +[[package]]
 +name = "getrandom"
-+version = "0.1.15"
++version = "0.1.16"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "fc587bc0ec293155d5bfa6b9891ec18a1e330c234f896ea47fbada4cadbe47e6"
++checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
 +dependencies = [
-+ "cfg-if 0.1.10",
++ "cfg-if 1.0.0",
 + "libc",
 + "wasi 0.9.0+wasi-snapshot-preview1",
 +]
 +
 +[[package]]
++name = "getrandom"
++version = "0.2.2"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "c9495705279e7140bf035dde1f6e750c162df8b625267cd52cc44e0b156732c8"
++dependencies = [
++ "cfg-if 1.0.0",
++ "libc",
++ "wasi 0.10.2+wasi-snapshot-preview1",
++]
++
++[[package]]
 +name = "gimli"
 +version = "0.23.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
···
 +
 +[[package]]
 +name = "hermit-abi"
-+version = "0.1.17"
++version = "0.1.18"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "5aca5565f760fb5b220e499d72710ed156fdb74e631659e99377d9ebfbd13ae8"
++checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c"
 +dependencies = [
 + "libc",
 +]
 +
 +[[package]]
 +name = "hex"
-+version = "0.4.2"
++version = "0.4.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "644f9158b2f133fd50f5fb3242878846d9eb792e445c893805ff0e3824006e35"
++checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 +
 +[[package]]
 +name = "hound"
···
 +
 +[[package]]
 +name = "http"
-+version = "0.2.2"
++version = "0.2.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "84129d298a6d57d246960ff8eb831ca4af3f96d29e2e28848dae275408658e26"
++checksum = "7245cd7449cc792608c3c8a9eaf69bd4eabbabf802713748fd739c98b82f0747"
 +dependencies = [
-+ "bytes 0.5.6",
++ "bytes 1.0.1",
 + "fnv",
 + "itoa",
 +]
···
 +
 +[[package]]
 +name = "httparse"
-+version = "1.3.4"
++version = "1.3.5"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "cd179ae861f0c2e53da70d892f5f3029f9594be0c41dc5269cd371691b1dc2f9"
++checksum = "615caabe2c3160b313d52ccc905335f4ed5f10881dd63dc5699d47e90be85691"
 +
 +[[package]]
 +name = "httpdate"
···
 +
 +[[package]]
 +name = "hyper"
-+version = "0.13.9"
++version = "0.13.10"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "f6ad767baac13b44d4529fcf58ba2cd0995e36e7b435bc5b039de6f47e880dbf"
++checksum = "8a6f157065790a3ed2f88679250419b5cdd96e714a0d65f7797fd337186e96bb"
 +dependencies = [
 + "bytes 0.5.6",
 + "futures-channel",
···
 + "httparse",
 + "httpdate",
 + "itoa",
-+ "pin-project 1.0.2",
++ "pin-project",
 + "socket2",
 + "tokio",
 + "tower-service",
···
 +]
 +
 +[[package]]
++name = "ident_case"
++version = "1.0.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
++
++[[package]]
 +name = "idna"
-+version = "0.2.0"
++version = "0.2.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "02e2673c30ee86b5b96a9cb52ad15718aa1f966f5ab9ad54a8b95d5ca33120a9"
++checksum = "89829a5d69c23d348314a7ac337fe39173b61149a9864deabd260983aed48c21"
 +dependencies = [
 + "matches",
 + "unicode-bidi",
···
 +
 +[[package]]
 +name = "indexmap"
-+version = "1.6.1"
++version = "1.6.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "4fb1fa934250de4de8aef298d81c729a7d33d8c239daa3a7575e6b92bfc7313b"
++checksum = "824845a0bf897a9042383849b02c1bc219c2383772efcd5c6f9766fa4b81aef3"
 +dependencies = [
 + "autocfg",
 + "hashbrown",
 +]
 +
 +[[package]]
++name = "instant"
++version = "0.1.9"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "61124eeebbd69b8190558df225adf7e4caafce0d743919e5d6b19652314ec5ec"
++dependencies = [
++ "cfg-if 1.0.0",
++]
++
++[[package]]
 +name = "iovec"
 +version = "0.1.4"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
···
 +
 +[[package]]
 +name = "itoa"
-+version = "0.4.6"
++version = "0.4.7"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736"
++
++[[package]]
++name = "jni"
++version = "0.18.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "24967112a1e4301ca5342ea339763613a37592b8a6ce6cf2e4494537c7a42faf"
++dependencies = [
++ "cesu8",
++ "combine",
++ "jni-sys",
++ "log",
++ "thiserror",
++ "walkdir",
++]
++
++[[package]]
++name = "jni-sys"
++version = "0.3.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
++
++[[package]]
++name = "jobserver"
++version = "0.1.21"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"
++checksum = "5c71313ebb9439f74b00d9d2dcec36440beaf57a6aa0623068441dd7cd81a7f2"
++dependencies = [
++ "libc",
++]
 +
 +[[package]]
 +name = "js-sys"
-+version = "0.3.46"
++version = "0.3.50"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "cf3d7383929f7c9c7c2d0fa596f325832df98c3704f2c60553080f7127a58175"
++checksum = "2d99f9e3e84b8f67f846ef5b4cbbc3b1c29f6c759fcbce6f01aa0e73d932a24c"
 +dependencies = [
 + "wasm-bindgen",
 +]
···
 +
 +[[package]]
 +name = "lewton"
-+version = "0.9.4"
++version = "0.10.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "8d542c1a317036c45c2aa1cf10cc9d403ca91eb2d333ef1a4917e5cb10628bd0"
++checksum = "777b48df9aaab155475a83a7df3070395ea1ac6902f5cd062b8f2b028075c030"
 +dependencies = [
 + "byteorder",
 + "ogg",
-+ "smallvec",
++ "tinyvec",
 +]
 +
 +[[package]]
 +name = "libc"
-+version = "0.2.81"
++version = "0.2.92"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "1482821306169ec4d07f6aca392a4681f66c75c9918aa49641a2595db64053cb"
++checksum = "56d855069fafbb9b344c0f962150cd2c1187975cb1c22c1522c240d8c4986714"
 +
 +[[package]]
 +name = "libdbus-sys"
···
 +
 +[[package]]
 +name = "libloading"
-+version = "0.6.6"
++version = "0.7.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "e9367bdfa836b7e3cf895867f7a570283444da90562980ec2263d6e1569b16bc"
++checksum = "6f84d96438c15fcd6c3f244c8fce01d1e2b9c6b5623e9c711dc9286d8fc92d6a"
 +dependencies = [
 + "cfg-if 1.0.0",
 + "winapi 0.3.9",
···
 +
 +[[package]]
 +name = "linked-hash-map"
-+version = "0.5.3"
++version = "0.5.4"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "7fb9b38af92608140b86b693604b9ffcc5824240a484d1ecd4795bacb2fe88f3"
++
++[[package]]
++name = "lock_api"
++version = "0.4.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "8dd5a6d5999d9907cda8ed67bbd137d3af8085216c2ac62de5be860bd41f304a"
++checksum = "dd96ffd135b2fd7b973ac026d28085defbe8983df057ced3eb4f2130b0831312"
++dependencies = [
++ "scopeguard",
++]
 +
 +[[package]]
 +name = "log"
-+version = "0.4.11"
++version = "0.4.14"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "4fabed175da42fed1fa0746b0ea71f412aa9d35e76e95e59b192c64b9dc2bf8b"
++checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
 +dependencies = [
-+ "cfg-if 0.1.10",
++ "cfg-if 1.0.0",
 +]
 +
 +[[package]]
···
 +checksum = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
 +
 +[[package]]
-+name = "maybe-uninit"
-+version = "2.0.0"
-+source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00"
-+
-+[[package]]
 +name = "memchr"
 +version = "2.3.4"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
···
 +
 +[[package]]
 +name = "minimp3"
-+version = "0.3.5"
++version = "0.5.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "dce0cff6a0bfd3f8b6b2350819bbddd63bc65cc45e53888bdd0ff49dde16d2d5"
++checksum = "985438f75febf74c392071a975a29641b420dd84431135a6e6db721de4b74372"
 +dependencies = [
 + "minimp3-sys",
 + "slice-deque",
++ "thiserror",
 +]
 +
 +[[package]]
···
 +
 +[[package]]
 +name = "miniz_oxide"
-+version = "0.4.3"
++version = "0.4.4"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "0f2d26ec3309788e423cfbf68ad1800f061638098d76a83681af979dc4eda19d"
++checksum = "a92518e98c078586bc6c934028adcca4c92a53d6a958196de835170a01d84e4b"
 +dependencies = [
 + "adler",
 + "autocfg",
···
 +
 +[[package]]
 +name = "native-tls"
-+version = "0.2.6"
++version = "0.2.7"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "6fcc7939b5edc4e4f86b1b4a04bb1498afaaf871b1a6691838ed06fcb48d3a3f"
++checksum = "b8d96b2e1c8da3957d58100b09f102c6d9cfdfced01b7ec5a8974044bb09dbd4"
 +dependencies = [
 + "lazy_static 1.4.0",
 + "libc",
···
 +]
 +
 +[[package]]
++name = "ndk"
++version = "0.3.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "8794322172319b972f528bf90c6b467be0079f1fa82780ffb431088e741a73ab"
++dependencies = [
++ "jni-sys",
++ "ndk-sys",
++ "num_enum",
++ "thiserror",
++]
++
++[[package]]
++name = "ndk-glue"
++version = "0.3.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "c5caf0c24d51ac1c905c27d4eda4fa0635bbe0de596b8f79235e0b17a4d29385"
++dependencies = [
++ "lazy_static 1.4.0",
++ "libc",
++ "log",
++ "ndk",
++ "ndk-macro",
++ "ndk-sys",
++]
++
++[[package]]
++name = "ndk-macro"
++version = "0.2.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "05d1c6307dc424d0f65b9b06e94f88248e6305726b14729fd67a5e47b2dc481d"
++dependencies = [
++ "darling",
++ "proc-macro-crate",
++ "proc-macro2",
++ "quote",
++ "syn",
++]
++
++[[package]]
++name = "ndk-sys"
++version = "0.2.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "c44922cb3dbb1c70b5e5f443d63b64363a898564d739ba5198e3a9138442868d"
++
++[[package]]
 +name = "net2"
 +version = "0.2.37"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
···
 +
 +[[package]]
 +name = "netease_music_tui"
-+version = "0.1.1"
++version = "0.1.3"
 +dependencies = [
 + "base64 0.11.0",
 + "byteorder",
···
 + "mp3-duration",
 + "num-bigint",
 + "openssl",
-+ "rand",
++ "rand 0.7.3",
 + "regex",
 + "reqwest",
 + "rodio",
-+ "serde 1.0.118",
++ "serde 1.0.125",
 + "serde_derive",
 + "serde_json",
 + "serde_urlencoded 0.6.1",
···
 +]
 +
 +[[package]]
++name = "nix"
++version = "0.20.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "fa9b4819da1bc61c0ea48b63b7bc8604064dd43013e7cc325df098d49cd7c18a"
++dependencies = [
++ "bitflags",
++ "cc",
++ "cfg-if 1.0.0",
++ "libc",
++]
++
++[[package]]
 +name = "nom"
 +version = "4.2.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
···
 +checksum = "ffb4262d26ed83a1c0a33a38fe2bb15797329c85770da05e6b828ddb782627af"
 +dependencies = [
 + "memchr",
-+ "version_check 0.9.2",
++ "version_check 0.9.3",
 +]
 +
 +[[package]]
···
 +]
 +
 +[[package]]
++name = "num-derive"
++version = "0.3.3"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "876a53fff98e03a936a674b29568b0e605f06b29372c2489ff4de23f1949743d"
++dependencies = [
++ "proc-macro2",
++ "quote",
++ "syn",
++]
++
++[[package]]
 +name = "num-integer"
 +version = "0.1.44"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
···
 +]
 +
 +[[package]]
++name = "num_enum"
++version = "0.5.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "226b45a5c2ac4dd696ed30fa6b94b057ad909c7b7fc2e0d0808192bced894066"
++dependencies = [
++ "derivative",
++ "num_enum_derive",
++]
++
++[[package]]
++name = "num_enum_derive"
++version = "0.5.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "1c0fd9eba1d5db0994a239e09c1be402d35622277e35468ba891aa5e3188ce7e"
++dependencies = [
++ "proc-macro-crate",
++ "proc-macro2",
++ "quote",
++ "syn",
++]
++
++[[package]]
 +name = "numtoa"
 +version = "0.1.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
···
 +
 +[[package]]
 +name = "object"
-+version = "0.22.0"
++version = "0.23.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "a9a7ab5d64814df0fe4a4b5ead45ed6c5f181ee3ff04ba344313a6c80446c5d4"
++
++[[package]]
++name = "oboe"
++version = "0.4.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "4cfb2390bddb9546c0f7448fd1d2abdd39e6075206f960991eb28c7fa7f126c4"
++dependencies = [
++ "jni",
++ "ndk",
++ "ndk-glue",
++ "num-derive",
++ "num-traits 0.2.14",
++ "oboe-sys",
++]
++
++[[package]]
++name = "oboe-sys"
++version = "0.4.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "8d3b63360ec3cb337817c2dbd47ab4a0f170d285d8e5a2064600f3def1402397"
++checksum = "fe069264d082fc820dfa172f79be3f2e088ecfece9b1c47b0c9fd838d2bef103"
++dependencies = [
++ "cc",
++]
 +
 +[[package]]
 +name = "ogg"
-+version = "0.7.1"
++version = "0.8.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "13e571c3517af9e1729d4c63571a27edd660ade0667973bfc74a67c660c2b651"
++checksum = "6951b4e8bf21c8193da321bcce9c9dd2e13c858fe078bf9054a288b419ae5d6e"
 +dependencies = [
 + "byteorder",
 +]
 +
 +[[package]]
 +name = "once_cell"
-+version = "1.5.2"
++version = "1.7.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "13bd41f508810a131401606d54ac32a467c97172d74ba7662562ebba5ad07fa0"
++checksum = "af8b08b04175473088b46763e51ee54da5f9a164bc162f615b91bc179dbf15a3"
 +
 +[[package]]
 +name = "openssl"
-+version = "0.10.32"
++version = "0.10.33"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "038d43985d1ddca7a9900630d8cd031b56e4794eecc2e9ea39dd17aa04399a70"
++checksum = "a61075b62a23fef5a29815de7536d940aa35ce96d18ce0cc5076272db678a577"
 +dependencies = [
 + "bitflags",
 + "cfg-if 1.0.0",
 + "foreign-types",
-+ "lazy_static 1.4.0",
 + "libc",
++ "once_cell",
 + "openssl-sys",
 +]
 +
···
 +
 +[[package]]
 +name = "openssl-sys"
-+version = "0.9.60"
++version = "0.9.61"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "921fc71883267538946025deffb622905ecad223c28efbfdef9bb59a0175f3e6"
++checksum = "313752393519e876837e09e1fa183ddef0be7735868dced3196f4472d536277f"
 +dependencies = [
 + "autocfg",
 + "cc",
···
 +]
 +
 +[[package]]
++name = "parking_lot"
++version = "0.11.1"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "6d7744ac029df22dca6284efe4e898991d28e3085c706c972bcd7da4a27a15eb"
++dependencies = [
++ "instant",
++ "lock_api",
++ "parking_lot_core",
++]
++
++[[package]]
++name = "parking_lot_core"
++version = "0.8.3"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "fa7a782938e745763fe6907fc6ba86946d72f49fe7e21de074e08128a99fb018"
++dependencies = [
++ "cfg-if 1.0.0",
++ "instant",
++ "libc",
++ "redox_syscall 0.2.5",
++ "smallvec",
++ "winapi 0.3.9",
++]
++
++[[package]]
 +name = "peeking_take_while"
 +version = "0.1.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
···
 +
 +[[package]]
 +name = "pin-project"
-+version = "0.4.27"
++version = "1.0.6"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "2ffbc8e94b38ea3d2d8ba92aea2983b503cd75d0888d75b86bb37970b5698e15"
++checksum = "bc174859768806e91ae575187ada95c91a29e96a98dc5d2cd9a1fed039501ba6"
 +dependencies = [
-+ "pin-project-internal 0.4.27",
-+]
-+
-+[[package]]
-+name = "pin-project"
-+version = "1.0.2"
-+source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "9ccc2237c2c489783abd8c4c80e5450fc0e98644555b1364da68cc29aa151ca7"
-+dependencies = [
-+ "pin-project-internal 1.0.2",
++ "pin-project-internal",
 +]
 +
 +[[package]]
 +name = "pin-project-internal"
-+version = "0.4.27"
++version = "1.0.6"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "65ad2ae56b6abe3a1ee25f15ee605bacadb9a764edaba9c2bf4103800d4a1895"
-+dependencies = [
-+ "proc-macro2",
-+ "quote",
-+ "syn",
-+]
-+
-+[[package]]
-+name = "pin-project-internal"
-+version = "1.0.2"
-+source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "f8e8d2bf0b23038a4424865103a4df472855692821aab4e4f5c3312d461d9e5f"
++checksum = "a490329918e856ed1b083f244e3bfe2d8c4f336407e4ea9e1a9f479ff09049e5"
 +dependencies = [
 + "proc-macro2",
 + "quote",
···
 +
 +[[package]]
 +name = "pin-project-lite"
-+version = "0.1.11"
++version = "0.1.12"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "c917123afa01924fc84bb20c4c03f004d9c38e5127e3c039bbf7f4b9c76a2f6b"
++checksum = "257b64915a082f7811703966789728173279bdebb956b143dbcd23f6f970a777"
 +
 +[[package]]
 +name = "pin-project-lite"
-+version = "0.2.0"
++version = "0.2.6"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "6b063f57ec186e6140e2b8b6921e5f1bd89c7356dda5b33acc5401203ca6131c"
++checksum = "dc0e1f259c92177c30a4c9d177246edd0a3568b25756a977d0632cf8fa37e905"
 +
 +[[package]]
 +name = "pin-utils"
···
 +checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
 +
 +[[package]]
++name = "proc-macro-crate"
++version = "0.1.5"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "1d6ea3c4595b96363c13943497db34af4460fb474a95c43f4446ad341b8c9785"
++dependencies = [
++ "toml 0.5.8",
++]
++
++[[package]]
 +name = "proc-macro-hack"
 +version = "0.5.19"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
···
 +
 +[[package]]
 +name = "proc-macro-nested"
-+version = "0.1.6"
++version = "0.1.7"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "eba180dafb9038b050a4c280019bbedf9f2467b61e5d892dcad585bb57aadc5a"
++checksum = "bc881b2c22681370c6a780e47af9840ef841837bc98118431d4e1868bd0c1086"
 +
 +[[package]]
 +name = "proc-macro2"
-+version = "1.0.24"
++version = "1.0.26"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "1e0704ee1a7e00d7bb417d0770ea303c1bccbabf0ef1667dae92b5967f5f8a71"
++checksum = "a152013215dca273577e18d2bf00fa862b89b24169fb78c4c95aeb07992c9cec"
 +dependencies = [
 + "unicode-xid",
 +]
 +
 +[[package]]
 +name = "publicsuffix"
-+version = "1.5.4"
++version = "1.5.6"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "3bbaa49075179162b49acac1c6aa45fb4dafb5f13cf6794276d77bc7fd95757b"
++checksum = "95b4ce31ff0a27d93c8de1849cf58162283752f065a90d508f1105fa6c9a213f"
 +dependencies = [
-+ "error-chain",
 + "idna",
-+ "lazy_static 1.4.0",
-+ "regex",
 + "url",
 +]
 +
 +[[package]]
 +name = "quote"
-+version = "1.0.8"
++version = "1.0.9"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "991431c3519a3f36861882da93630ce66b52918dcf1b8e2fd66b397fc96f28df"
++checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
 +dependencies = [
 + "proc-macro2",
 +]
···
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
 +dependencies = [
-+ "getrandom",
++ "getrandom 0.1.16",
++ "libc",
++ "rand_chacha 0.2.2",
++ "rand_core 0.5.1",
++ "rand_hc 0.2.0",
++]
++
++[[package]]
++name = "rand"
++version = "0.8.3"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "0ef9e7e66b4468674bfcb0c81af8b7fa0bb154fa9f28eb840da5c447baeb8d7e"
++dependencies = [
 + "libc",
-+ "rand_chacha",
-+ "rand_core",
-+ "rand_hc",
++ "rand_chacha 0.3.0",
++ "rand_core 0.6.2",
++ "rand_hc 0.3.0",
 +]
 +
 +[[package]]
···
 +checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
 +dependencies = [
 + "ppv-lite86",
-+ "rand_core",
++ "rand_core 0.5.1",
++]
++
++[[package]]
++name = "rand_chacha"
++version = "0.3.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "e12735cf05c9e10bf21534da50a147b924d555dc7a547c42e6bb2d5b6017ae0d"
++dependencies = [
++ "ppv-lite86",
++ "rand_core 0.6.2",
 +]
 +
 +[[package]]
···
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
 +dependencies = [
-+ "getrandom",
++ "getrandom 0.1.16",
++]
++
++[[package]]
++name = "rand_core"
++version = "0.6.2"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "34cf66eb183df1c5876e2dcf6b13d57340741e8dc255b48e40a26de954d06ae7"
++dependencies = [
++ "getrandom 0.2.2",
 +]
 +
 +[[package]]
···
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
 +dependencies = [
-+ "rand_core",
++ "rand_core 0.5.1",
++]
++
++[[package]]
++name = "rand_hc"
++version = "0.3.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "3190ef7066a446f2e7f42e239d161e905420ccab01eb967c9eb27d21b2322a73"
++dependencies = [
++ "rand_core 0.6.2",
 +]
 +
 +[[package]]
···
 +checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
 +
 +[[package]]
++name = "redox_syscall"
++version = "0.2.5"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "94341e4e44e24f6b591b59e47a8a027df12e008d73fd5672dbea9cc22f4507d9"
++dependencies = [
++ "bitflags",
++]
++
++[[package]]
 +name = "redox_termios"
-+version = "0.1.1"
++version = "0.1.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "7e891cfe48e9100a70a3b6eb652fef28920c117d366339687bd5576160db0f76"
++checksum = "8440d8acb4fd3d277125b4bd01a6f38aee8d814b3b5fc09b3f2b825d37d3fe8f"
 +dependencies = [
-+ "redox_syscall",
++ "redox_syscall 0.2.5",
 +]
 +
 +[[package]]
···
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "de0737333e7a9502c789a36d7c7fa6092a49895d4faa31ca5df163857ded2e9d"
 +dependencies = [
-+ "getrandom",
-+ "redox_syscall",
++ "getrandom 0.1.16",
++ "redox_syscall 0.1.57",
 + "rust-argon2",
 +]
 +
 +[[package]]
 +name = "regex"
-+version = "1.4.2"
++version = "1.4.5"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "38cf2c13ed4745de91a5eb834e11c00bcc3709e773173b2ce4c56c9fbde04b9c"
++checksum = "957056ecddbeba1b26965114e191d2e8589ce74db242b6ea25fc4062427a5c19"
 +dependencies = [
 + "aho-corasick",
 + "memchr",
 + "regex-syntax",
-+ "thread_local",
 +]
 +
 +[[package]]
 +name = "regex-syntax"
-+version = "0.6.21"
++version = "0.6.23"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "3b181ba2dcf07aaccad5448e8ead58db5b742cf85dfe035e2227f137a539a189"
++checksum = "24d5f089152e60f62d28b835fbff2cd2e8dc0baf1ac13343bef92ab7eed84548"
 +
 +[[package]]
 +name = "remove_dir_all"
···
 + "mime_guess",
 + "native-tls",
 + "percent-encoding",
-+ "pin-project-lite 0.2.0",
-+ "serde 1.0.118",
++ "pin-project-lite 0.2.6",
++ "serde 1.0.125",
 + "serde_urlencoded 0.7.0",
-+ "time 0.2.23",
++ "time 0.2.26",
 + "tokio",
 + "tokio-socks",
 + "tokio-tls",
···
 +
 +[[package]]
 +name = "rodio"
-+version = "0.10.0"
++version = "0.13.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "1e0e0dfa7c8b17c6428f6e992a22ea595922cc86f946191b6b59e7ce96b77262"
++checksum = "b65c2eda643191f6d1bb12ea323a9db8d9ba95374e9be3780b5a9fb5cfb8520f"
 +dependencies = [
 + "claxon",
 + "cpal",
 + "hound",
-+ "lazy_static 1.4.0",
 + "lewton",
 + "minimp3",
 +]
···
 +checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
 +
 +[[package]]
++name = "same-file"
++version = "1.0.6"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
++dependencies = [
++ "winapi-util",
++]
++
++[[package]]
 +name = "schannel"
 +version = "0.1.19"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
···
 + "lazy_static 1.4.0",
 + "winapi 0.3.9",
 +]
++
++[[package]]
++name = "scopeguard"
++version = "1.1.0"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 +
 +[[package]]
 +name = "security-framework"
-+version = "2.0.0"
++version = "2.2.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "c1759c2e3c8580017a484a7ac56d3abc5a6c1feadf88db2f3633f12ae4268c69"
++checksum = "3670b1d2fdf6084d192bc71ead7aabe6c06aa2ea3fbd9cc3ac111fa5c2b1bd84"
 +dependencies = [
 + "bitflags",
 + "core-foundation",
···
 +
 +[[package]]
 +name = "security-framework-sys"
-+version = "2.0.0"
++version = "2.2.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "f99b9d5e26d2a71633cc4f2ebae7cc9f874044e0c351a27e17892d76dce5678b"
++checksum = "3676258fd3cfe2c9a0ec99ce3038798d847ce3e4bb17746373eb9f0f1ac16339"
 +dependencies = [
 + "core-foundation-sys 0.8.2",
 + "libc",
···
 +
 +[[package]]
 +name = "serde"
-+version = "1.0.118"
++version = "1.0.125"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "06c64263859d87aa2eb554587e2d23183398d617427327cf2b3d0ed8c69e4800"
++checksum = "558dc50e1a5a5fa7112ca2ce4effcb321b0300c0d4ccf0776a9f60cd89031171"
 +dependencies = [
 + "serde_derive",
 +]
···
 +
 +[[package]]
 +name = "serde_derive"
-+version = "1.0.118"
++version = "1.0.125"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "c84d3526699cd55261af4b941e4e725444df67aa4f9e6a3564f18030d12672df"
++checksum = "b093b7a2bb58203b5da3056c05b4ec1fed827dcfdb37347a8841695263b3d06d"
 +dependencies = [
 + "proc-macro2",
 + "quote",
···
 +
 +[[package]]
 +name = "serde_json"
-+version = "1.0.60"
++version = "1.0.64"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "1500e84d27fe482ed1dc791a56eddc2f230046a040fa908c08bda1d9fb615779"
++checksum = "799e97dc9fdae36a5c8b8f2cae9ce2ee9fdce2058c57a93e6099d919fd982f79"
 +dependencies = [
 + "itoa",
 + "ryu",
-+ "serde 1.0.118",
++ "serde 1.0.125",
 +]
 +
 +[[package]]
···
 +dependencies = [
 + "dtoa",
 + "itoa",
-+ "serde 1.0.118",
++ "serde 1.0.125",
 + "url",
 +]
 +
···
 + "form_urlencoded",
 + "itoa",
 + "ryu",
-+ "serde 1.0.118",
++ "serde 1.0.125",
 +]
 +
 +[[package]]
···
 +
 +[[package]]
 +name = "smallvec"
-+version = "0.6.13"
++version = "1.6.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "f7b0758c52e15a8b5e3691eae6cc559f08eee9406e548a4477ba4e67770a82b6"
-+dependencies = [
-+ "maybe-uninit",
-+]
++checksum = "fe0f37c9e8f3c5a4a66ad655a93c74daac4ad00c441533bf5c6e7990bb42604e"
 +
 +[[package]]
 +name = "socket2"
···
 +
 +[[package]]
 +name = "standback"
-+version = "0.2.13"
++version = "0.2.17"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "cf906c8b8fc3f6ecd1046e01da1d8ddec83e48c8b08b84dcc02b585a6bedf5a8"
++checksum = "e113fb6f3de07a243d434a56ec6f186dfd51cb08448239fe7bcae73f87ff28ff"
 +dependencies = [
-+ "version_check 0.9.2",
++ "version_check 0.9.3",
 +]
 +
 +[[package]]
···
 +dependencies = [
 + "proc-macro2",
 + "quote",
-+ "serde 1.0.118",
++ "serde 1.0.125",
 + "serde_derive",
 + "syn",
 +]
···
 + "base-x",
 + "proc-macro2",
 + "quote",
-+ "serde 1.0.118",
++ "serde 1.0.125",
 + "serde_derive",
 + "serde_json",
 + "sha1",
···
 +checksum = "213701ba3370744dcd1a12960caa4843b3d68b4d1c0a5d575e0d65b2ee9d16c0"
 +
 +[[package]]
++name = "strsim"
++version = "0.9.3"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "6446ced80d6c486436db5c078dde11a9f73d42b57fb273121e160b84f63d894c"
++
++[[package]]
 +name = "syn"
-+version = "1.0.55"
++version = "1.0.68"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "a571a711dddd09019ccc628e1b17fe87c59b09d513c06c026877aa708334f37a"
++checksum = "3ce15dd3ed8aa2f8eeac4716d6ef5ab58b6b9256db41d7e1a0224c2788e8fd87"
 +dependencies = [
 + "proc-macro2",
 + "quote",
···
 +
 +[[package]]
 +name = "tempfile"
-+version = "3.1.0"
++version = "3.2.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "7a6e24d9338a0a5be79593e2fa15a648add6138caa803e2d5bc782c371732ca9"
++checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
 +dependencies = [
-+ "cfg-if 0.1.10",
++ "cfg-if 1.0.0",
 + "libc",
-+ "rand",
-+ "redox_syscall",
++ "rand 0.8.3",
++ "redox_syscall 0.2.5",
 + "remove_dir_all",
 + "winapi 0.3.9",
 +]
 +
 +[[package]]
 +name = "termion"
-+version = "1.5.5"
++version = "1.5.6"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "c22cec9d8978d906be5ac94bceb5a010d885c626c4c8855721a4dbd20e3ac905"
++checksum = "077185e2eac69c3f8379a4298e1e07cd36beb962290d4a51199acf0fdc10607e"
 +dependencies = [
 + "libc",
 + "numtoa",
-+ "redox_syscall",
++ "redox_syscall 0.2.5",
 + "redox_termios",
 +]
 +
 +[[package]]
 +name = "thiserror"
-+version = "1.0.22"
++version = "1.0.24"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "0e9ae34b84616eedaaf1e9dd6026dbe00dcafa92aa0c8077cb69df1fcfe5e53e"
++checksum = "e0f4a65597094d4483ddaed134f409b2cb7c1beccf25201a9f73c719254fa98e"
 +dependencies = [
 + "thiserror-impl",
 +]
 +
 +[[package]]
 +name = "thiserror-impl"
-+version = "1.0.22"
++version = "1.0.24"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "9ba20f23e85b10754cd195504aebf6a27e2e6cbe28c17778a0c930724628dd56"
++checksum = "7765189610d8241a44529806d6fd1f2e0a08734313a35d5b3a556f92b381f3c0"
 +dependencies = [
 + "proc-macro2",
 + "quote",
···
 +checksum = "c7fbf4c9d56b320106cd64fd024dadfa0be7cb4706725fc44a7d7ce952d820c1"
 +dependencies = [
 + "libc",
-+ "redox_syscall",
++ "redox_syscall 0.1.57",
 + "winapi 0.3.9",
 +]
 +
 +[[package]]
-+name = "thread_local"
-+version = "1.0.1"
-+source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14"
-+dependencies = [
-+ "lazy_static 1.4.0",
-+]
-+
-+[[package]]
 +name = "time"
-+version = "0.1.44"
++version = "0.1.43"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "6db9e6914ab8b1ae1c260a4ae7a49b6c5611b40328a735b21862567685e73255"
++checksum = "ca8a50ef2360fbd1eeb0ecd46795a87a19024eb4b53c5dc916ca1fd95fe62438"
 +dependencies = [
 + "libc",
-+ "wasi 0.10.0+wasi-snapshot-preview1",
 + "winapi 0.3.9",
 +]
 +
 +[[package]]
 +name = "time"
-+version = "0.2.23"
++version = "0.2.26"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "bcdaeea317915d59b2b4cd3b5efcd156c309108664277793f5351700c02ce98b"
++checksum = "08a8cbfbf47955132d0202d1662f49b2423ae35862aee471f3ba4b133358f372"
 +dependencies = [
 + "const_fn",
 + "libc",
 + "standback",
 + "stdweb 0.4.20",
 + "time-macros",
-+ "version_check 0.9.2",
++ "version_check 0.9.3",
 + "winapi 0.3.9",
 +]
 +
···
 +
 +[[package]]
 +name = "tinyvec"
-+version = "1.1.0"
++version = "1.1.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "ccf8dbc19eb42fba10e8feaaec282fb50e2c14b2726d6301dbfeed0f73306a6f"
++checksum = "317cca572a0e89c3ce0ca1f1bdc9369547fe318a683418e42ac8f59d14701023"
 +dependencies = [
 + "tinyvec_macros",
 +]
···
 +
 +[[package]]
 +name = "tokio"
-+version = "0.2.24"
++version = "0.2.25"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "099837d3464c16a808060bb3f02263b412f6fafcb5d01c533d309985fbeebe48"
++checksum = "6703a273949a90131b290be1fe7b039d0fc884aa1935860dfcbe056f28cd8092"
 +dependencies = [
 + "bytes 0.5.6",
 + "fnv",
···
 + "memchr",
 + "mio",
 + "num_cpus",
-+ "pin-project-lite 0.1.11",
++ "pin-project-lite 0.1.12",
 + "slab",
 + "tokio-macros",
 +]
···
 + "futures-core",
 + "futures-sink",
 + "log",
-+ "pin-project-lite 0.1.11",
++ "pin-project-lite 0.1.12",
 + "tokio",
 +]
 +
···
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "758664fc71a3a69038656bee8b6be6477d2a6c315a6b81f7081f591bffa4111f"
 +dependencies = [
-+ "serde 1.0.118",
++ "serde 1.0.125",
++]
++
++[[package]]
++name = "toml"
++version = "0.5.8"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
++dependencies = [
++ "serde 1.0.125",
 +]
 +
 +[[package]]
 +name = "tower-service"
-+version = "0.3.0"
++version = "0.3.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "e987b6bf443f4b5b3b6f38704195592cca41c5bb7aedd3c3693c7081f8289860"
++checksum = "360dfd1d6d30e05fda32ace2c8c70e9c0a9da713275777f5a4dbb8a1893930c6"
 +
 +[[package]]
 +name = "tracing"
-+version = "0.1.22"
++version = "0.1.25"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "9f47026cdc4080c07e49b37087de021820269d996f581aac150ef9e5583eefe3"
++checksum = "01ebdc2bb4498ab1ab5f5b73c5803825e60199229ccba0698170e3be0e7f959f"
 +dependencies = [
 + "cfg-if 1.0.0",
 + "log",
-+ "pin-project-lite 0.2.0",
++ "pin-project-lite 0.2.6",
 + "tracing-core",
 +]
 +
···
 +
 +[[package]]
 +name = "tracing-futures"
-+version = "0.2.4"
++version = "0.2.5"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "ab7bb6f14721aa00656086e9335d363c5c8747bae02ebe32ea2c7dece5689b4c"
++checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"
 +dependencies = [
-+ "pin-project 0.4.27",
++ "pin-project",
 + "tracing",
 +]
 +
···
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6"
 +dependencies = [
-+ "version_check 0.9.2",
++ "version_check 0.9.3",
 +]
 +
 +[[package]]
···
 +
 +[[package]]
 +name = "unicode-normalization"
-+version = "0.1.16"
++version = "0.1.17"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "a13e63ab62dbe32aeee58d1c5408d35c36c392bba5d9d3142287219721afe606"
++checksum = "07fbfce1c8a97d547e8b5334978438d9d6ec8c20e38f56d4a4374d181493eaef"
 +dependencies = [
 + "tinyvec",
 +]
···
 +
 +[[package]]
 +name = "url"
-+version = "2.2.0"
++version = "2.2.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "5909f2b0817350449ed73e8bcd81c8c3c8d9a7a5d8acba4b27db277f1868976e"
++checksum = "9ccd964113622c8e9322cfac19eb1004a07e636c545f325da085d5cdde6f1f8b"
 +dependencies = [
 + "form_urlencoded",
 + "idna",
···
 +
 +[[package]]
 +name = "version_check"
-+version = "0.9.2"
++version = "0.9.3"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
++
++[[package]]
++name = "walkdir"
++version = "2.3.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "b5a972e5669d67ba988ce3dc826706fb0a8b01471c088cb0b6110b805cc36aed"
++checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"
++dependencies = [
++ "same-file",
++ "winapi 0.3.9",
++ "winapi-util",
++]
 +
 +[[package]]
 +name = "want"
···
 +
 +[[package]]
 +name = "wasi"
-+version = "0.10.0+wasi-snapshot-preview1"
++version = "0.10.2+wasi-snapshot-preview1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
++checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
 +
 +[[package]]
 +name = "wasm-bindgen"
-+version = "0.2.69"
++version = "0.2.73"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "3cd364751395ca0f68cafb17666eee36b63077fb5ecd972bbcd74c90c4bf736e"
++checksum = "83240549659d187488f91f33c0f8547cbfef0b2088bc470c116d1d260ef623d9"
 +dependencies = [
 + "cfg-if 1.0.0",
-+ "serde 1.0.118",
++ "serde 1.0.125",
 + "serde_json",
 + "wasm-bindgen-macro",
 +]
 +
 +[[package]]
 +name = "wasm-bindgen-backend"
-+version = "0.2.69"
++version = "0.2.73"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "1114f89ab1f4106e5b55e688b828c0ab0ea593a1ea7c094b141b14cbaaec2d62"
++checksum = "ae70622411ca953215ca6d06d3ebeb1e915f0f6613e3b495122878d7ebec7dae"
 +dependencies = [
 + "bumpalo",
 + "lazy_static 1.4.0",
···
 +
 +[[package]]
 +name = "wasm-bindgen-futures"
-+version = "0.4.19"
++version = "0.4.23"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "1fe9756085a84584ee9457a002b7cdfe0bfff169f45d2591d8be1345a6780e35"
++checksum = "81b8b767af23de6ac18bf2168b690bed2902743ddf0fb39252e36f9e2bfc63ea"
 +dependencies = [
 + "cfg-if 1.0.0",
 + "js-sys",
···
 +
 +[[package]]
 +name = "wasm-bindgen-macro"
-+version = "0.2.69"
++version = "0.2.73"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "7a6ac8995ead1f084a8dea1e65f194d0973800c7f571f6edd70adf06ecf77084"
++checksum = "3e734d91443f177bfdb41969de821e15c516931c3c3db3d318fa1b68975d0f6f"
 +dependencies = [
 + "quote",
 + "wasm-bindgen-macro-support",
···
 +
 +[[package]]
 +name = "wasm-bindgen-macro-support"
-+version = "0.2.69"
++version = "0.2.73"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "b5a48c72f299d80557c7c62e37e7225369ecc0c963964059509fbafe917c7549"
++checksum = "d53739ff08c8a68b0fdbcd54c372b8ab800b1449ab3c9d706503bc7dd1621b2c"
 +dependencies = [
 + "proc-macro2",
 + "quote",
···
 +
 +[[package]]
 +name = "wasm-bindgen-shared"
-+version = "0.2.69"
++version = "0.2.73"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "7e7811dd7f9398f14cc76efd356f98f03aa30419dea46aa810d71e819fc97158"
++checksum = "d9a543ae66aa233d14bb765ed9af4a33e81b8b58d1584cf1b47ff8cd0b9e4489"
 +
 +[[package]]
 +name = "web-sys"
-+version = "0.3.46"
++version = "0.3.50"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "222b1ef9334f92a21d3fb53dc3fd80f30836959a90f9274a626d7e06315ba3c3"
++checksum = "a905d57e488fec8861446d3393670fb50d27a262344013181c2cdf9fff5481be"
 +dependencies = [
 + "js-sys",
 + "wasm-bindgen",
···
 +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 +
 +[[package]]
++name = "winapi-util"
++version = "0.1.5"
++source = "registry+https://github.com/rust-lang/crates.io-index"
++checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
++dependencies = [
++ "winapi 0.3.9",
++]
++
++[[package]]
 +name = "winapi-x86_64-pc-windows-gnu"
 +version = "0.4.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
···
 +
 +[[package]]
 +name = "yaml-rust"
-+version = "0.4.4"
++version = "0.4.5"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
-+checksum = "39f0c922f1a334134dc2f7a8b67dc5d25f0735263feec974345ff706bcf20b0d"
++checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
 +dependencies = [
-+ "linked-hash-map 0.5.3",
++ "linked-hash-map 0.5.4",
 +]

pkgs/applications/audio/netease-music-tui/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "netease-music-tui";
-  version = "v0.1.2";
+  version = "0.1.3";
 
   src = fetchFromGitHub {
     owner = "betta-cyber";
     repo = "netease-music-tui";
-    rev = version;
-    sha256 = "0m5b3q493d32kxznm4apn56216l07b1c49km236i03mpfvdw7m1f";
+    rev = "v${version}";
+    sha256 = "09355a6d197ckayh9833y39dsarklgpgrq3raapiv25z59di30qq";
   };
 
   cargoPatches = [ ./cargo-lock.patch ];
···
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ alsaLib openssl ];
 
-  cargoSha256 = "1kfbnwy3lkbhz0ggxwr5n6qd1plipkr1ycr3z2r7c0amrzzbkc7l";
+  cargoSha256 = "0f06wc7h2zjipifvxsskxvihjf6mykrjrm7yk0zf98ra079bc9g9";
 
   meta = with lib; {
     homepage = "https://github.com/betta-cyber/netease-music-tui";

pkgs/applications/audio/netease-music-tui/update-cargo-lock.sh

···
+#!nix-shell
+#!nix-shell -i bash -p coreutils gnugrep git cargo
+
+# This updates cargo-lock.patch for the netease-music-tui version listed in
+# default.nix.
+
+set -eu -o verbose
+
+here=$PWD
+version=$(cat default.nix | grep '^  version = "' | cut -d '"' -f 2)
+checkout=$(mktemp -d)
+git clone -b "$version" --depth=1 https://github.com/betta-cyber/netease-music-tui "$checkout"
+cd "$checkout"
+
+cargo generate-lockfile
+git add -f Cargo.lock
+git diff HEAD -- Cargo.lock > "$here"/cargo-lock.patch
+
+cd "$here"
+rm -rf "$checkout"

pkgs/applications/audio/sonic-pi/default.nix

···
 , pkg-config
 , boost
 , bash
-, jack2Full
+, jack2
 , supercollider
 , qwt
 , osmid
···
   dontWrapQtApps = true;
   preFixup = ''
     wrapQtApp "$out/bin/sonic-pi" \
-      --prefix PATH : ${ruby}/bin:${bash}/bin:${supercollider}/bin:${jack2Full}/bin \
+      --prefix PATH : ${ruby}/bin:${bash}/bin:${supercollider}/bin:${jack2}/bin \
       --set AUBIO_LIB "${aubio}/lib/libaubio.so"
   '';
 

pkgs/applications/audio/tetraproc/default.nix

···
 { lib, stdenv, fetchurl, makeWrapper
-, expat, fftwFloat, fontconfig, freetype, libjack2, jack2Full, libclthreads, libclxclient
+, expat, fftwFloat, fontconfig, freetype, libjack2, jack2, libclthreads, libclxclient
 , libsndfile, libxcb, xorg
 }:
 
···
 
   postInstall = ''
     # Make sure Jack is avalable in $PATH for tetraproc
-    wrapProgram $out/bin/tetraproc --prefix PATH : "${jack2Full}/bin"
+    wrapProgram $out/bin/tetraproc --prefix PATH : "${jack2}/bin"
   '';
 
   meta = with lib; {

pkgs/applications/editors/emacs/27.nix

···
 import ./generic.nix (rec {
-  version = "27.1";
-  sha256 = "0h9f2wpmp6rb5rfwvqwv1ia1nw86h74p7hnz3vb3gjazj67i4k2a";
+  version = "27.2";
+  sha256 = "sha256-tKfMTnjmPzeGJOCRkhW5EK9bsqCvyBn60pgnLp9Awbk=";
   patches = [
     ./tramp-detect-wrapped-gvfsd.patch
   ];

pkgs/applications/editors/emacs/tramp-detect-wrapped-gvfsd.patch

···
 diff --git a/lisp/net/tramp-gvfs.el b/lisp/net/tramp-gvfs.el
-index 34a234c..b5a471c 100644
+index 9e26c8fd6d..fa220e513c 100644
 --- a/lisp/net/tramp-gvfs.el
 +++ b/lisp/net/tramp-gvfs.el
-@@ -122,6 +122,7 @@
- 	 (tramp-compat-funcall 'dbus-get-unique-name :system)
- 	 (tramp-compat-funcall 'dbus-get-unique-name :session)
- 	 (or (tramp-compat-process-running-p "gvfs-fuse-daemon")
+@@ -125,5 +125,6 @@
+ 	     ;; for some processes.  Better we don't check.
+ 	     (<= emacs-major-version 25)
+ 	     (tramp-compat-process-running-p "gvfs-fuse-daemon")
 +	     (tramp-compat-process-running-p ".gvfsd-fuse-wrapped")
  	     (tramp-compat-process-running-p "gvfsd-fuse"))))
    "Non-nil when GVFS is available.")
- 

pkgs/applications/editors/sigil/default.nix

···
 
 mkDerivation rec {
   pname = "sigil";
-  version = "1.4.3";
+  version = "1.5.1";
 
   src = fetchFromGitHub {
     repo = "Sigil";
     owner = "Sigil-Ebook";
     rev = version;
-    sha256 = "1hk8kmhvkwfimbxzhwbnb8qdpf4n36cdzl9wfvi574i9pps36hnz";
+    sha256 = "sha256-BqNaIsUJE0KmFcmTjJERbclzaRe1dMjareWxUye2se0=";
   };
 
   pythonPath = with python3Packages; [ lxml ];

pkgs/applications/gis/saga/default.nix

···
 , dxflib
 , curl
 , libiodbc
-, lzma
+, xz
 , libharu
 , opencv
 , vigra
···
     vigra
     postgresql
     libiodbc
-    lzma
+    xz
     qhull
     giflib
   ]

pkgs/applications/graphics/hydrus/default.nix

···
 { lib
 , fetchFromGitHub
-, lzma
+, xz
 , qt5
 , wrapQtAppsHook
 , miniupnpc_2
···
     service-identity
     twisted
     lz4
-    lzma
+    xz
     pysocks
     matplotlib
     qtpy

pkgs/applications/graphics/opentoonz/default.nix

···
 { boost, cmake, fetchFromGitHub, freeglut, freetype, glew, libjpeg, libmypaint
-, libpng, libtiff, libusb1, lz4, lzma, lzo, openblas, pkg-config, qtbase
+, libpng, libtiff, libusb1, lz4, xz, lzo, openblas, pkg-config, qtbase
 , qtmultimedia, qtscript, lib, stdenv, superlu, wrapQtAppsHook, }:
 let source = import ./source.nix { inherit fetchFromGitHub; };
 in stdenv.mkDerivation rec {
···
     libtiff
     libusb1
     lz4
-    lzma
+    xz
     lzo
     openblas
     qtbase

pkgs/applications/graphics/sane/config.nix

···
 { lib, stdenv }:
 
-{ paths }:
+{ paths, disabledDefaultBackends ? [] }:
 
 with lib;
-let installSanePath = path: ''
+let
+installSanePath = path: ''
       if [ -e "${path}/lib/sane" ]; then
         find "${path}/lib/sane" -maxdepth 1 -not -type d | while read backend; do
           symlink "$backend" "$out/lib/sane/$(basename "$backend")"
···
         done
       fi
     '';
+    disableBackend = backend: ''
+      grep -q '${backend}' $out/etc/sane.d/dll.conf || { echo '${backend} is not a default plugin in $SANE_CONFIG_DIR/dll.conf'; exit 1; }
+      substituteInPlace $out/etc/sane.d/dll.conf --replace '${backend}' '# ${backend} disabled in nixos config'
+    '';
 in
 stdenv.mkDerivation {
   name = "sane-config";
···
     }
 
     mkdir -p $out/etc/sane.d $out/etc/sane.d/dll.d $out/lib/sane
-  '' + concatMapStrings installSanePath paths;
+  ''
+  + (concatMapStrings installSanePath paths)
+  + (concatMapStrings disableBackend disabledDefaultBackends);
 }

pkgs/applications/kde/akonadi/default.nix

···
   mkDerivation, lib, kdepimTeam,
   extra-cmake-modules, shared-mime-info, qtbase, accounts-qt,
   boost, kaccounts-integration, kcompletion, kconfigwidgets, kcrash, kdbusaddons,
-  kdesignerplugin, ki18n, kiconthemes, kio, kitemmodels, kwindowsystem, mysql, qttools,
-  signond, lzma,
+  kdesignerplugin, ki18n, kiconthemes, kio, kitemmodels, kwindowsystem, mariadb, qttools,
+  signond, xz,
 }:
 
 mkDerivation {
···
   nativeBuildInputs = [ extra-cmake-modules shared-mime-info ];
   buildInputs = [
     kaccounts-integration kcompletion kconfigwidgets kcrash kdbusaddons kdesignerplugin
-    ki18n kiconthemes kio kwindowsystem lzma accounts-qt qttools signond
+    ki18n kiconthemes kio kwindowsystem xz accounts-qt qttools signond
   ];
   propagatedBuildInputs = [ boost kitemmodels ];
   outputs = [ "out" "dev" ];
   CXXFLAGS = [
-    ''-DNIXPKGS_MYSQL_MYSQLD=\"${lib.getBin mysql}/bin/mysqld\"''
-    ''-DNIXPKGS_MYSQL_MYSQLADMIN=\"${lib.getBin mysql}/bin/mysqladmin\"''
-    ''-DNIXPKGS_MYSQL_MYSQL_INSTALL_DB=\"${lib.getBin mysql}/bin/mysql_install_db\"''
-    ''-DNIXPKGS_MYSQL_MYSQLCHECK=\"${lib.getBin mysql}/bin/mysqlcheck\"''
+    ''-DNIXPKGS_MYSQL_MYSQLD=\"${lib.getBin mariadb}/bin/mysqld\"''
+    ''-DNIXPKGS_MYSQL_MYSQLADMIN=\"${lib.getBin mariadb}/bin/mysqladmin\"''
+    ''-DNIXPKGS_MYSQL_MYSQL_INSTALL_DB=\"${lib.getBin mariadb}/bin/mysql_install_db\"''
+    ''-DNIXPKGS_MYSQL_MYSQLCHECK=\"${lib.getBin mariadb}/bin/mysqlcheck\"''
     ''-DNIXPKGS_POSTGRES_PG_CTL=\"\"''
     ''-DNIXPKGS_POSTGRES_PG_UPGRADE=\"\"''
     ''-DNIXPKGS_POSTGRES_INITDB=\"\"''

pkgs/applications/misc/azuredatastudio/default.nix

···
 , at-spi2-atk
 , gnutar
 , atomEnv
-, kerberos
+, libkrb5
 }:
 
 # from justinwoo/azuredatastudio-nix
···
         at-spi2-core
         at-spi2-atk
         stdenv.cc.cc.lib
-        kerberos
+        libkrb5
       ]
     )
     targetPath

pkgs/applications/misc/bashSnippets/default.nix

···
 { stdenv, lib, fetchFromGitHub, makeWrapper
-, curl, python3, bind, iproute, bc, gitMinimal }:
+, curl, python3, bind, iproute2, bc, gitMinimal }:
 let
   version = "1.23.0";
   deps = lib.makeBinPath [
     curl
     python3
     bind.dnsutils
-    iproute
+    iproute2
     bc
     gitMinimal
   ];

pkgs/applications/misc/cura/plugins.nix

···
-{ lib, stdenv, fetchFromGitHub, fetchpatch, python3Packages }:
+{ lib, stdenv, fetchFromGitHub, fetchpatch, python3Packages, libspnav }:
 
 let
 
···
 
     octoprint = stdenv.mkDerivation rec {
       pname = "Cura-OctoPrintPlugin";
-      version = "3.5.16";
+      version = "3.5.18";
 
       src = fetchFromGitHub {
         owner = "fieldOfView";
         repo = pname;
-        rev = "8affa8aa9796cb37129d3b7222fff03f86c936cd";
-        sha256 = "0l4qfcashkdmpdm8nm3klz6hmi1f0bmbpb9b1yn4mvg0fam6c5xi";
+        rev = "7bd73946fbf22d18337dc900a81a011ece26bee0";
+        sha256 = "057b2f5f49p96lkh2wsr9w6yh2003x4a85irqsgbzp6igmk8imdn";
       };
 
       propagatedBuildInputs = with python3Packages; [
···
         description = "Enables printing directly to OctoPrint and monitoring the process";
         homepage = "https://github.com/fieldOfView/Cura-OctoPrintPlugin";
         license = licenses.agpl3;
+        maintainers = with maintainers; [ gebner ];
+      };
+    };
+
+    rawmouse = stdenv.mkDerivation rec {
+      pname = "RawMouse";
+      version = "1.0.13";
+
+      src = fetchFromGitHub {
+        owner = "smartavionics";
+        repo = pname;
+        rev = version;
+        sha256 = "1cj40pgsfcwliz47mkiqjbslkwcm34qb1pajc2mcljgflcnickly";
+      };
+
+      buildPhase = ''
+        substituteInPlace RawMouse/config.json --replace \
+          /usr/local/lib/libspnav.so ${libspnav}/lib/libspnav.so
+      '';
+
+      installPhase = ''
+        mkdir -p $out/lib/cura/plugins/RawMouse
+        cp -rv . $out/lib/cura/plugins/RawMouse/
+      '';
+
+      meta = with lib; {
+        description = "Cura plugin for HID mice such as 3Dconnexion spacemouse";
+        homepage = "https://github.com/smartavionics/RawMouse";
+        license = licenses.agpl3Plus;
         maintainers = with maintainers; [ gebner ];
       };
     };

pkgs/applications/misc/dbeaver/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "dbeaver-ce";
-  version = "21.0.1"; # When updating also update fetchedMavenDeps.sha256
+  version = "21.0.2"; # When updating also update fetchedMavenDeps.sha256
 
   src = fetchFromGitHub {
     owner = "dbeaver";
     repo = "dbeaver";
     rev = version;
-    sha256 = "sha256-9l8604STqmdoUjD+EJCp4aDk4juKsPCmFnD/WYpajxo=";
+    sha256 = "sha256-3EMSiEq1wdg4dxBU90RVVv0Hrf5dXPc1MPI0+WMk48k=";
   };
 
   fetchedMavenDeps = stdenv.mkDerivation {

pkgs/applications/misc/golden-cheetah/default.nix

···
 { lib, fetchFromGitHub, fetchpatch, mkDerivation
 , qtbase, qtsvg, qtserialport, qtwebengine, qtmultimedia, qttools
 , qtconnectivity, qtcharts, libusb-compat-0_1
-, yacc, flex, zlib, qmake, makeDesktopItem, makeWrapper
+, bison, flex, zlib, qmake, makeDesktopItem, makeWrapper
 }:
 
 let
···
     qtbase qtsvg qtserialport qtwebengine qtmultimedia qttools zlib
     qtconnectivity qtcharts libusb-compat-0_1
   ];
-  nativeBuildInputs = [ flex makeWrapper qmake yacc ];
+  nativeBuildInputs = [ flex makeWrapper qmake bison ];
 
   patches = [
     # allow building with bison 3.7

pkgs/applications/misc/mediainfo/default.nix

···
 { lib, stdenv, fetchurl, autoreconfHook, pkg-config, libzen, libmediainfo, zlib }:
 
 stdenv.mkDerivation rec {
-  version = "20.09";
+  version = "21.03";
   pname = "mediainfo";
   src = fetchurl {
     url = "https://mediaarea.net/download/source/mediainfo/${version}/mediainfo_${version}.tar.xz";
-    sha256 = "0rqg9z7s5bk7vlvjrs4gackzg7ib05a0dffi2ihsjf5a7kw7wcir";
+    sha256 = "07h2a1lbw5ak6c9bcn8qydchl0wpgk945rf9sfcqjyv05h5wll6y";
   };
 
   nativeBuildInputs = [ autoreconfHook pkg-config ];

pkgs/applications/misc/mob/default.nix

···
 
 buildGoPackage rec {
   pname = "mob";
-  version = "1.3.0";
+  version = "1.4.0";
   goPackagePath = "github.com/remotemobprogramming/mob";
 
   src = fetchFromGitHub {
     rev = "v${version}";
     owner = "remotemobprogramming";
     repo = pname;
-    sha256 = "sha256-uzWr6wWO6niocJ8yLc1Uu9Wt/FXlCuQrC0RJkgVlphM=";
+    sha256 = "sha256-JiTRTH8ai27H1xySyKTWiu/MG0C61Tz+hVI6tkSRp+k=";
   };
 
   meta = with lib; {

pkgs/applications/misc/mupdf/default.nix

···
-{ stdenv, lib, fetchurl, fetchpatch, pkg-config, freetype, harfbuzz, openjpeg
-, jbig2dec, libjpeg , darwin
+{ stdenv
+, lib
+, fetchurl
+, fetchpatch
+, pkg-config
+, freetype
+, harfbuzz
+, openjpeg
+, jbig2dec
+, libjpeg
+, darwin
 , gumbo
-, enableX11 ? true, libX11, libXext, libXi, libXrandr
-, enableCurl ? true, curl, openssl
-, enableGL ? true, freeglut, libGLU
+, enableX11 ? true
+, libX11
+, libXext
+, libXi
+, libXrandr
+, enableCurl ? true
+, curl
+, openssl
+, enableGL ? true
+, freeglut
+, libGLU
 }:
-
 let
 
   # OpenJPEG version is hardcoded in package source
···
     lib.versions.majorMinor (lib.getVersion openjpeg);
 
 
-in stdenv.mkDerivation rec {
+in
+stdenv.mkDerivation rec {
   version = "1.18.0";
   pname = "mupdf";
 
···
   # Use shared libraries to decrease size
   buildFlags = [ "shared" ];
 
-  makeFlags = [ "prefix=$(out) USE_SYSTEM_LIBS=yes" ];
+  makeFlags = [ "prefix=$(out)" "USE_SYSTEM_LIBS=yes" ]
+    ++ lib.optionals (!enableX11) [ "HAVE_X11=no" ]
+    ++ lib.optionals (!enableGL) [ "HAVE_GLUT=no" ];
+
   nativeBuildInputs = [ pkg-config ];
-  buildInputs = [ freetype harfbuzz openjpeg jbig2dec libjpeg freeglut libGLU gumbo ]
-                ++ lib.optionals enableX11 [ libX11 libXext libXi libXrandr ]
-                ++ lib.optionals enableCurl [ curl openssl ]
-                ++ lib.optionals enableGL (
-                  if stdenv.isDarwin then
-                    with darwin.apple_sdk.frameworks; [ GLUT OpenGL ]
-                  else
-                    [ freeglut libGLU ])
-                ;
+  buildInputs = [ freetype harfbuzz openjpeg jbig2dec libjpeg gumbo ]
+    ++ lib.optionals enableX11 [ libX11 libXext libXi libXrandr ]
+    ++ lib.optionals enableCurl [ curl openssl ]
+    ++ lib.optionals enableGL (
+    if stdenv.isDarwin then
+      with darwin.apple_sdk.frameworks; [ GLUT OpenGL ]
+    else
+      [ freeglut libGLU ]
+  )
+  ;
   outputs = [ "bin" "dev" "out" "man" "doc" ];
 
   preConfigure = ''
···
     EOF
 
     moveToOutput "bin" "$bin"
+  '' + lib.optionalString enableX11 ''
     ln -s "$bin/bin/mupdf-x11" "$bin/bin/mupdf"
     mkdir -p $bin/share/applications
     cat > $bin/share/applications/mupdf.desktop <<EOF

pkgs/applications/misc/openlp/default.nix

···
+# This file contains all runtime glue: Bindings to optional runtime dependencies
+# for pdfSupport, presentationSupport, and media playback.
+{ lib, mkDerivation, wrapGAppsHook, python3Packages
+
+# qt deps
+, qtbase, qtmultimedia
+
+# optional deps
+, pdfSupport ? false, mupdf  # alternatively could use ghostscript
+, presentationSupport ? false, libreoffice-unwrapped
+, vlcSupport ? false
+, gstreamerSupport ? false, gst_all_1, gstPlugins ? (gst: [
+    gst.gst-plugins-base
+    gst.gst-plugins-good
+    gst.gst-plugins-bad
+    gst.gst-plugins-ugly
+  ])
+
+#, enableMySql ? false      # Untested. If interested, contact maintainer.
+#, enablePostgreSql ? false # Untested. If interested, contact maintainer.
+#, enableJenkinsApi ? false # Untested. If interested, contact maintainer.
+}:
+
+let p = gstPlugins gst_all_1;
+# If gstreamer is activated but no plugins are given, it will at runtime
+# create the false illusion of being usable.
+in assert gstreamerSupport -> (builtins.isList p && builtins.length p > 0);
+
+let
+  # optional packages
+  libreofficePath = "${libreoffice-unwrapped}/lib/libreoffice/program";
+
+  # lib functions
+  inherit (lib.lists) optional optionals;
+  wrapSetVar = var: ''--set ${var} "''$${var}"'';
+
+  # base pkg/lib
+  baseLib = python3Packages.callPackage ./lib.nix { };
+in mkDerivation {
+  inherit (baseLib) pname version src;
+
+  nativeBuildInputs = [ python3Packages.wrapPython wrapGAppsHook ];
+  buildInputs = [ qtbase ] ++ optionals gstreamerSupport
+    ([ qtmultimedia.bin gst_all_1.gstreamer ] ++ gstPlugins gst_all_1);
+  propagatedBuildInputs = optional pdfSupport mupdf
+    ++ optional presentationSupport libreoffice-unwrapped;
+  pythonPath = [ baseLib ] ++ optional vlcSupport python3Packages.python-vlc;
+    # ++ optional enableMySql mysql-connector  # Untested. If interested, contact maintainer.
+    # ++ optional enablePostgreSql psycopg2    # Untested. If interested, contact maintainer.
+    # ++ optional enableJenkinsApi jenkinsapi  # Untested. If interested, contact maintainer.
+
+  PYTHONPATH = libreofficePath;
+  URE_BOOTSTRAP = "vnd.sun.star.pathname:${libreofficePath}/fundamentalrc";
+  UNO_PATH = libreofficePath;
+  LD_LIBRARY_PATH = libreofficePath;
+  JAVA_HOME = "${libreoffice-unwrapped.jdk.home}";
+
+  dontWrapQtApps = true;
+  dontWrapGApps = true;
+
+  # defined in gappsWrapperHook
+  wrapPrefixVariables = optionals presentationSupport
+    [ "PYTHONPATH" "LD_LIBRARY_PATH" "JAVA_HOME" ];
+  makeWrapperArgs = [
+    "\${gappsWrapperArgs[@]}"
+    "\${qtWrapperArgs[@]}"
+  ] ++ optionals presentationSupport
+    ([ "--prefix PATH : ${libreoffice-unwrapped}/bin" ]
+      ++ map wrapSetVar [ "URE_BOOTSTRAP" "UNO_PATH" ]);
+
+  installPhase = ''
+    install -D openlp.py $out/bin/openlp
+  '';
+
+  preFixup = ''
+    wrapPythonPrograms
+  '';
+
+  meta = baseLib.meta // {
+    hydraPlatforms = [ ]; # this is only the wrapper; baseLib gets built
+  };
+
+  passthru = {
+    inherit baseLib;
+  };
+}

pkgs/applications/misc/openlp/lib.nix

···
+# This file contains the base package, some of which is compiled.
+# Runtime glue to optinal runtime dependencies is in 'default.nix'.
+{ fetchurl, lib, qt5
+
+# python deps
+, python, buildPythonPackage
+, alembic, beautifulsoup4, chardet, lxml, Mako, pyenchant
+, pyqt5_with_qtwebkit, pyxdg, sip, sqlalchemy, sqlalchemy_migrate
+}:
+
+buildPythonPackage rec {
+  pname = "openlp";
+  version = "2.4.6";
+
+  src = fetchurl {
+    url = "https://get.openlp.org/${version}/OpenLP-${version}.tar.gz";
+    sha256 = "f63dcf5f1f8a8199bf55e806b44066ad920d26c9cf67ae432eb8cdd1e761fc30";
+  };
+
+  doCheck = false;
+  # FIXME: checks must be disabled because they are lacking the qt env.
+  #        They fail like this, even if built and wrapped with all Qt and
+  #        runtime dependencies:
+  #
+  #     running install tests
+  #     qt.qpa.plugin: Could not find the Qt platform plugin "xcb" in ""
+  #     This application failed to start because no Qt platform plugin could be initialized. Reinstalling the application may fix this problem.
+  #
+  #     Available platform plugins are: wayland-egl, wayland, wayland-xcomposite-egl, wayland-xcomposite-glx.
+  #
+  # See also https://discourse.nixos.org/t/qt-plugin-path-unset-in-test-phase/
+
+  #checkInputs = [ mock nose ];
+  nativeBuildInputs = [ qt5.qttools ];
+  propagatedBuildInputs = [
+    alembic
+    beautifulsoup4
+    chardet
+    lxml
+    Mako
+    pyenchant
+    pyqt5_with_qtwebkit
+    pyxdg
+    sip
+    sqlalchemy
+    sqlalchemy_migrate
+  ];
+
+  prePatch = ''
+    echo 'from vlc import *' > openlp/core/ui/media/vendor/vlc.py
+  '';
+
+  dontWrapQtApps = true;
+  dontWrapGApps = true;
+  postInstall = ''
+    ( # use subshell because of cd
+      tdestdir="$out/i18n"
+      mkdir -p "$tdestdir"
+      cd ./resources/i18n
+      for file in *.ts; do
+          lconvert -i "$file" -o "$tdestdir/''${file%%ts}qm"
+      done
+    )
+  '';
+
+  preFixup = ''
+    rm -r $out/${python.sitePackages}/tests
+    rm -r $out/bin
+  '';
+
+  meta = with lib; {
+    description = "Free church presentation software";
+    homepage = "https://openlp.org/";
+    downloadPage = "https://openlp.org/#downloads";
+    platforms = platforms.unix;
+    license = licenses.gpl2Only;
+    maintainers = [ maintainers.jorsn ];
+
+    longDescription = ''
+      OpenLP is a free church presentation software.
+
+      Features:
+
+      * Cross platform between Linux, Windows, OS X and FreeBSD
+      * Display songs, Bible verses, presentations, images, audio and video
+      * Control OpenLP remotely via the Android remote, iOS remote or mobile web browser
+      * Quickly and easily import songs from other popular presentation packages
+      * Easy enough to use to get up and running in less than 10 minutes
+
+      Remark: This pkg only supports sqlite dbs. If you wish to have support for
+            mysql or postgresql dbs, or Jenkins, please contact the maintainer.
+
+      Bugs which affect this software packaged in Nixpkgs:
+
+      1. The package must disable checks, because they are lacking the qt env.
+         (see pkg source and https://discourse.nixos.org/t/qt-plugin-path-unset-in-test-phase/)
+      2. There is a segfault on exit. Not a real problem, according to debug log, everything
+         shuts down correctly. Maybe related to https://forums.openlp.org/discussion/3620/crash-on-exit.
+         Plan: Wait for OpenLP-3, since it is already in beta 1
+         (2021-02-09; news: https://openlp.org/blog/).
+    '';
+  };
+}

pkgs/applications/misc/openring/default.nix

···
+{ buildGoModule, fetchFromSourcehut, lib }:
+
+buildGoModule rec {
+  pname = "openring";
+  version = "unstable-2021-04-03";
+
+  src = fetchFromSourcehut {
+    owner = "~sircmpwn";
+    repo = pname;
+    rev = "f13edb5dfd882ce608d61cf6b6740650ce9d84a3";
+    sha256 = "sha256-Z65V77JZ9jCzBg7T2+d5Agxxd+MV2R7nYcLedYP5eOE=";
+  };
+
+  vendorSha256 = "sha256-BbBTmkGyLrIWphXC+dBaHaVzHuXRZ+4N/Jt2k3nF7Z4=";
+
+  # The package has no tests.
+  doCheck = false;
+
+  meta = with lib; {
+    description = "A webring for static site generators";
+    homepage = "https://git.sr.ht/~sircmpwn/openring";
+    license = licenses.gpl3Only;
+    maintainers = with maintainers; [ sumnerevans ];
+  };
+}

pkgs/applications/misc/sc-im/default.nix

···
 , makeWrapper
 , pkg-config
 , which
-, yacc
+, bison
 , gnuplot
 , libxls
 , libxml2
···
     makeWrapper
     pkg-config
     which
-    yacc
+    bison
   ];
 
   buildInputs = [

pkgs/applications/misc/tellico/default.nix

···
 { lib
 , fetchurl
 , mkDerivation
-, libkcddb
-, kinit
-, kdelibs4support
-, solid
-, kxmlgui
+, cmake
+, exempi
+, extra-cmake-modules
 , karchive
+, kdoctools
 , kfilemetadata
 , khtml
+, kitemmodels
 , knewstuff
+, kxmlgui
+, libcdio
+, libkcddb
 , libksane
-, cmake
-, exempi
-, extra-cmake-modules
-, libcdio
-, poppler
 , makeWrapper
-, kdoctools
+, poppler
+, qtcharts
+, qtwebengine
+, solid
 , taglib
 }:
 
 mkDerivation rec {
-  name = "tellico";
-  version = "3.3.3";
+  pname = "tellico";
+  version = "3.4";
 
   src = fetchurl {
     # version 3.3.0 just uses 3.3 in its name
···
       "https://tellico-project.org/files/tellico-${version}.tar.xz"
       "https://tellico-project.org/files/tellico-${lib.versions.majorMinor version}.tar.xz"
     ];
-    sha256 = "sha256-9cdbUTa2Mt3/yNylOSdGjgDETD74sR0dU4C58uW0Y6o=";
+    sha256 = "sha256-YXMJrAkfehe3ox4WZ19igyFbXwtjO5wxN3bmgP01jPs=";
   };
 
   nativeBuildInputs = [
···
 
   buildInputs = [
     exempi
-    extra-cmake-modules
     karchive
-    libkcddb
-    kdelibs4support
     kfilemetadata
     khtml
+    kitemmodels
     knewstuff
     kxmlgui
     libcdio
+    libkcddb
     libksane
     poppler
+    qtcharts
+    qtwebengine
     solid
     taglib
   ];

pkgs/applications/networking/appgate-sdp/default.nix

···
 , glib
 , gtk3
 , icu
-, iproute
+, iproute2
 , krb5
 , lib
 , mesa
···
       patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" --set-rpath "$ORIGIN:$out/opt/appgate/service/:$out/opt/appgate/:${rpath}" $binary
     done
 
-    wrapProgram $out/opt/appgate/appgate-driver --prefix PATH : ${lib.makeBinPath [ iproute networkmanager dnsmasq ]}
+    wrapProgram $out/opt/appgate/appgate-driver --prefix PATH : ${lib.makeBinPath [ iproute2 networkmanager dnsmasq ]}
     wrapProgram $out/opt/appgate/linux/set_dns --set PYTHONPATH $PYTHONPATH
   '';
   meta = with lib; {

pkgs/applications/networking/browsers/chromium/common.nix

···
 , libusb1, pciutils, nss, re2
 
 , python2Packages, perl, pkg-config
-, nspr, systemd, kerberos
+, nspr, systemd, libkrb5
 , util-linux, alsaLib
 , bison, gperf
 , glib, gtk3, dbus-glib
···
     buildInputs = defaultDependencies ++ [
       nspr nss systemd
       util-linux alsaLib
-      bison gperf kerberos
+      bison gperf libkrb5
       glib gtk3 dbus-glib
       libXScrnSaver libXcursor libXtst libxshmfence libGLU libGL
       pciutils protobuf speechd libXdamage at-spi2-core

pkgs/applications/networking/browsers/elinks/default.nix

···
 { lib, stdenv, fetchFromGitHub, fetchpatch, ncurses, xlibsWrapper, bzip2, zlib
-, brotli, zstd, lzma, openssl, autoreconfHook, gettext, pkg-config, libev
+, brotli, zstd, xz, openssl, autoreconfHook, gettext, pkg-config, libev
 , gpm, libidn, tre, expat
 , # Incompatible licenses, LGPLv3 - GPLv2
   enableGuile        ? false,                                         guile ? null
···
   };
 
   buildInputs = [
-    ncurses xlibsWrapper bzip2 zlib brotli zstd lzma
+    ncurses xlibsWrapper bzip2 zlib brotli zstd xz
     openssl libidn tre expat libev
   ]
     ++ lib.optional stdenv.isLinux gpm

pkgs/applications/networking/browsers/firefox-bin/default.nix

···
 , glibc
 , gtk2
 , gtk3
-, kerberos
+, libkrb5
 , libX11
 , libXScrnSaver
 , libxcb
···
       glibc
       gtk2
       gtk3
-      kerberos
+      libkrb5
       mesa
       libX11
       libXScrnSaver

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

···
 , gtk3Support ? true, gtk2, gtk3, wrapGAppsHook
 , waylandSupport ? true, libxkbcommon
 , ltoSupport ? (stdenv.isLinux && stdenv.is64bit), overrideCC, buildPackages
-, gssSupport ? true, kerberos
+, gssSupport ? true, libkrb5
 , pipewireSupport ? waylandSupport && webrtcSupport, pipewire
 
 ## privacy-related options
···
   ++ lib.optional  alsaSupport alsaLib
   ++ lib.optional  pulseaudioSupport libpulseaudio # only headers are needed
   ++ lib.optional  gtk3Support gtk3
-  ++ lib.optional  gssSupport kerberos
+  ++ lib.optional  gssSupport libkrb5
   ++ lib.optional  waylandSupport libxkbcommon
   ++ lib.optional  pipewireSupport pipewire
   ++ lib.optional  (lib.versionAtLeast ffversion "82") gnum4

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

···
 , tridactyl-native
 , fx_cast_bridge
 , udev
-, kerberos
+, libkrb5
 , libva
 , mesa # firefox wants gbm for drm+dmabuf
 }:
···
       libs =   lib.optionals stdenv.isLinux [ udev libva mesa libnotify xorg.libXScrnSaver ]
             ++ lib.optional (pipewireSupport && lib.versionAtLeast version "83") pipewire
             ++ lib.optional ffmpegSupport ffmpeg
-            ++ lib.optional gssSupport kerberos
+            ++ lib.optional gssSupport libkrb5
             ++ lib.optional useGlvnd libglvnd
             ++ lib.optionals (cfg.enableQuakeLive or false)
             (with xorg; [ stdenv.cc libX11 libXxf86dga libXxf86vm libXext libXt alsaLib zlib ])

pkgs/applications/networking/browsers/google-chrome/default.nix

···
 , libXcursor, libXext, libXfixes, libXrender, libXScrnSaver, libXcomposite, libxcb
 , alsaLib, libXdamage, libXtst, libXrandr, libxshmfence, expat, cups
 , dbus, gtk3, gdk-pixbuf, gcc-unwrapped, at-spi2-atk, at-spi2-core
-, kerberos, libdrm, mesa
+, libkrb5, libdrm, mesa
 , libxkbcommon, wayland # ozone/wayland
 
 # Command line programs
···
     liberation_ttf curl util-linux xdg-utils wget
     flac harfbuzz icu libpng opusWithCustomModes snappy speechd
     bzip2 libcap at-spi2-atk at-spi2-core
-    kerberos libdrm mesa coreutils
+    libkrb5 libdrm mesa coreutils
     libxkbcommon wayland
   ] ++ optional pulseSupport libpulseaudio
     ++ optional libvaSupport libva

pkgs/applications/networking/cluster/k3s/default.nix

···
 , makeWrapper
 , socat
 , iptables
-, iproute
+, iproute2
 , bridge-utils
 , conntrack-tools
 , buildGoPackage
···
     kmod
     socat
     iptables
-    iproute
+    iproute2
     bridge-utils
     ethtool
     util-linux

pkgs/applications/networking/cluster/openshift/default.nix

···
 { lib, fetchFromGitHub, buildGoPackage, which, go-bindata, rsync, util-linux
-, coreutils, kerberos, ncurses, clang, installShellFiles
+, coreutils, libkrb5, ncurses, clang, installShellFiles
 , components ? [
   "cmd/oc"
   "cmd/openshift"
···
 
   goPackagePath = "github.com/openshift/origin";
 
-  buildInputs = [ kerberos ncurses ];
+  buildInputs = [ libkrb5 ncurses ];
 
   nativeBuildInputs = [ which rsync go-bindata clang installShellFiles ];
 

pkgs/applications/networking/cluster/qbec/default.nix

···
 
 buildGoModule rec {
   pname = "qbec";
-  version = "0.14.1";
+  version = "0.14.2";
 
   src = fetchFromGitHub {
     owner = "splunk";
     repo = "qbec";
     rev = "v${version}";
-    sha256 = "sha256-+CzY/ifH+U3I36uHXyO2FSkPCz+SWRpSPnxfd2LHHhY=";
+    sha256 = "sha256-F5xnW9069Xrl6isvmeYtfTZUZSiSq47HLs5/p3HCf6E=";
   };
 
   vendorSha256 = "sha256-wtpXqIixjRYYSIPe43Q5627g6mu05WdvwCi9cXVgCBs=";

pkgs/applications/networking/cluster/velero/default.nix

···
 
 buildGoModule rec {
   pname = "velero";
-  version = "1.5.3";
+  version = "1.5.4";
 
   src = fetchFromGitHub {
     rev = "v${version}";
     owner = "vmware-tanzu";
     repo = "velero";
-    sha256 = "sha256-DZ6phJxc8n9LCSsER09K3j+pUJxkYrBZQaI4h+bcV94=";
+    sha256 = "sha256-YHBqIM3NV2L13w9WCzldUWmdBMec7ZndzYgGHblS8Dg=";
   };
 
   buildFlagsArray = ''

pkgs/applications/networking/compactor/default.nix

···
 { autoconf, automake, boost, cbor-diag, cddl, fetchFromGitHub, file, libctemplate, libmaxminddb
-, libpcap, libtins, libtool, lzma, openssl, pkg-config, lib, stdenv, tcpdump, wireshark-cli
+, libpcap, libtins, libtool, xz, openssl, pkg-config, lib, stdenv, tcpdump, wireshark-cli
 }:
 
 stdenv.mkDerivation rec {
···
     libpcap
     openssl
     libtins
-    lzma
+    xz
     libctemplate
     libmaxminddb
   ];

pkgs/applications/networking/firehol/default.nix

···
 { stdenv, lib, fetchFromGitHub, pkgs
-, autoconf, automake, curl, iprange, iproute, ipset, iptables, iputils
+, autoconf, automake, curl, iprange, iproute2, ipset, iptables, iputils
 , kmod, nettools, procps, tcpdump, traceroute, util-linux, whois
 
 # If true, just install FireQOS without FireHOL
···
 
   nativeBuildInputs = [ autoconf automake ];
   buildInputs = [
-    curl iprange iproute ipset iptables iputils kmod
+    curl iprange iproute2 ipset iptables iputils kmod
     nettools procps tcpdump traceroute util-linux whois
   ];
 

pkgs/applications/networking/ike/default.nix

···
 { lib, stdenv, fetchurl, fetchpatch, cmake, openssl, libedit, flex, bison, qt4, makeWrapper
-, gcc, nettools, iproute, linuxHeaders }:
+, gcc, nettools, iproute2, linuxHeaders }:
 
 # NOTE: use $out/etc/iked.conf as sample configuration and also set: dhcp_file "/etc/iked.dhcp";
 # launch with "iked -f /etc/iked.conf"
···
   ];
 
   nativeBuildInputs = [ cmake flex bison makeWrapper ];
-  buildInputs = [ openssl libedit qt4 nettools iproute ];
+  buildInputs = [ openssl libedit qt4 nettools iproute2 ];
 
   postPatch = ''
     # fix build with bison3

pkgs/applications/networking/instant-messengers/telegram/kotatogram-desktop/default.nix

···
 { mkDerivation, lib, fetchFromGitHub, pkg-config, python3, cmake, ninja
 , qtbase, qtimageformats, libdbusmenu, hunspell, xdg-utils, ffmpeg_3, openalSoft
-, lzma, lz4, xxHash, zlib, minizip, openssl, libtgvoip, microsoft_gsl, tl-expected
+, xz, lz4, xxHash, zlib, minizip, openssl, libtgvoip, microsoft_gsl, tl-expected
 , range-v3
 }:
 
···
   nativeBuildInputs = [ pkg-config python3 cmake ninja ];
 
   buildInputs = [
-    qtbase qtimageformats ffmpeg_3 openalSoft lzma lz4 xxHash libdbusmenu
+    qtbase qtimageformats ffmpeg_3 openalSoft xz lz4 xxHash libdbusmenu
     zlib minizip openssl hunspell libtgvoip microsoft_gsl tl-expected range-v3
   ];
 

pkgs/applications/networking/instant-messengers/zoom-us/default.nix

···
 assert pulseaudioSupport -> libpulseaudio != null;
 
 let
-  version = "5.5.7938.0228";
+  version = "5.6.13632.0328";
   srcs = {
     x86_64-linux = fetchurl {
       url = "https://zoom.us/client/${version}/zoom_x86_64.pkg.tar.xz";
-      sha256 = "KM8o2tgIn0lecOM4gKdTOdk/zsohlFqtNX+ca/S6FGY=";
+      sha256 = "0nskpg3rbv40jcbih95sfdr0kfv5hjv50z9jdz1cddl8v7hbqg71";
     };
   };
 

pkgs/applications/networking/mailreaders/alpine/default.nix

···
-{lib, stdenv, fetchurl, ncurses, tcl, openssl, pam, kerberos
+{lib, stdenv, fetchurl, ncurses, tcl, openssl, pam, libkrb5
 , openldap
 }:
 
···
   };
 
   buildInputs = [
-    ncurses tcl openssl pam kerberos openldap
+    ncurses tcl openssl pam libkrb5 openldap
   ];
 
   hardeningDisable = [ "format" ];

pkgs/applications/networking/mailreaders/mutt/default.nix

···
 , cyrus_sasl ? null
 , gnupg ? null
 , gpgme ? null
-, kerberos ? null
+, libkrb5 ? null
 , headerCache  ? true
 , sslSupport   ? true
 , saslSupport  ? true
···
     [ ncurses which perl ]
     ++ optional headerCache  gdbm
     ++ optional sslSupport   openssl
-    ++ optional gssSupport   kerberos
+    ++ optional gssSupport   libkrb5
     ++ optional saslSupport  cyrus_sasl
     ++ optional gpgmeSupport gpgme;
 

pkgs/applications/networking/mailreaders/neomutt/default.nix

···
 { lib, stdenv, fetchFromGitHub, gettext, makeWrapper, tcl, which
-, ncurses, perl , cyrus_sasl, gss, gpgme, kerberos, libidn, libxml2, notmuch, openssl
+, ncurses, perl , cyrus_sasl, gss, gpgme, libkrb5, libidn, libxml2, notmuch, openssl
 , lmdb, libxslt, docbook_xsl, docbook_xml_dtd_42, w3m, mailcap, sqlite, zlib
 }:
 
···
   };
 
   buildInputs = [
-    cyrus_sasl gss gpgme kerberos libidn ncurses
+    cyrus_sasl gss gpgme libkrb5 libidn ncurses
     notmuch openssl perl lmdb
     mailcap sqlite
   ];

pkgs/applications/networking/mailreaders/thunderbird-bin/68.nix

···
 , glibc
 , gtk2
 , gtk3
-, kerberos
+, libkrb5
 , libX11
 , libXScrnSaver
 , libXcomposite
···
       glibc
       gtk2
       gtk3
-      kerberos
+      libkrb5
       libX11
       libXScrnSaver
       libXcomposite

pkgs/applications/networking/mailreaders/thunderbird-bin/default.nix

···
 , gpgme
 , gtk2
 , gtk3
-, kerberos
+, libkrb5
 , libcanberra
 , libGL
 , libGLU
···
       glibc
       gtk2
       gtk3
-      kerberos
+      libkrb5
       libX11
       libXScrnSaver
       libXcomposite

pkgs/applications/networking/remote/aws-workspaces/default.nix

···
 { stdenv, lib
 , makeWrapper, dpkg, fetchurl, autoPatchelfHook
-, curl, kerberos, lttng-ust, libpulseaudio, gtk3, openssl_1_1, icu, webkitgtk, librsvg, gdk-pixbuf, libsoup, glib-networking
+, curl, libkrb5, lttng-ust, libpulseaudio, gtk3, openssl_1_1, icu, webkitgtk, librsvg, gdk-pixbuf, libsoup, glib-networking
 }:
 
 stdenv.mkDerivation rec {
···
 
   buildInputs = [
     stdenv.cc.cc.lib
-    kerberos
+    libkrb5
     curl
     lttng-ust
     libpulseaudio

pkgs/applications/networking/remote/x2goserver/default.nix

···
 { stdenv, lib, fetchurl, perlPackages, makeWrapper, perl, which, nx-libs
 , util-linux, coreutils, glibc, gawk, gnused, gnugrep, findutils, xorg
-, nettools, iproute, bc, procps, psmisc, lsof, pwgen, openssh, sshfs, bash
+, nettools, iproute2, bc, procps, psmisc, lsof, pwgen, openssh, sshfs, bash
 }:
 
 let
···
 
   binaryDeps = [
     perlEnv which nx-libs util-linux coreutils glibc.bin gawk gnused gnugrep
-    findutils nettools iproute bc procps psmisc lsof pwgen openssh sshfs
+    findutils nettools iproute2 bc procps psmisc lsof pwgen openssh sshfs
     xorg.xauth xorg.xinit xorg.xrandr xorg.xmodmap xorg.xwininfo xorg.fontutil
     xorg.xkbcomp xorg.setxkbmap
   ];

pkgs/applications/networking/sniffers/wireshark/default.nix

···
     install -Dm644 ../image/wsicon.svg $out/share/icons/wireshark.svg
     mkdir $dev/include/{epan/{wmem,ftypes,dfilter},wsutil,wiretap} -pv
 
-    cp config.h $dev/include/
+    cp config.h $dev/include/wireshark/
     cp ../ws_*.h $dev/include
     cp ../epan/*.h $dev/include/epan/
     cp ../epan/wmem/*.h $dev/include/epan/wmem/

pkgs/applications/office/wpsoffice/default.nix

···
 , libtool
 , libuuid
 , libxml2
-, lzma
+, xz
 , nspr
 , nss
 , openssl
···
     libuuid
     libxcb
     libxml2
-    lzma
+    xz
     nspr
     nss
     openssl

pkgs/applications/radio/gnss-sdr/default.nix

···
 , cmake
 , gmp
 , glog
-, gmock
+, gtest
 , openssl
 , gflags
 , gnuradio3_8
···
     armadillo
     gnuradio3_8.unwrapped.boost
     glog
-    gmock
+    gtest
     openssl
     gflags
     orc

pkgs/applications/radio/multimon-ng/default.nix

···
-{ lib, stdenv, fetchFromGitHub, qt4, qmake4Hook, libpulseaudio }:
-let
-  version = "1.1.9";
-in
-stdenv.mkDerivation {
+{ lib, stdenv, fetchFromGitHub, cmake, libpulseaudio, libX11 }:
+
+stdenv.mkDerivation rec {
   pname = "multimon-ng";
-  inherit version;
+  version = "1.1.9";
 
   src = fetchFromGitHub {
     owner = "EliasOenal";
···
     sha256 = "01716cfhxfzsab9zjply9giaa4nn4b7rm3p3vizrwi7n253yiwm2";
   };
 
-  buildInputs = [ qt4 libpulseaudio ];
+  buildInputs = [ libpulseaudio libX11 ];
 
-  nativeBuildInputs = [ qmake4Hook ];
-
-  qmakeFlags = [ "multimon-ng.pro" ];
-
-  installPhase = ''
-    mkdir -p $out/bin
-    cp multimon-ng $out/bin
-  '';
+  nativeBuildInputs = [ cmake ];
 
   meta = with lib; {
     description = "Multimon is a digital baseband audio protocol decoder";
···
     homepage = "https://github.com/EliasOenal/multimon-ng";
     license = licenses.gpl2Only;
     platforms = platforms.linux;
-    maintainers = [ maintainers.markuskowa ];
+    maintainers = with maintainers; [ markuskowa ];
   };
 }

pkgs/applications/science/biology/bcftools/default.nix

···
-{ lib, stdenv, fetchurl, htslib, zlib, bzip2, lzma, curl, perl, python3, bash }:
+{ lib, stdenv, fetchurl, htslib, zlib, bzip2, xz, curl, perl, python3, bash }:
 
 stdenv.mkDerivation rec {
   pname = "bcftools";
···
     python3
   ];
 
-  buildInputs = [ htslib zlib bzip2 lzma curl ];
+  buildInputs = [ htslib zlib bzip2 xz curl ];
 
   strictDeps = true;
 

pkgs/applications/science/biology/bedtools/default.nix

···
-{lib, stdenv, fetchFromGitHub, zlib, python3, bzip2, lzma}:
+{lib, stdenv, fetchFromGitHub, zlib, python3, bzip2, xz}:
 
 stdenv.mkDerivation rec {
   pname = "bedtools";
···
     python3
   ];
 
-  buildInputs = [ zlib bzip2 lzma ];
+  buildInputs = [ zlib bzip2 xz ];
+
   cxx = if stdenv.cc.isClang then "clang++" else "g++";
   cc = if stdenv.cc.isClang then "clang" else "gcc";
   buildPhase = "make prefix=$out SHELL=${stdenv.shell} CXX=${cxx} CC=${cc} -j $NIX_BUILD_CORES";

pkgs/applications/science/biology/delly/default.nix

···
-{ lib, stdenv, fetchpatch, fetchFromGitHub, htslib, zlib, bzip2, lzma, ncurses, boost }:
+{ lib, stdenv, fetchpatch, fetchFromGitHub, htslib, zlib, bzip2, xz, ncurses, boost }:
 
 stdenv.mkDerivation rec {
   pname = "delly";
···
       sha256 = "sha256-DWwC35r8cQbePUzppkFQlev0YZdxk2+BSrNTW/DOY3M=";
   };
 
-  buildInputs = [ zlib htslib bzip2 lzma ncurses boost ];
+  buildInputs = [ zlib htslib bzip2 xz ncurses boost ];
 
   EBROOTHTSLIB = htslib;
 

pkgs/applications/science/biology/freebayes/default.nix

···
-{ lib, stdenv, fetchFromGitHub, zlib, bzip2, lzma }:
+{ lib, stdenv, fetchFromGitHub, zlib, bzip2, xz }:
 
 stdenv.mkDerivation rec {
   pname = "freebayes";
···
     fetchSubmodules = true;
   };
 
-  buildInputs = [ zlib bzip2 lzma ];
+  buildInputs = [ zlib bzip2 xz ];
 
   installPhase = ''
     install -vD bin/freebayes bin/bamleftalign scripts/* -t $out/bin

pkgs/applications/science/biology/kent/default.nix

···
 , libuuid
 , zlib
 , bzip2
-, lzma
+, xz
 , openssl
 , curl
 , libmysqlclient
···
     sha256 = "0l5lmqqc6sqkf4hyk3z4825ly0vdlj5xdfad6zd0708cb1v81nbx";
   };
 
-  buildInputs = [ libpng libuuid zlib bzip2 lzma openssl curl libmysqlclient ];
+  buildInputs = [ libpng libuuid zlib bzip2 xz openssl curl libmysqlclient ];
 
   patchPhase = ''
     substituteInPlace ./src/checkUmask.sh \

pkgs/applications/science/biology/meme-suite/default.nix

···
+{ lib, stdenv, fetchurl, python3, perl, glibc, zlib }:
+
+stdenv.mkDerivation rec {
+  pname = "meme-suite";
+  version = "5.1.1";
+
+  src = fetchurl {
+    url = "https://meme-suite.org/meme-software/${version}/meme-${version}.tar.gz";
+    sha256 = "38d73d256d431ad4eb7da2c817ce56ff2b4e26c39387ff0d6ada088938b38eb5";
+  };
+
+  buildInputs = [ zlib ];
+  nativeBuildInputs = [ perl python3 ];
+
+  meta = with lib; {
+    description = "Motif-based sequence analysis tools";
+    license = licenses.unfree;
+    maintainers = with maintainers; [ gschwartz ];
+    platforms = platforms.linux;
+  };
+}

pkgs/applications/science/biology/octopus/default.nix

···
-{lib, stdenv, fetchpatch, fetchFromGitHub, cmake, boost, gmp, htslib, zlib, lzma, pkg-config}:
+{lib, stdenv, fetchpatch, fetchFromGitHub, cmake, boost, gmp, htslib, zlib, xz, pkg-config}:
 
 stdenv.mkDerivation rec {
   pname = "octopus";
···
   ];
 
   nativeBuildInputs = [ cmake pkg-config ];
-  buildInputs = [ boost gmp htslib zlib lzma ];
+  buildInputs = [ boost gmp htslib zlib xz ];
 
   postInstall = ''
     mkdir $out/bin

pkgs/applications/science/biology/svaba/default.nix

···
-{ lib, stdenv, zlib, bzip2, lzma, fetchFromGitHub } :
+{ lib, stdenv, zlib, bzip2, xz, fetchFromGitHub } :
 
 stdenv.mkDerivation rec {
   version = "1.1.0";
···
     fetchSubmodules = true;
   };
 
-  buildInputs = [ zlib bzip2 lzma ];
+  buildInputs = [ zlib bzip2 xz ];
 
   installPhase = ''
     runHook preInstall

pkgs/applications/science/electronics/tkgate/1.x.nix

···
-{ lib, stdenv, fetchurl, tcl, tk, libX11, glibc, which, yacc, flex, imake, xorgproto, gccmakedep }:
+{ lib, stdenv, fetchurl, tcl, tk, libX11, glibc, which, bison, flex, imake, xorgproto, gccmakedep }:
 
 let
   libiconvInc = lib.optionalString stdenv.isLinux "${glibc.dev}/include";
···
     sha256 = "1pqywkidfpdbj18i03h97f4cimld4fb3mqfy8jjsxs12kihm18fs";
   };
 
-  nativeBuildInputs = [ which yacc flex imake gccmakedep ];
+  nativeBuildInputs = [ which bison flex imake gccmakedep ];
   buildInputs = [ tcl tk libX11 xorgproto ];
   dontUseImakeConfigure = true;
 

pkgs/applications/science/machine-learning/shogun/default.nix

···
 { stdenv, lib, fetchFromGitHub, fetchpatch, fetchurl, cmake, ctags, swig
 # data, compression
-, bzip2, curl, hdf5, json_c, lzma, lzo, protobuf, snappy
+, bzip2, curl, hdf5, json_c, xz, lzo, protobuf, snappy
 # maths
 , blas, lapack, eigen, nlopt, lp_solve, colpack, glpk
 # libraries
···
 
   nativeBuildInputs = [ cmake ];
   buildInputs = with lib; [
-      blas lapack bzip2 colpack curl ctags eigen hdf5 json_c lp_solve lzma lzo
+      blas lapack bzip2 colpack curl ctags eigen hdf5 json_c lp_solve xz lzo
       protobuf nlopt snappy swig (libarchive.dev) libxml2 lapack glpk
     ]
     ++ optionals (pythonSupport) (with pythonPackages; [ python ply numpy ])

pkgs/applications/science/misc/root/5.nix

···
 { lib, stdenv, fetchurl, fetchpatch, cmake, pcre, pkg-config, python2
-, libX11, libXpm, libXft, libXext, libGLU, libGL, zlib, libxml2, lz4, lzma, gsl_1, xxHash
+, libX11, libXpm, libXft, libXext, libGLU, libGL, zlib, libxml2, lz4, xz, gsl_1, xxHash
 , Cocoa, OpenGL, noSplash ? false }:
 
 stdenv.mkDerivation rec {
···
   };
 
   nativeBuildInputs = [ cmake pkg-config ];
-  buildInputs = [ pcre python2 zlib libxml2 lz4 lzma gsl_1 xxHash ]
+  buildInputs = [ pcre python2 zlib libxml2 lz4 xz gsl_1 xxHash ]
     ++ lib.optionals (!stdenv.isDarwin) [ libX11 libXpm libXft libXext libGLU libGL ]
     ++ lib.optionals (stdenv.isDarwin) [ Cocoa OpenGL ]
     ;

pkgs/applications/science/misc/root/default.nix

···
 { stdenv, lib, fetchurl, makeWrapper, cmake, ftgl, gl2ps, glew, gsl, llvm_5
-, libX11, libXpm, libXft, libXext, libGLU, libGL, libxml2, lz4, lzma, pcre
+, libX11, libXpm, libXft, libXext, libGLU, libGL, libxml2, lz4, xz, pcre
 , pkg-config, python, xxHash, zlib, zstd
 , libAfterImage, giflib, libjpeg, libtiff, libpng
 , Cocoa, OpenGL, noSplash ? false }:
 
 stdenv.mkDerivation rec {
   pname = "root";
-  version = "6.22.06";
+  version = "6.22.08";
 
   src = fetchurl {
     url = "https://root.cern.ch/download/root_v${version}.source.tar.gz";
-    sha256 = "0mqvj42nax0bmz8h83jjlwjm3xxjy1n0n10inc8csip9ly28fs64";
+    sha256 = "0vrgi83hrw4n9zgx873fn4ba3vk54slrwk1cl4cc4plgxzv1y1kg";
   };
 
   nativeBuildInputs = [ makeWrapper cmake pkg-config ];
-  buildInputs = [ ftgl gl2ps glew pcre zlib zstd llvm_5 libxml2 lz4 lzma gsl xxHash libAfterImage giflib libjpeg libtiff libpng python.pkgs.numpy ]
+  buildInputs = [ ftgl gl2ps glew pcre zlib zstd llvm_5 libxml2 lz4 xz gsl xxHash libAfterImage giflib libjpeg libtiff libpng python.pkgs.numpy ]
     ++ lib.optionals (!stdenv.isDarwin) [ libX11 libXpm libXft libXext libGLU libGL ]
     ++ lib.optionals (stdenv.isDarwin) [ Cocoa OpenGL ]
     ;

pkgs/applications/search/recoll/default.nix

···
 , withGui ? true
 }:
 
-assert stdenv.hostPlatform.system != "powerpc-linux";
-
 mkDerivation rec {
   pname = "recoll";
   version = "1.28.6";

pkgs/applications/version-management/monotone-viz/default.nix

···
 { lib, stdenv, fetchurl, ocamlPackages, gnome2, pkg-config, makeWrapper, glib
-, libtool, libpng, yacc, expat, fontconfig, gd, pango, libjpeg, libwebp, xlibsWrapper, libXaw
+, libtool, libpng, bison, expat, fontconfig, gd, pango, libjpeg, libwebp, xlibsWrapper, libXaw
 }:
 # We need an old version of Graphviz for format compatibility reasons.
 # This version is vulnerable, but monotone-viz will never feed it bad input.
 let graphviz_2_0 = import ./graphviz-2.0.nix {
       inherit lib stdenv fetchurl pkg-config xlibsWrapper libpng libjpeg expat libXaw
-        yacc libtool fontconfig pango gd libwebp;
+        bison libtool fontconfig pango gd libwebp;
     }; in
 let inherit (gnome2) libgnomecanvas; in
 let inherit (ocamlPackages) ocaml lablgtk camlp4; in

pkgs/applications/version-management/monotone-viz/graphviz-2.0.nix

···
 { lib, stdenv, fetchurl, pkg-config, xlibsWrapper, libpng, libjpeg, expat, libXaw
-, yacc, libtool, fontconfig, pango, gd, libwebp
+, bison, libtool, fontconfig, pango, gd, libwebp
 }:
 
 stdenv.mkDerivation rec {
···
 
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [
-    xlibsWrapper libpng libjpeg expat libXaw yacc
+    xlibsWrapper libpng libjpeg expat libXaw bison
     libtool fontconfig pango gd libwebp
   ];
 

pkgs/applications/video/handbrake/default.nix

···
 
 { stdenv, lib, fetchFromGitHub,
   # Main build tools
-  pkg-config, autoconf, automake, libtool, m4, lzma, python3,
+  pkg-config, autoconf, automake, libtool, m4, xz, python3,
   numactl,
   # Processing, video codecs, containers
   ffmpeg-full, nv-codec-headers, libogg, x264, x265, libvpx, libtheora, dav1d,
···
     ffmpeg-full libogg libtheora x264 x265 libvpx dav1d
     libopus lame libvorbis a52dec speex libsamplerate
     libiconv fribidi fontconfig freetype libass jansson libxml2 harfbuzz
-    libdvdread libdvdnav libdvdcss libbluray lzma
+    libdvdread libdvdnav libdvdcss libbluray xz
   ] ++ lib.optional (!stdenv.isDarwin) numactl
   ++ lib.optionals useGtk [
     glib gtk3 libappindicator-gtk3 libnotify

pkgs/applications/video/kodi-packages/vfs-libarchive/default.nix

···
-{ lib, rel, buildKodiBinaryAddon, fetchFromGitHub, libarchive, lzma, bzip2, zlib, lz4, lzo, openssl }:
+{ lib, rel, buildKodiBinaryAddon, fetchFromGitHub, libarchive, xz, bzip2, zlib, lz4, lzo, openssl }:
 buildKodiBinaryAddon rec {
   pname = namespace;
   namespace = "vfs.libarchive";
···
     sha256 = "1q62p1i6rvqk2zv6f1cpffkh95lgclys2xl4dwyhj3acmqdxd9i5";
   };
 
-  extraBuildInputs = [ libarchive lzma bzip2 zlib lz4 lzo openssl ];
+  extraBuildInputs = [ libarchive xz bzip2 zlib lz4 lzo openssl ];
 
   meta = with lib; {
     description = "LibArchive Virtual Filesystem add-on for Kodi";

pkgs/applications/video/kodi/packages.nix

···
+{ lib, stdenv, callPackage, fetchFromGitHub
+, cmake, kodi, libcec_platform, tinyxml, pugixml
+, steam, udev, libusb1, jsoncpp, libhdhomerun, zlib
+, python3Packages, expat, glib, nspr, nss, openssl
+, libssh, libarchive, xz, bzip2, lz4, lzo }:
+
+with lib;
+
+let self = rec {
+
+  addonDir = "/share/kodi/addons";
+  rel = "Matrix";
+
+  inherit kodi;
+
+  # Convert derivation to a kodi module. Stolen from ../../../top-level/python-packages.nix
+  toKodiAddon = drv: drv.overrideAttrs(oldAttrs: {
+    # Use passthru in order to prevent rebuilds when possible.
+    passthru = (oldAttrs.passthru or {})// {
+      kodiAddonFor = kodi;
+      requiredKodiAddons = requiredKodiAddons drv.propagatedBuildInputs;
+    };
+  });
+
+  # Check whether a derivation provides a Kodi addon.
+  hasKodiAddon = drv: drv ? kodiAddonFor && drv.kodiAddonFor == kodi;
+
+  # Get list of required Kodi addons given a list of derivations.
+  requiredKodiAddons = drvs: let
+      modules = filter hasKodiAddon drvs;
+    in unique (modules ++ concatLists (catAttrs "requiredKodiAddons" modules));
+
+  kodi-platform = stdenv.mkDerivation rec {
+    project = "kodi-platform";
+    version = "17.1";
+    name = "${project}-${version}";
+
+    src = fetchFromGitHub {
+      owner = "xbmc";
+      repo = project;
+      rev = "c8188d82678fec6b784597db69a68e74ff4986b5";
+      sha256 = "1r3gs3c6zczmm66qcxh9mr306clwb3p7ykzb70r3jv5jqggiz199";
+    };
+
+    nativeBuildInputs = [ cmake ];
+    buildInputs = [ kodi libcec_platform tinyxml ];
+  };
+
+  buildKodiAddon =
+    { name ? "${attrs.pname}-${attrs.version}"
+    , namespace
+    , sourceDir ? ""
+    , ... } @ attrs:
+  toKodiAddon (stdenv.mkDerivation ({
+    name = "kodi-" + name;
+
+    dontStrip = true;
+
+    extraRuntimeDependencies = [ ];
+
+    installPhase = ''
+      cd $src/$sourceDir
+      d=$out${addonDir}/${namespace}
+      mkdir -p $d
+      sauce="."
+      [ -d ${namespace} ] && sauce=${namespace}
+      cp -R "$sauce/"* $d
+    '';
+  } // attrs));
+
+  buildKodiBinaryAddon =
+    { name ? "${attrs.pname}-${attrs.version}"
+    , namespace
+    , version
+    , extraBuildInputs ? []
+    , extraRuntimeDependencies ? []
+    , extraInstallPhase ? "", ... } @ attrs:
+  toKodiAddon (stdenv.mkDerivation ({
+    name = "kodi-" + name;
+
+    dontStrip = true;
+
+    nativeBuildInputs = [ cmake ];
+    buildInputs = [ kodi kodi-platform libcec_platform ] ++ extraBuildInputs;
+
+    inherit extraRuntimeDependencies;
+
+    # disables check ensuring install prefix is that of kodi
+    cmakeFlags = [
+      "-DOVERRIDE_PATHS=1"
+    ];
+
+    # kodi checks for addon .so libs existance in the addon folder (share/...)
+    # and the non-wrapped kodi lib/... folder before even trying to dlopen
+    # them. Symlinking .so, as setting LD_LIBRARY_PATH is of no use
+    installPhase = let n = namespace; in ''
+      make install
+      ln -s $out/lib/addons/${n}/${n}.so.${version} $out${addonDir}/${n}/${n}.so.${version}
+      ${extraInstallPhase}
+    '';
+  } // attrs));
+
+  advanced-launcher = buildKodiAddon rec {
+
+    pname = "advanced-launcher";
+    namespace = "plugin.program.advanced.launcher";
+    version = "2.5.8";
+
+    src = fetchFromGitHub {
+      owner = "edwtjo";
+      repo = pname;
+      rev = version;
+      sha256 = "142vvgs37asq5m54xqhjzqvgmb0xlirvm0kz6lxaqynp0vvgrkx2";
+    };
+
+    meta = {
+      homepage = "https://forum.kodi.tv/showthread.php?tid=85724";
+      description = "A program launcher for Kodi";
+      longDescription = ''
+        Advanced Launcher allows you to start any Linux, Windows and
+        macOS external applications (with command line support or not)
+        directly from the Kodi GUI. Advanced Launcher also give you
+        the possibility to edit, download (from Internet resources)
+        and manage all the meta-data (informations and images) related
+        to these applications.
+      '';
+      platforms = platforms.all;
+      maintainers = with maintainers; [ edwtjo ];
+      broken = true; # requires port to python3
+    };
+
+  };
+
+  advanced-emulator-launcher = buildKodiAddon rec {
+
+    pname = "advanced-emulator-launcher";
+    namespace = "plugin.program.advanced.emulator.launcher";
+    version = "0.9.6";
+
+    src = fetchFromGitHub {
+      owner = "Wintermute0110";
+      repo = namespace;
+      rev = version;
+      sha256 = "1sv9z77jj6bam6llcnd9b3dgkbvhwad2m1v541rv3acrackms2z2";
+    };
+
+    meta = {
+      homepage = "https://forum.kodi.tv/showthread.php?tid=287826";
+      description = "A program launcher for Kodi";
+      longDescription = ''
+        Advanced Emulator Launcher is a multi-emulator front-end for Kodi
+        scalable to collections of thousands of ROMs. Includes offline scrapers
+        for MAME and No-Intro ROM sets and also supports scrapping ROM metadata
+        and artwork online. ROM auditing for No-Intro ROMs using No-Intro XML
+        DATs. Launching of games and standalone applications is also available.
+      '';
+      platforms = platforms.all;
+      maintainers = with maintainers; [ edwtjo ];
+      broken = true; # requires port to python3
+    };
+
+  };
+
+  controllers = let
+    pname = "game-controller";
+    version = "1.0.3";
+
+    src = fetchFromGitHub {
+      owner = "kodi-game";
+      repo = "kodi-game-controllers";
+      rev = "01acb5b6e8b85392b3cb298b034aadb1b24ccf18";
+      sha256 = "0sbc0w0fwbp7rbmbgb6a1kglhnn5g85hijcbbvf5x6jdq9v3f1qb";
+    };
+
+    meta = {
+      description = "Add support for different gaming controllers.";
+      platforms = platforms.all;
+      maintainers = with maintainers; [ edwtjo ];
+    };
+
+    mkController = controller: {
+        ${controller} = buildKodiAddon rec {
+          pname = pname + "-" + controller;
+          namespace = "game.controller." + controller;
+          sourceDir = "addons/" + namespace;
+          inherit version src meta;
+        };
+      };
+    in (mkController "default")
+    // (mkController "dreamcast")
+    // (mkController "gba")
+    // (mkController "genesis")
+    // (mkController "mouse")
+    // (mkController "n64")
+    // (mkController "nes")
+    // (mkController "ps")
+    // (mkController "snes");
+
+  hyper-launcher = let
+    pname = "hyper-launcher";
+    version = "1.5.2";
+    src = fetchFromGitHub rec {
+      name = pname + "-" + version + ".tar.gz";
+      owner = "teeedubb";
+      repo = owner + "-xbmc-repo";
+      rev = "f958ba93fe85b9c9025b1745d89c2db2e7dd9bf6";
+      sha256 = "1dvff24fbas25k5kvca4ssks9l1g5rfa3hl8lqxczkaqi3pp41j5";
+    };
+    meta = {
+      homepage = "https://forum.kodi.tv/showthread.php?tid=258159";
+      description = "A ROM launcher for Kodi that uses HyperSpin assets.";
+      maintainers = with maintainers; [ edwtjo ];
+      broken = true; # requires port to python3
+    };
+  in {
+    service = buildKodiAddon {
+      pname = pname + "-service";
+      version = "1.2.1";
+      namespace = "service.hyper.launcher";
+      inherit src meta;
+    };
+    plugin = buildKodiAddon {
+      namespace = "plugin.hyper.launcher";
+      inherit pname version src meta;
+    };
+  };
+
+  joystick = buildKodiBinaryAddon rec {
+    pname = namespace;
+    namespace = "peripheral.joystick";
+    version = "1.7.1";
+
+    src = fetchFromGitHub {
+      owner = "xbmc";
+      repo = namespace;
+      rev = "${version}-${rel}";
+      sha256 = "1dhj4afr9kj938xx70fq5r409mz6lbw4n581ljvdjj9lq7akc914";
+    };
+
+    meta = {
+      description = "Binary addon for raw joystick input.";
+      platforms = platforms.all;
+      maintainers = with maintainers; [ edwtjo ];
+    };
+
+    extraBuildInputs = [ tinyxml udev ];
+  };
+
+  simpleplugin = buildKodiAddon rec {
+    pname = "simpleplugin";
+    namespace = "script.module.simpleplugin";
+    version = "2.3.2";
+
+    src = fetchFromGitHub {
+      owner = "romanvm";
+      repo = namespace;
+      rev = "v.${version}";
+      sha256 = "0myar8dqjigb75pcc8zx3i5z79p1ifgphgb82s5syqywk0zaxm3j";
+    };
+
+    meta = {
+      homepage = src.meta.homepage;
+      description = "Simpleplugin API";
+      license = licenses.gpl3;
+      broken = true; # requires port to python3
+    };
+  };
+
+  svtplay = buildKodiAddon rec {
+
+    pname = "svtplay";
+    namespace = "plugin.video.svtplay";
+    version = "5.1.12";
+
+    src = fetchFromGitHub {
+      name = pname + "-" + version + ".tar.gz";
+      owner = "nilzen";
+      repo = "xbmc-" + pname;
+      rev = "v${version}";
+      sha256 = "04j1nhm7mh9chs995lz6bv1vsq5xzk7a7c0lmk4bnfv8jrfpj0w6";
+    };
+
+    meta = {
+      homepage = "https://forum.kodi.tv/showthread.php?tid=67110";
+      description = "Watch content from SVT Play";
+      longDescription = ''
+        With this addon you can stream content from SVT Play
+        (svtplay.se). The plugin fetches the video URL from the SVT
+        Play website and feeds it to the Kodi video player. HLS (m3u8)
+        is the preferred video format by the plugin.
+      '';
+      platforms = platforms.all;
+      maintainers = with maintainers; [ edwtjo ];
+    };
+
+  };
+
+  steam-controller = buildKodiBinaryAddon rec {
+    pname = namespace;
+    namespace = "peripheral.steamcontroller";
+    version = "0.11.0";
+
+    src = fetchFromGitHub {
+      owner = "kodi-game";
+      repo = namespace;
+      rev = "f68140ca44f163a03d3a625d1f2005a6edef96cb";
+      sha256 = "09lm8i119xlsxxk0c64rnp8iw0crr90v7m8iwi9r31qdmxrdxpmg";
+    };
+
+    extraBuildInputs = [ libusb1 ];
+
+    meta = {
+      description = "Binary addon for steam controller.";
+      platforms = platforms.all;
+      maintainers = with maintainers; [ edwtjo ];
+    };
+
+  };
+
+  steam-launcher = buildKodiAddon {
+
+    pname = "steam-launcher";
+    namespace = "script.steam.launcher";
+    version = "3.5.1";
+
+    src = fetchFromGitHub rec {
+      owner = "teeedubb";
+      repo = owner + "-xbmc-repo";
+      rev = "8260bf9b464846a1f1965da495d2f2b7ceb81d55";
+      sha256 = "1fj3ry5s44nf1jzxk4bmnpa4b9p23nrpmpj2a4i6xf94h7jl7p5k";
+    };
+
+    propagatedBuildInputs = [ steam ];
+
+    meta = {
+      homepage = "https://forum.kodi.tv/showthread.php?tid=157499";
+      description = "Launch Steam in Big Picture Mode from Kodi";
+      longDescription = ''
+        This add-on will close/minimise Kodi, launch Steam in Big
+        Picture Mode and when Steam BPM is exited (either by quitting
+        Steam or returning to the desktop) Kodi will
+        restart/maximise. Running pre/post Steam scripts can be
+        configured via the addon.
+      '';
+      maintainers = with maintainers; [ edwtjo ];
+    };
+  };
+
+  pdfreader = buildKodiAddon rec {
+    pname = "pdfreader";
+    namespace = "plugin.image.pdf";
+    version = "2.0.2";
+
+    src = fetchFromGitHub {
+      owner = "i96751414";
+      repo = "plugin.image.pdfreader";
+      rev = "v${version}";
+      sha256 = "0nkqhlm1gyagq6xpdgqvd5qxyr2ngpml9smdmzfabc8b972mwjml";
+    };
+
+    meta = {
+      homepage = "https://forum.kodi.tv/showthread.php?tid=187421";
+      description = "A comic book reader";
+      maintainers = with maintainers; [ edwtjo ];
+    };
+  };
+
+  pvr-hts = buildKodiBinaryAddon rec {
+
+    pname = "pvr-hts";
+    namespace = "pvr.hts";
+    version = "8.2.2";
+
+    src = fetchFromGitHub {
+      owner = "kodi-pvr";
+      repo = "pvr.hts";
+      rev = "${version}-${rel}";
+      sha256 = "0jnn9gfjl556acqjf92wzzn371gxymhbbi665nqgg2gjcan0a49q";
+    };
+
+    meta = {
+      homepage = "https://github.com/kodi-pvr/pvr.hts";
+      description = "Kodi's Tvheadend HTSP client addon";
+      platforms = platforms.all;
+      maintainers = with maintainers; [ cpages ];
+    };
+
+  };
+
+  pvr-hdhomerun = buildKodiBinaryAddon rec {
+
+    pname = "pvr-hdhomerun";
+    namespace = "pvr.hdhomerun";
+    version = "7.1.0";
+
+    src = fetchFromGitHub {
+      owner = "kodi-pvr";
+      repo = "pvr.hdhomerun";
+      rev = "${version}-${rel}";
+      sha256 = "0gbwjssnd319csq2kwlyjj1rskg19m1dxac5dl2dymvx5hn3zrgm";
+    };
+
+    meta = {
+      homepage = "https://github.com/kodi-pvr/pvr.hdhomerun";
+      description = "Kodi's HDHomeRun PVR client addon";
+      platforms = platforms.all;
+      maintainers = with maintainers; [ titanous ];
+    };
+
+    extraBuildInputs = [ jsoncpp libhdhomerun ];
+
+  };
+
+  pvr-iptvsimple = buildKodiBinaryAddon rec {
+
+    pname = "pvr-iptvsimple";
+    namespace = "pvr.iptvsimple";
+    version = "7.4.2";
+
+    src = fetchFromGitHub {
+      owner = "kodi-pvr";
+      repo = "pvr.iptvsimple";
+      rev = "${version}-${rel}";
+      sha256 = "062i922qi0izkvn7v47yhyy2cf3fa7xc3k95b1gm9abfdwkk8ywr";
+    };
+
+    meta = {
+      homepage = "https://github.com/kodi-pvr/pvr.iptvsimple";
+      description = "Kodi's IPTV Simple client addon";
+      platforms = platforms.all;
+      maintainers = with maintainers; [ ];
+      license = licenses.gpl2Plus;
+    };
+
+    extraBuildInputs = [ zlib pugixml ];
+  };
+
+  osmc-skin = buildKodiAddon rec {
+
+    pname = "osmc-skin";
+    namespace = "skin.osmc";
+    version = "18.0.0";
+
+    src = fetchFromGitHub {
+      owner = "osmc";
+      repo = namespace;
+      rev = "40a6c318641e2cbeac58fb0e7dde9c2beac737a0";
+      sha256 = "1l7hyfj5zvjxjdm94y325bmy1naak455b9l8952sb0gllzrcwj6s";
+    };
+
+    meta = {
+      homepage = "https://github.com/osmc/skin.osmc";
+      description = "The default skin for OSMC";
+      platforms = platforms.all;
+      maintainers = with maintainers; [ worldofpeace ];
+      license = licenses.cc-by-nc-sa-30;
+    };
+  };
+
+  yatp = python3Packages.toPythonModule (buildKodiAddon rec {
+    pname = "yatp";
+    namespace = "plugin.video.yatp";
+    version = "3.3.2";
+
+    src = fetchFromGitHub {
+      owner = "romanvm";
+      repo = "kodi.yatp";
+      rev = "v.${version}";
+      sha256 = "12g1f57sx7dy6wy7ljl7siz2qs1kxcmijcg7xx2xpvmq61x9qa2d";
+    };
+
+    patches = [ ./yatp/dont-monkey.patch ];
+
+    propagatedBuildInputs = [
+      simpleplugin
+      python3Packages.requests
+      python3Packages.libtorrent-rasterbar
+    ];
+
+    meta = {
+      homepage = src.meta.homepage;
+      description = "Yet Another Torrent Player: libtorrent-based torrent streaming for Kodi";
+      license = licenses.gpl3;
+      broken = true; # requires port to python3
+    };
+  });
+
+  inputstream-adaptive = buildKodiBinaryAddon rec {
+
+    pname = "inputstream-adaptive";
+    namespace = "inputstream.adaptive";
+    version = "2.6.7";
+
+    src = fetchFromGitHub {
+      owner = "peak3d";
+      repo = "inputstream.adaptive";
+      rev = "${version}-${rel}";
+      sha256 = "1pwqmbr78wp12jn6rwv63npdfc456adwz0amlxf6gvgg43li6p7s";
+    };
+
+    extraBuildInputs = [ expat ];
+
+    extraRuntimeDependencies = [ glib nspr nss stdenv.cc.cc.lib ];
+
+    extraInstallPhase = let n = namespace; in ''
+      ln -s $out/lib/addons/${n}/libssd_wv.so $out/${addonDir}/${n}/libssd_wv.so
+    '';
+
+    meta = {
+      homepage = "https://github.com/peak3d/inputstream.adaptive";
+      description = "Kodi inputstream addon for several manifest types";
+      platforms = platforms.all;
+      maintainers = with maintainers; [ sephalon ];
+    };
+  };
+
+  vfs-sftp = buildKodiBinaryAddon rec {
+    pname = namespace;
+    namespace = "vfs.sftp";
+    version = "2.0.0";
+
+    src = fetchFromGitHub {
+      owner = "xbmc";
+      repo = namespace;
+      rev = "${version}-${rel}";
+      sha256 = "06w74sh8yagrrp7a7rjaz3xrh1j3wdqald9c4b72c33gpk5997dk";
+    };
+
+    meta = with lib; {
+      description = "SFTP Virtual Filesystem add-on for Kodi";
+      license = licenses.gpl2Plus;
+      platforms = platforms.all;
+      maintainers = with maintainers; [ minijackson ];
+    };
+
+    extraBuildInputs = [ openssl libssh zlib ];
+  };
+
+  vfs-libarchive = buildKodiBinaryAddon rec {
+    pname = namespace;
+    namespace = "vfs.libarchive";
+    version = "2.0.0";
+
+    src = fetchFromGitHub {
+      owner = "xbmc";
+      repo = namespace;
+      rev = "${version}-${rel}";
+      sha256 = "1q62p1i6rvqk2zv6f1cpffkh95lgclys2xl4dwyhj3acmqdxd9i5";
+    };
+
+    meta = with lib; {
+      description = "LibArchive Virtual Filesystem add-on for Kodi";
+      license = licenses.gpl2Plus;
+      platforms = platforms.all;
+      maintainers = with maintainers; [ minijackson ];
+    };
+
+    extraBuildInputs = [ libarchive xz bzip2 zlib lz4 lzo openssl ];
+  };
+}; in self

pkgs/applications/video/mpv/default.nix

···
 
 in stdenv.mkDerivation rec {
   pname = "mpv";
-  version = "0.33.0";
+  version = "0.33.1";
 
   src = fetchFromGitHub {
     owner  = "mpv-player";
     repo   = "mpv";
     rev    = "v${version}";
-    sha256 = "sha256-3l32qQBpvWVjbLp5CZtO039oDQeH7C/cNAKtJxrzlRk=";
+    sha256 = "06rw1f55zcsj78ql8w70j9ljp2qb1pv594xj7q9cmq7i92a7hq45";
   };
 
   patches = [

pkgs/applications/virtualization/crun/default.nix

···
 , nixosTests
 , criu
 , system
-, fetchpatch
 }:
 
 let
···
     "test_pid_file.py"
     "test_preserve_fds.py"
     "test_resources"
+    "test_seccomp"
     "test_start.py"
     "test_uid_gid.py"
     "test_update.py"
···
 in
 stdenv.mkDerivation rec {
   pname = "crun";
-  version = "0.18";
+  version = "0.19";
 
   src = fetchFromGitHub {
     owner = "containers";
     repo = pname;
     rev = version;
-    sha256 = "sha256-VjMpfj2qUQdhqdnLpZsYigfo2sM7gNl0GrE4nitp13g=";
+    sha256 = "sha256-G9asWedX03cP5Qg5HIzlSIwwqNL16kiyWairk+6Kabw=";
     fetchSubmodules = true;
   };
-
-  patches = [
-    # For 0.18 some tests switched to static builds, this was reverted after 0.18 was released
-    (fetchpatch {
-      url = "https://github.com/containers/crun/commit/d26579bfe56aa36dd522745d47a661ce8c70d4e7.patch";
-      sha256 = "1xmc0wj0j2xcg0915vxn0pplc4s94rpmw0s5g8cyf8dshfl283f9";
-    })
-  ];
 
   nativeBuildInputs = [ autoreconfHook go-md2man pkg-config python3 ];
 

pkgs/applications/virtualization/docker/default.nix

···
       , stdenv, fetchFromGitHub, fetchpatch, buildGoPackage
       , makeWrapper, installShellFiles, pkg-config
       , go-md2man, go, containerd, runc, docker-proxy, tini, libtool
-      , sqlite, iproute, lvm2, systemd, docker-buildx
+      , sqlite, iproute2, lvm2, systemd, docker-buildx
       , btrfs-progs, iptables, e2fsprogs, xz, util-linux, xfsprogs, git
       , procps, libseccomp
       , nixosTests
···
       nativeBuildInputs = [ makeWrapper pkg-config go-md2man go libtool installShellFiles ];
       buildInputs = [ sqlite lvm2 btrfs-progs systemd libseccomp ];
 
-      extraPath = optionals (stdenv.isLinux) (makeBinPath [ iproute iptables e2fsprogs xz xfsprogs procps util-linux git ]);
+      extraPath = optionals (stdenv.isLinux) (makeBinPath [ iproute2 iptables e2fsprogs xz xfsprogs procps util-linux git ]);
 
       buildPhase = ''
         export GOCACHE="$TMPDIR/go-cache"

pkgs/applications/virtualization/gvisor/default.nix

···
 , git
 , glibcLocales
 , go
-, iproute
+, iproute2
 , iptables
 , makeWrapper
 , procps
···
 
       # Needed for the 'runsc do' subcomand
       wrapProgram $out/bin/runsc \
-        --prefix PATH : ${lib.makeBinPath [ iproute iptables procps ]}
+        --prefix PATH : ${lib.makeBinPath [ iproute2 iptables procps ]}
     '';
   };
 

pkgs/applications/virtualization/open-vm-tools/default.nix

···
 { stdenv, lib, fetchFromGitHub, makeWrapper, autoreconfHook,
   fuse, libmspack, openssl, pam, xercesc, icu, libdnet, procps, libtirpc, rpcsvc-proto,
   libX11, libXext, libXinerama, libXi, libXrender, libXrandr, libXtst,
-  pkg-config, glib, gdk-pixbuf-xlib, gtk3, gtkmm3, iproute, dbus, systemd, which,
+  pkg-config, glib, gdk-pixbuf-xlib, gtk3, gtkmm3, iproute2, dbus, systemd, which,
   withX ? true }:
 
 stdenv.mkDerivation rec {
···
 
   postInstall = ''
     wrapProgram "$out/etc/vmware-tools/scripts/vmware/network" \
-      --prefix PATH ':' "${lib.makeBinPath [ iproute dbus systemd which ]}"
+      --prefix PATH ':' "${lib.makeBinPath [ iproute2 dbus systemd which ]}"
   '';
 
   meta = with lib; {

pkgs/applications/virtualization/x11docker/default.nix

···
-{ lib, stdenv, fetchFromGitHub, makeWrapper, nx-libs, xorg, getopt, gnugrep, gawk, ps, mount, iproute }:
+{ lib, stdenv, fetchFromGitHub, makeWrapper, nx-libs, xorg, getopt, gnugrep, gawk, ps, mount, iproute2 }:
 stdenv.mkDerivation rec {
   pname = "x11docker";
   version = "6.6.2";
···
   installPhase = ''
     install -D x11docker "$out/bin/x11docker";
     wrapProgram "$out/bin/x11docker" \
-      --prefix PATH : "${lib.makeBinPath [ getopt gnugrep gawk ps mount iproute nx-libs xorg.xdpyinfo xorg.xhost xorg.xinit ]}"
+      --prefix PATH : "${lib.makeBinPath [ getopt gnugrep gawk ps mount iproute2 nx-libs xorg.xdpyinfo xorg.xhost xorg.xinit ]}"
   '';
 
   meta = {

pkgs/applications/virtualization/xen/generic.nix

···
 
 # Scripts
 , coreutils, gawk, gnused, gnugrep, diffutils, multipath-tools
-, iproute, inetutils, iptables, bridge-utils, openvswitch, nbd, drbd
+, iproute2, inetutils, iptables, bridge-utils, openvswitch, nbd, drbd
 , lvm2, util-linux, procps, systemd
 
 # Documentation
···
   scriptEnvPath = concatMapStringsSep ":" (x: "${x}/bin") [
     which perl
     coreutils gawk gnused gnugrep diffutils util-linux multipath-tools
-    iproute inetutils iptables bridge-utils openvswitch nbd drbd
+    iproute2 inetutils iptables bridge-utils openvswitch nbd drbd
   ];
 
   withXenfiles = f: concatStringsSep "\n" (mapAttrsToList f config.xenfiles);

pkgs/applications/window-managers/cwm/default.nix

···
-{ lib, stdenv, fetchFromGitHub, libX11, libXinerama, libXrandr, libXft, yacc, pkg-config }:
+{ lib, stdenv, fetchFromGitHub, libX11, libXinerama, libXrandr, libXft, bison, pkg-config }:
 
 stdenv.mkDerivation rec {
 
···
   };
 
   nativeBuildInputs = [ pkg-config ];
-  buildInputs = [ libX11 libXinerama libXrandr libXft yacc ];
+  buildInputs = [ libX11 libXinerama libXrandr libXft bison ];
 
   prePatch = ''sed -i "s@/usr/local@$out@" Makefile'';
 

pkgs/applications/window-managers/dwm/dwm-status.nix

···
 { lib, rustPlatform, fetchFromGitHub, dbus, gdk-pixbuf, libnotify, makeWrapper, pkg-config, xorg
 , enableAlsaUtils ? true, alsaUtils, coreutils
-, enableNetwork ? true, dnsutils, iproute, wirelesstools }:
+, enableNetwork ? true, dnsutils, iproute2, wirelesstools }:
 
 let
   bins = lib.optionals enableAlsaUtils [ alsaUtils coreutils ]
-    ++ lib.optionals enableNetwork [ dnsutils iproute wirelesstools ];
+    ++ lib.optionals enableNetwork [ dnsutils iproute2 wirelesstools ];
 in
 
 rustPlatform.buildRustPackage rec {

pkgs/applications/window-managers/i3/blocks-gaps.nix

···
 { fetchFromGitHub, lib, stdenv, perl, makeWrapper
-, iproute, acpi, sysstat, alsaUtils
+, iproute2, acpi, sysstat, alsaUtils
 , scripts ? [ "bandwidth" "battery" "cpu_usage" "disk" "iface"
               "load_average" "memory" "volume" "wifi" ]
 }:
···
 
   postFixup = ''
     wrapProgram $out/libexec/i3blocks/bandwidth \
-      --prefix PATH : ${makeBinPath (optional (elem "bandwidth" scripts) iproute)}
+      --prefix PATH : ${makeBinPath (optional (elem "bandwidth" scripts) iproute2)}
     wrapProgram $out/libexec/i3blocks/battery \
       --prefix PATH : ${makeBinPath (optional (elem "battery" scripts) acpi)}
     wrapProgram $out/libexec/i3blocks/cpu_usage \
       --prefix PATH : ${makeBinPath (optional (elem "cpu_usage" scripts) sysstat)}
     wrapProgram $out/libexec/i3blocks/iface \
-      --prefix PATH : ${makeBinPath (optional (elem "iface" scripts) iproute)}
+      --prefix PATH : ${makeBinPath (optional (elem "iface" scripts) iproute2)}
     wrapProgram $out/libexec/i3blocks/volume \
       --prefix PATH : ${makeBinPath (optional (elem "volume" scripts) alsaUtils)}
   '';

pkgs/applications/window-managers/i3/wsr.nix

···
+{ lib, fetchFromGitHub, rustPlatform, libxcb, python3 }:
+
+rustPlatform.buildRustPackage rec {
+  pname = "i3wsr";
+  version = "1.3.1";
+
+  src = fetchFromGitHub {
+    owner = "roosta";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "1zpyncg29y8cv5nw0vgd69nywbj1ppxf6qfm4zc6zz0gk0vxy4pn";
+  };
+
+  cargoSha256 = "0snys419d32anf73jcvrq8h9kp1fq0maqcxz6ww04yg2jv6j47nc";
+
+  nativeBuildInputs = [ python3 ];
+  buildInputs = [ libxcb ];
+
+  # has not tests
+  doCheck = false;
+
+  meta = with lib; {
+    description = "Automatically change i3 workspace names based on their contents";
+    longDescription = ''
+      Automatically sets the workspace names to match the windows on the workspace.
+      The chosen name for a workspace is a user-defined composite of the WM_CLASS X11
+      window property for each window in a workspace.
+    '';
+    homepage = "https://github.com/roosta/i3wsr";
+    license = licenses.mit;
+    maintainers = [ maintainers.sebbadk ];
+  };
+}

pkgs/applications/window-managers/sway/wsr.nix

···
+{ lib, fetchFromGitHub, rustPlatform, libxcb, python3 }:
+
+rustPlatform.buildRustPackage rec {
+  pname = "swaywsr";
+  version = "1.1.0";
+
+  src = fetchFromGitHub {
+    owner = "pedroscaff";
+    repo = pname;
+    rev = "6c4671c702f647395d983aaf607286db1c692db6";
+    sha256 = "0bmpbhyvgnbi5baj6v0wdxpdh9cnlzvcc44vh3vihmzsp6i5q05a";
+  };
+
+  cargoSha256 = "15wa03279lflr16a6kw7zcn3nvalnjydk9g6nj7xqxmc7zkpf0rm";
+
+  nativeBuildInputs = [ python3 ];
+  buildInputs = [ libxcb ];
+
+  # has not tests
+  doCheck = false;
+
+  meta = with lib; {
+    description = "Automatically change sway workspace names based on their contents";
+    longDescription = ''
+      Automatically sets the workspace names to match the windows on the workspace.
+      The chosen name for a workspace is a composite of the app_id or WM_CLASS X11
+      window property for each window in a workspace.
+    '';
+    homepage = "https://github.com/pedroscaff/swaywsr";
+    license = licenses.mit;
+    maintainers = [ maintainers.sebbadk ];
+  };
+}

pkgs/build-support/build-fhs-userenv-bubblewrap/default.nix

···
       if [[ $path == '/etc' ]]; then
         :
       elif [[ -L $i ]]; then
-        symlinks+=(--symlink "$(readlink "$i")" "$path")
+        symlinks+=(--symlink "$(${coreutils}/bin/readlink "$i")" "$path")
         blacklist+=("$path")
       else
         ro_mounts+=(--ro-bind "$i" "$path")

pkgs/build-support/vm/default.nix

···
       buildCommand = ''
         ${createRootFS}
 
-        PATH=$PATH:${lib.makeBinPath [ dpkg dpkg glibc lzma ]}
+        PATH=$PATH:${lib.makeBinPath [ dpkg dpkg glibc xz ]}
 
         # Unpack the .debs.  We do this to prevent pre-install scripts
         # (which have lots of circular dependencies) from barfing.

pkgs/data/fonts/julia-mono/default.nix

···
 { lib, fetchzip }:
 
 let
-  version = "0.034";
+  version = "0.035";
 
 in fetchzip {
   name = "JuliaMono-${version}";
   url = "https://github.com/cormullion/juliamono/releases/download/v${version}/JuliaMono.zip";
-  sha256 = "sha256:0xx3mhzs17baaich67kvwyzqg8h9ga11jrja2i8sxx4861dp1z85";
+  sha256 = "sha256:17w8rn37wadxnmakhd6mpmqdx14dsrc3qym4k9b47albl1a34i1j";
 
   postFetch = ''
     mkdir -p $out/share/fonts/truetype

pkgs/data/themes/matcha/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "matcha-gtk-theme";
-  version = "2021-02-04";
+  version = "2021-04-05";
 
   src = fetchFromGitHub {
     owner = "vinceliuice";
     repo = pname;
     rev = version;
-    sha256 = "sha256-CDym+yqLu7QpqmdUpXAbJTCjQf/r9D1sl7ZdpaWaXFE=";
+    sha256 = "0bm7hr4lqqz3z2miif38628r4qcy7i5hdk6sm0ngjacm43cl0qvg";
   };
 
   buildInputs = [ gdk-pixbuf librsvg ];
···
   propagatedUserEnvPkgs = [ gtk-engine-murrine ];
 
   installPhase = ''
+    runHook preInstall
     patchShebangs .
     mkdir -p $out/share/themes
     name= ./install.sh -d $out/share/themes
     install -D -t $out/share/gtksourceview-3.0/styles src/extra/gedit/matcha.xml
     mkdir -p $out/share/doc/${pname}
     cp -a src/extra/firefox $out/share/doc/${pname}
+    runHook postInstall
   '';
 
   meta = with lib; {
-    description = "A stylish flat Design theme for GTK based desktop environments";
+    description = "A stylish flat design theme for GTK based desktop environments";
     homepage = "https://vinceliuice.github.io/theme-matcha";
     license = licenses.gpl3Only;
     platforms = platforms.unix;

pkgs/desktops/gnome-3/core/evolution-data-server/default.nix

···
 { fetchurl, lib, stdenv, substituteAll, pkg-config, gnome3, python3, gobject-introspection
 , intltool, libsoup, libxml2, libsecret, icu, sqlite, tzdata, libcanberra-gtk3, gcr, p11-kit
 , db, nspr, nss, libical, gperf, wrapGAppsHook, glib-networking, pcre, vala, cmake, ninja
-, kerberos, openldap, webkitgtk, libaccounts-glib, json-glib, glib, gtk3, libphonenumber
+, libkrb5, openldap, webkitgtk, libaccounts-glib, json-glib, glib, gtk3, libphonenumber
 , gnome-online-accounts, libgweather, libgdata, gsettings-desktop-schemas, boost, protobuf }:
 
 stdenv.mkDerivation rec {
···
   buildInputs = [
     glib libsoup libxml2 gtk3 gnome-online-accounts
     gcr p11-kit libgweather libgdata libaccounts-glib json-glib
-    icu sqlite kerberos openldap webkitgtk glib-networking
+    icu sqlite libkrb5 openldap webkitgtk glib-networking
     libcanberra-gtk3 pcre libphonenumber boost protobuf
   ];
 

pkgs/desktops/plasma-5/default.nix

···
       plasma-workspace-wallpapers = callPackage ./plasma-workspace-wallpapers.nix {};
       polkit-kde-agent = callPackage ./polkit-kde-agent.nix {};
       powerdevil = callPackage ./powerdevil.nix {};
+      qqc2-breeze-style = callPackage ./qqc2-breeze-style.nix {};
       sddm-kcm = callPackage ./sddm-kcm.nix {};
       systemsettings = callPackage ./systemsettings.nix {};
       xdg-desktop-portal-kde = callPackage ./xdg-desktop-portal-kde.nix {};

pkgs/desktops/plasma-5/qqc2-breeze-style.nix

···
+{ mkDerivation
+, lib
+, extra-cmake-modules
+, kconfig
+, kconfigwidgets
+, kdoctools
+, kguiaddons
+, kiconthemes
+, kirigami2
+, qtquickcontrols2
+, qtx11extras
+}:
+
+mkDerivation {
+  name = "qqc2-breeze-style";
+  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
+  buildInputs = [
+    kconfig
+    kconfigwidgets
+    kguiaddons
+    kiconthemes
+    kirigami2
+    qtquickcontrols2
+    qtx11extras
+  ];
+}

pkgs/desktops/xfce/applications/mousepad/allow-checking-parent-sources-when-looking-up-schema.patch

···
-From 3b06d6129033ddaa8dc455a6a572077fd63a3816 Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?Jos=C3=A9=20Romildo=20Malaquias?= <[e-mail]>
-Date: Mon, 1 Mar 2021 17:03:07 -0300
-Subject: [PATCH] Allow checking parent sources when looking up schema
-
----
- mousepad/mousepad-settings-store.c | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/mousepad/mousepad-settings-store.c b/mousepad/mousepad-settings-store.c
-index e5a848b..de989bd 100644
---- a/mousepad/mousepad-settings-store.c
-+++ b/mousepad/mousepad-settings-store.c
-@@ -181,7 +181,7 @@ mousepad_settings_store_add_settings (MousepadSettingsStore *self,
-   const gchar      *prefix;
- 
-   /* loop through keys in schema and store mapping of their setting name to GSettings */
--  schema = g_settings_schema_source_lookup (source, schema_id, FALSE);
-+  schema = g_settings_schema_source_lookup (source, schema_id, TRUE);
-   keys = g_settings_schema_list_keys (schema);
-   prefix = schema_id + MOUSEPAD_ID_LEN + 1;
-   for (key = keys; key && *key; key++)
--- 
-2.30.0
-

pkgs/desktops/xfce/applications/mousepad/default.nix

···
-{ mkXfceDerivation, gobject-introspection, vala, gtk3, gtksourceview3, xfconf }:
+{ mkXfceDerivation, gobject-introspection, vala, gtk3, gtksourceview4, xfconf }:
 
 mkXfceDerivation {
   category = "apps";
   pname = "mousepad";
-  version = "0.5.3";
+  version = "0.5.4";
   odd-unstable = false;
 
-  sha256 = "0ki5k5p24dpawkyq4k8am1fcq02njhnmhq5vf2ah1zqbc0iyl5yn";
+  sha256 = "0yrmjs6cyzm08jz8wzrx8wdxj7zdbxn6x625109ckfcfxrkp4a2f";
 
   nativeBuildInputs = [ gobject-introspection vala ];
 
-  buildInputs = [ gtk3 gtksourceview3 xfconf ];
-
-  patches = [ ./allow-checking-parent-sources-when-looking-up-schema.patch ];
+  buildInputs = [ gtk3 gtksourceview4 xfconf ];
 
   meta = {
     description = "Simple text editor for Xfce";

pkgs/development/compilers/graalvm/default.nix

···
 { stdenv, lib, fetchFromGitHub, fetchurl, fetchzip, fetchgit, mercurial_4, python27, setJavaClassPath,
   which, zlib, makeWrapper, openjdk, unzip, git, clang, llvm, icu, ruby, glibc, bash, gcc, libobjc,
-  xcodebuild, gfortran, readline, bzip2, lzma, pcre, curl, ed, libresolv, libiconv, writeScriptBin,
+  xcodebuild, gfortran, readline, bzip2, xz, pcre, curl, ed, libresolv, libiconv, writeScriptBin,
   openssl, perl, CoreFoundation, Foundation, JavaNativeFoundation, JavaRuntimeSupport, JavaVM, Cocoa
 }:
 
···
 
     buildInputs = [ mx zlib.dev mercurial jvmci8 git llvm clang
                     python27withPackages icu ruby bzip2 which
-                    readline bzip2 lzma pcre curl ed gfortran
+                    readline bzip2 xz pcre curl ed gfortran
                   ]  ++ lib.optional stdenv.isDarwin [
                     CoreFoundation gcc.cc.lib libiconv perl openssl
                   ];

pkgs/development/compilers/ispc/default.nix

···
-{ lib, stdenv, fetchFromGitHub
+{ lib, stdenv, fetchFromGitHub, fetchpatch
 , cmake, which, m4, python3, bison, flex, llvmPackages
 
   # the default test target is sse4, but that is not supported by all Hydra agents
···
 
 stdenv.mkDerivation rec {
   pname   = "ispc";
-  version = "1.13.0";
+  version = "unstable-2021-04-02";
 
   src = fetchFromGitHub {
     owner  = pname;
     repo   = pname;
-    rev    = "v${version}";
-    sha256 = "1l74xkpwwxc38k2ngg7mpvswziiy91yxslgfad6688hh1n5jvayd";
+    # ISPC release 1.15.0 doesn't build against LLVM 11.1, only against 11.0. So we
+    # use latest ISPC main branch for now, until they support an LLVM version we have.
+    # https://github.com/ispc/ispc/issues/2027#issuecomment-784470530
+    rev    = "3e8313568265d2adfbf95bd6b6e1a4c70ef59bed";
+    sha256 = "sha256-gvr+VpoacmwQlP5gT4MnfmKdACZWJduVMIpR0YRzseg=";
   };
+
+  patches = [
+    # Fix cmake error: `Failed to find clang++`
+    # https://github.com/ispc/ispc/pull/2055
+    (fetchpatch {
+      url = "https://github.com/erictapen/ispc/commit/338119b2f4e11fcf0b0852de296c320928e572a2.patch";
+      sha256 = "sha256-+RqDq1LMWomu/K4SgK0Nip47b1RwyM6W0cTSNGD4+m4=";
+    })
+  ];
 
   nativeBuildInputs = [ cmake which m4 bison flex python3 ];
   buildInputs = with llvmPackages; [
···
 
   cmakeFlags = [
     "-DCLANG_EXECUTABLE=${llvmPackages.clang}/bin/clang"
+    "-DCLANGPP_EXECUTABLE=${llvmPackages.clang}/bin/clang++"
     "-DISPC_INCLUDE_EXAMPLES=OFF"
     "-DISPC_INCLUDE_UTILS=OFF"
     "-DARM_ENABLED=FALSE"

pkgs/development/compilers/sjasmplus/default.nix

···
+{ lib, stdenv, fetchFromGitHub }:
+
+stdenv.mkDerivation rec {
+  pname = "sjasmplus";
+  version = "1.18.2";
+
+  src = fetchFromGitHub {
+    owner = "z00m128";
+    repo = "sjasmplus";
+    rev = "v${version}";
+    sha256 = "04348zcmc0b3crzwhvj1shx6f1n3x05vs8d5qdm7qhgdfki8r74v";
+  };
+
+  buildFlags = [
+    "CC=${stdenv.cc.targetPrefix}cc"
+    "CXX=${stdenv.cc.targetPrefix}c++"
+  ];
+
+  installPhase = ''
+    runHook preInstall
+    install -D sjasmplus $out/bin/sjasmplus
+    runHook postInstall
+  '';
+
+  meta = with lib; {
+    homepage = "https://z00m128.github.io/sjasmplus/";
+    description = "A Z80 assembly language cross compiler. It is based on the SjASM source code by Sjoerd Mastijn";
+    license = licenses.bsd3;
+    platforms = platforms.all;
+    maintainers = with maintainers; [ electrified ];
+  };
+}

pkgs/development/interpreters/python/cpython/default.nix

···
 , expat
 , libffi
 , gdbm
-, lzma
+, xz
 , mime-types ? null, mimetypesSupport ? true
 , ncurses
 , openssl
···
   ];
 
   buildInputs = filter (p: p != null) ([
-    zlib bzip2 expat lzma libffi gdbm sqlite readline ncurses openssl ]
+    zlib bzip2 expat xz libffi gdbm sqlite readline ncurses openssl ]
     ++ optionals x11Support [ tcl tk libX11 xorgproto ]
     ++ optionals (bluezSupport && stdenv.isLinux) [ bluez ]
     ++ optionals stdenv.isDarwin [ configd ])

pkgs/development/interpreters/python/pypy/default.nix

···
 { lib, stdenv, substituteAll, fetchurl
 , zlib ? null, zlibSupport ? true, bzip2, pkg-config, libffi, libunwind, Security
 , sqlite, openssl, ncurses, python, expat, tcl, tk, tix, xlibsWrapper, libX11
-, self, gdbm, db, lzma
+, self, gdbm, db, xz
 , python-setup-hook
 # For the Python package set
 , packageOverrides ? (self: super: {})
···
   buildInputs = [
     bzip2 openssl pythonForPypy libffi ncurses expat sqlite tk tcl xlibsWrapper libX11 gdbm db
   ]  ++ optionals isPy3k [
-    lzma
+    xz
   ] ++ optionals (stdenv ? cc && stdenv.cc.libc != null) [
     stdenv.cc.libc
   ] ++ optionals zlibSupport [

pkgs/development/interpreters/wasmer/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "wasmer";
-  version = "0.17.0";
+  version = "1.0.2";
 
   src = fetchFromGitHub {
     owner = "wasmerio";
     repo = pname;
     rev = version;
-    sha256 = "05g4h0xkqd14wnmijiiwmhk6l909fjxr6a2zplrjfxk5bypdalpm";
+    sha256 = "0ciia8hhkkyh6rmrxgbk3bgwjwzkcba6645wlcm0vlgk2w4i5m3z";
     fetchSubmodules = true;
   };
 
-  cargoSha256 = "1ssmgx9fjvkq7ycyzjanqmlm5b80akllq6qyv3mj0k5fvs659wcq";
+  cargoSha256 = "08r2b4s005w8r207jwq2fd43y3prgd8pg1m72aww1r7yrbxdr0v2";
 
   nativeBuildInputs = [ cmake pkg-config ];
 
-  # Since wasmer 0.17 no backends are enabled by default. Backends are now detected
-  # using the [makefile](https://github.com/wasmerio/wasmer/blob/master/Makefile).
-  # Enabling cranelift as this used to be the old default. At least one backend is
-  # needed for the run subcommand to work.
-  cargoBuildFlags = [ "--features" "backend-cranelift" ];
+  cargoBuildFlags = [
+    # cranelift+jit works everywhere, see:
+    # https://github.com/wasmerio/wasmer/blob/master/Makefile#L22
+    "--features" "cranelift,jit"
+    # must target manifest and desired output bin, otherwise output is empty
+    "--manifest-path" "lib/cli/Cargo.toml"
+    "--bin" "wasmer"
+  ];
+
+  cargoTestFlags = [
+    "--features" "test-cranelift,test-jit"
+  ];
 
   LIBCLANG_PATH = "${llvmPackages.libclang}/lib";
 

pkgs/development/libraries/comedilib/default.nix

···
 , fetchFromGitHub
 , autoreconfHook
 , flex
-, yacc
+, bison
 , xmlto
 , docbook_xsl
 , docbook_xml_dtd_44
···
   nativeBuildInputs = [
     autoreconfHook
     flex
-    yacc
+    bison
     swig
     xmlto
     docbook_xml_dtd_44

pkgs/development/libraries/cyrus-sasl/default.nix

···
-{ lib, stdenv, fetchurl, openssl, openldap, kerberos, db, gettext
+{ lib, stdenv, fetchurl, openssl, openldap, libkrb5, db, gettext
 , pam, fixDarwinDylibNames, autoreconfHook, enableLdap ? false
 , buildPackages, pruneLibtoolFiles, fetchpatch }:
 
···
   nativeBuildInputs = [ autoreconfHook pruneLibtoolFiles ]
     ++ lib.optional stdenv.hostPlatform.isDarwin fixDarwinDylibNames;
   buildInputs =
-    [ openssl db gettext kerberos ]
+    [ openssl db gettext libkrb5 ]
     ++ lib.optional enableLdap openldap
     ++ lib.optional stdenv.isLinux pam;
 

pkgs/development/libraries/entt/default.nix

···
 { lib, stdenv, fetchFromGitHub, cmake }:
 stdenv.mkDerivation rec {
   pname = "entt";
-  version = "3.6.0";
+  version = "3.7.0";
 
   src = fetchFromGitHub {
     owner = "skypjack";
     repo = "entt";
     rev = "v${version}";
-    sha256 = "sha256-XaQQOt3UekjE4QUUW6+W5M4tkTqeGjZDExJB1U1/gJ8=";
+    sha256 = "sha256-qDjt74nijZhXW7F7GW0CSv6JWOc/kXN7ndbkwSO0+1s=";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/development/libraries/ffmpeg-full/default.nix

···
 , libxcbshapeExtlib ? true # X11 grabbing shape rendering
 , libXv ? null # Xlib support
 , libXext ? null # Xlib support
-, lzma ? null # xz-utils
+, xz ? null # xz-utils
 , nvenc ? !stdenv.isDarwin && !stdenv.isAarch64, nv-codec-headers ? null # NVIDIA NVENC support
 , openal ? null # OpenAL 1.1 capture support
 #, opencl ? null # OpenCL code
···
     (enableFeature libxcbshmExtlib "libxcb-shm")
     (enableFeature libxcbxfixesExtlib "libxcb-xfixes")
     (enableFeature libxcbshapeExtlib "libxcb-shape")
-    (enableFeature (lzma != null) "lzma")
+    (enableFeature (xz != null) "lzma")
     (enableFeature nvenc "nvenc")
     (enableFeature (openal != null) "openal")
     #(enableFeature opencl "opencl")
···
     bzip2 celt dav1d fontconfig freetype frei0r fribidi game-music-emu gnutls gsm
     libjack2 ladspaH lame libaom libass libbluray libbs2b libcaca libdc1394 libmodplug libmysofa
     libogg libopus librsvg libssh libtheora libvdpau libvorbis libvpx libwebp libX11
-    libxcb libXv libXext lzma openal openjpeg libpulseaudio rav1e svt-av1 rtmpdump opencore-amr
+    libxcb libXv libXext xz openal openjpeg libpulseaudio rav1e svt-av1 rtmpdump opencore-amr
     samba SDL2 soxr speex srt vid-stab vo-amrwbenc wavpack x264 x265 xavs xvidcore
     zeromq4 zlib
   ] ++ optionals openglExtlib [ libGL libGLU ]

pkgs/development/libraries/ffmpeg/generic.nix

···
 { lib, stdenv, buildPackages, fetchurl, pkg-config, addOpenGLRunpath, perl, texinfo, yasm
 , alsaLib, bzip2, fontconfig, freetype, gnutls, libiconv, lame, libass, libogg
-, libssh, libtheora, libva, libdrm, libvorbis, libvpx, lzma, libpulseaudio, soxr
+, libssh, libtheora, libva, libdrm, libvorbis, libvpx, xz, libpulseaudio, soxr
 , x264, x265, xvidcore, zlib, libopus, speex, nv-codec-headers, dav1d
 , openglSupport ? false, libGLU ? null, libGL ? null
 , libmfxSupport ? false, intel-media-sdk ? null
···
 
   buildInputs = [
     bzip2 fontconfig freetype gnutls libiconv lame libass libogg libssh libtheora
-    libvorbis lzma soxr x264 x265 xvidcore zlib libopus speex nv-codec-headers
+    libvorbis xz soxr x264 x265 xvidcore zlib libopus speex nv-codec-headers
   ] ++ optionals openglSupport [ libGL libGLU ]
     ++ optional libmfxSupport intel-media-sdk
     ++ optional libaomSupport libaom

pkgs/development/libraries/flatpak/default.nix

···
 , xmlto
 , appstream-glib
 , substituteAll
-, yacc
+, bison
 , xdg-dbus-proxy
 , p11-kit
 , bubblewrap
···
 , fuse
 , nixosTests
 , libsoup
-, lzma
+, xz
 , zstd
 , ostree
 , polkit
···
     pkg-config
     xmlto
     appstream-glib
-    yacc
+    bison
     wrapGAppsNoGuiHook
   ];
 
···
     libcap
     libseccomp
     libsoup
-    lzma
+    xz
     zstd
     polkit
     python3

pkgs/development/libraries/folly/default.nix

···
 , gflags
 , libiberty
 , lz4
-, lzma
+, xz
 , zlib
 , jemalloc
 , openssl
···
     libiberty
     openssl
     lz4
-    lzma
+    xz
     zlib
     jemalloc
     libunwind

pkgs/development/libraries/gnome-online-accounts/default.nix

···
 , docbook_xml_dtd_412
 , gnome3
 , gcr
-, kerberos
+, libkrb5
 , gvfs
 , dbus
 , wrapGAppsHook
···
     gvfs # OwnCloud, Google Drive
     icu
     json-glib
-    kerberos
+    libkrb5
     librest
     libsecret
     libsoup

pkgs/development/libraries/gnutls-kdh/generic.nix

···
 , perl, gmp, autogen, libidn, p11-kit, unbound, libiconv
 , guileBindings ? config.gnutls.guile or false, guile
 , tpmSupport ? true, trousers, nettools, gperftools, gperf, gettext, automake
-, yacc, texinfo
+, bison, texinfo
 
 # Version dependent args
 , version, src, patches ? [], postPatch ? "", nativeBuildInputs ? []
···
   enableParallelBuilding = false;
 
   buildInputs = [ lzo lzip nettle libtasn1 libidn p11-kit zlib gmp
-  autogen gperftools gperf gettext automake yacc texinfo ]
+  autogen gperftools gperf gettext automake bison texinfo ]
     ++ lib.optional doCheck nettools
     ++ lib.optional (stdenv.isFreeBSD || stdenv.isDarwin) libiconv
     ++ lib.optional (tpmSupport && stdenv.isLinux) trousers

pkgs/development/libraries/gsasl/default.nix

···
-{ fetchurl, lib, stdenv, libidn, kerberos }:
+{ fetchurl, lib, stdenv, libidn, libkrb5 }:
 
 stdenv.mkDerivation rec {
   name = "gsasl-1.10.0";
···
     sha256 = "sha256-hby9juYJWt54cCY6KOvLiDL1Qepzk5dUlJJgFcB1aNM=";
   };
 
-  buildInputs = [ libidn kerberos ];
+  buildInputs = [ libidn libkrb5 ];
 
   configureFlags = [ "--with-gssapi-impl=mit" ];
 

pkgs/development/libraries/kde-frameworks/karchive.nix

···
 {
   mkDerivation, lib,
   extra-cmake-modules,
-  bzip2, lzma, qtbase, zlib,
+  bzip2, xz, qtbase, zlib,
 }:
 
 mkDerivation {
···
     broken = builtins.compareVersions qtbase.version "5.14.0" < 0;
   };
   nativeBuildInputs = [ extra-cmake-modules ];
-  buildInputs = [ bzip2 lzma zlib ];
+  buildInputs = [ bzip2 xz zlib ];
   propagatedBuildInputs = [ qtbase ];
   outputs = [ "out" "dev" ];
 }

pkgs/development/libraries/kerberos/heimdal.nix

···
-{ lib, stdenv, fetchFromGitHub, autoreconfHook, pkg-config, python3, perl, yacc, flex
+{ lib, stdenv, fetchFromGitHub, autoreconfHook, pkg-config, python3, perl, bison, flex
 , texinfo, perlPackages
 , openldap, libcap_ng, sqlite, openssl, db, libedit, pam
 , CoreFoundation, Security, SystemConfiguration
···
 
   patches = [ ./heimdal-make-missing-headers.patch ];
 
-  nativeBuildInputs = [ autoreconfHook pkg-config python3 perl yacc flex texinfo ]
+  nativeBuildInputs = [ autoreconfHook pkg-config python3 perl bison flex texinfo ]
     ++ (with perlPackages; [ JSON ]);
   buildInputs = optionals (stdenv.isLinux) [ libcap_ng ]
     ++ [ db sqlite openssl libedit openldap pam]

pkgs/development/libraries/kerberos/krb5.nix

···
-{ lib, stdenv, fetchurl, pkg-config, perl, yacc, bootstrap_cmds
+{ lib, stdenv, fetchurl, pkg-config, perl, bison, bootstrap_cmds
 , openssl, openldap, libedit, keyutils
 
 # Extra Arguments
···
        ];
 
   nativeBuildInputs = [ pkg-config perl ]
-    ++ optional (!libOnly) yacc
+    ++ optional (!libOnly) bison
     # Provides the mig command used by the build scripts
     ++ optional stdenv.isDarwin bootstrap_cmds;
 

pkgs/development/libraries/libaacs/default.nix

···
-{ lib, stdenv, fetchurl, libgcrypt, libgpgerror, yacc, flex }:
+{ lib, stdenv, fetchurl, libgcrypt, libgpgerror, bison, flex }:
 
 # library that allows libbluray to play AACS protected bluray disks
 # libaacs does not infringe DRM's right or copyright. See the legal page of the website for more info.
···
 
   buildInputs = [ libgcrypt libgpgerror ];
 
-  nativeBuildInputs = [ yacc flex ];
+  nativeBuildInputs = [ bison flex ];
 
   meta = with lib; {
     homepage = "https://www.videolan.org/developers/libaacs.html";

pkgs/development/libraries/libdmapsharing/default.nix

···
+{ stdenv
+, lib
+, fetchFromGitLab
+, autoconf
+, automake
+, libtool
+, which
+, pkg-config
+, python3
+, vala
+, avahi
+, gdk-pixbuf
+, gst_all_1
+, glib
+, gtk3
+, libgee
+, check
+, gtk-doc
+, docbook-xsl-nons
+, docbook_xml_dtd_43
+, gobject-introspection
+, libsoup
+}:
+
+stdenv.mkDerivation rec {
+  pname = "libdmapsharing";
+  version = "3.9.10";
+
+  outputs = [ "out" "dev" "devdoc" ];
+  outputBin = "dev";
+
+  src = fetchFromGitLab {
+    domain = "gitlab.gnome.org";
+    owner = "GNOME";
+    repo = pname;
+    rev = "${lib.toUpper pname}_${lib.replaceStrings ["."] ["_"] version}";
+    sha256 = "04y1wjwnbw4pzg05h383d83p6an6ylwy4b4g32jmjxpfi388x33g";
+  };
+
+  nativeBuildInputs = [
+    autoconf
+    automake
+    libtool
+    which
+    pkg-config
+    python3
+    gobject-introspection
+    vala
+    gtk-doc
+    docbook-xsl-nons
+    docbook_xml_dtd_43
+  ];
+
+  buildInputs = [
+    avahi
+    gdk-pixbuf
+    gst_all_1.gstreamer
+    gst_all_1.gst-plugins-base
+  ];
+
+  propagatedBuildInputs = [
+    glib
+    libsoup
+  ];
+
+  checkInputs = [
+    libgee
+    check
+    gtk3
+  ];
+
+  configureFlags = [
+    "--enable-gtk-doc"
+  ];
+
+  # Cannot disable tests here or `check` from checkInputs would not be included.
+  # Cannot disable building the tests or docs will not build:
+  # https://gitlab.gnome.org/GNOME/libdmapsharing/-/issues/49
+  doCheck = true;
+
+  preConfigure = ''
+    NOCONFIGURE=1 ./autogen.sh
+  '';
+
+  # Tests require mDNS server.
+  checkPhase = ":";
+
+  meta = with lib; {
+    homepage = "https://www.flyn.org/projects/libdmapsharing/";
+    description = "Library that implements the DMAP family of protocols";
+    maintainers = teams.gnome.members;
+    license = licenses.lgpl21Plus;
+    platforms = platforms.linux;
+  };
+}

pkgs/development/libraries/libgssglue/default.nix

···
-{ lib, stdenv, fetchurl, kerberos }:
+{ lib, stdenv, fetchurl, libkrb5 }:
 
 stdenv.mkDerivation rec {
   name = "libgssglue-0.4";
···
   postInstall = ''
     mkdir -p $out/etc
     cat <<EOF > $out/etc/gssapi_mech.conf
-    ${kerberos}/lib/libgssapi_krb5.so mechglue_internal_krb5_init
+    ${libkrb5}/lib/libgssapi_krb5.so mechglue_internal_krb5_init
     EOF
   '';
 

pkgs/development/libraries/libpg_query/default.nix

···
+{ lib, stdenv, fetchFromGitHub, which }:
+
+stdenv.mkDerivation rec {
+  pname = "libpg_query";
+  version = "13-2.0.4";
+
+  src = fetchFromGitHub {
+    owner = "pganalyze";
+    repo = "libpg_query";
+    rev = version;
+    sha256 = "0d88fh613kh1izb6w288bfh7s3db4nz8cxyhmhq3lb7gl4axs2pv";
+  };
+
+  nativeBuildInputs = [ which ];
+
+  makeFlags = [ "build" ];
+
+  installPhase = ''
+    install -Dm644 -t $out/lib libpg_query.a
+    install -Dm644 -t $out/include pg_query.h
+  '';
+
+  meta = with lib; {
+    homepage = "https://github.com/pganalyze/libpg_query";
+    description = "C library for accessing the PostgreSQL parser outside of the server environment";
+    changelog = "https://github.com/pganalyze/libpg_query/raw/${version}/CHANGELOG.md";
+    license = licenses.bsd3;
+    platforms = platforms.x86_64;
+    maintainers = [ maintainers.marsam ];
+  };
+}

pkgs/development/libraries/libphonenumber/default.nix

···
-{ lib, stdenv, fetchFromGitHub, cmake, gmock, boost, pkg-config, protobuf, icu }:
+{ lib, stdenv, fetchFromGitHub, cmake, gtest, boost, pkg-config, protobuf, icu }:
 
 stdenv.mkDerivation rec {
   pname = "phonenumber";
···
 
   nativeBuildInputs = [
     cmake
-    gmock
+    gtest
     pkg-config
   ];
 

pkgs/development/libraries/libraspberrypi/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "libraspberrypi";
-  version = "unstable-2020-11-30";
+  version = "unstable-2021-03-17";
 
   src = fetchFromGitHub {
     owner = "raspberrypi";
     repo = "userland";
-    rev = "093b30bbc2fd083d68cc3ee07e6e555c6e592d11";
-    sha256 = "0n2psqyxlsic9cc5s8h65g0blblw3xws4czhpbbgjm58px3822d7";
+    rev = "3fd8527eefd8790b4e8393458efc5f94eb21a615";
+    sha256 = "099qxh4bjzwd431ffpdhzx0gzlrkdyf66wplgkwg2rrfrc9zlv5a";
   };
 
   patches = [

pkgs/development/libraries/librime/default.nix

···
 { lib, stdenv, fetchFromGitHub, cmake, boost, glog, leveldb, marisa, opencc,
-  libyamlcpp, gmock }:
+  libyamlcpp, gtest }:
 
 stdenv.mkDerivation rec {
   pname = "librime";
···
 
   nativeBuildInputs = [ cmake ];
 
-  buildInputs = [ boost glog leveldb marisa opencc libyamlcpp gmock ];
+  buildInputs = [ boost glog leveldb marisa opencc libyamlcpp gtest ];
 
   meta = with lib; {
     homepage    = "https://rime.im/";

pkgs/development/libraries/libticalcs2/default.nix

···
 , libticonv
 , libtifiles2
 , libticables2
-, lzma
+, xz
 , bzip2
 , acl
 , libobjc
···
     libticonv
     libtifiles2
     libticables2
-    lzma
+    xz
     bzip2
   ] ++ lib.optionals stdenv.isLinux [
     acl

pkgs/development/libraries/libvirt/5.9.0.nix

···
 { lib, stdenv, fetchurl, fetchgit
 , pkg-config, makeWrapper, libtool, autoconf, automake, fetchpatch
 , coreutils, libxml2, gnutls, perl, python2, attr
-, iproute, iptables, readline, lvm2, util-linux, systemd, libpciaccess, gettext
+, iproute2, iptables, readline, lvm2, util-linux, systemd, libpciaccess, gettext
 , libtasn1, ebtables, libgcrypt, yajl, pmutils, libcap_ng, libapparmor
 , dnsmasq, libnl, libpcap, libxslt, xhtml1, numad, numactl, perlPackages
 , curl, libiconv, gmp, zfs, parted, bridge-utils, dmidecode, glib, rpcsvc-proto, libtirpc
···
 
   preConfigure = ''
     ${ optionalString (!buildFromTarball) "./bootstrap --no-git --gnulib-srcdir=$(pwd)/.gnulib" }
-    PATH=${lib.makeBinPath ([ dnsmasq ] ++ optionals stdenv.isLinux [ iproute iptables ebtables lvm2 systemd numad ] ++ optionals enableIscsi [ openiscsi ])}:$PATH
+    PATH=${lib.makeBinPath ([ dnsmasq ] ++ optionals stdenv.isLinux [ iproute2 iptables ebtables lvm2 systemd numad ] ++ optionals enableIscsi [ openiscsi ])}:$PATH
     # the path to qemu-kvm will be stored in VM's .xml and .save files
     # do not use "''${qemu_kvm}/bin/qemu-kvm" to avoid bound VMs to particular qemu derivations
     substituteInPlace src/lxc/lxc_conf.c \
···
 
 
   postInstall = let
-    binPath = [ iptables iproute pmutils numad numactl bridge-utils dmidecode dnsmasq ebtables ] ++ optionals enableIscsi [ openiscsi ];
+    binPath = [ iptables iproute2 pmutils numad numactl bridge-utils dmidecode dnsmasq ebtables ] ++ optionals enableIscsi [ openiscsi ];
   in ''
     substituteInPlace $out/libexec/libvirt-guests.sh \
       --replace 'ON_BOOT=start'       'ON_BOOT=''${ON_BOOT:-start}' \

pkgs/development/libraries/libvirt/default.nix

···
 { lib, stdenv, fetchurl, fetchgit
 , makeWrapper, autoreconfHook, fetchpatch
 , coreutils, libxml2, gnutls, perl, python3, attr, glib, docutils
-, iproute, readline, lvm2, util-linux, systemd, libpciaccess, gettext
+, iproute2, readline, lvm2, util-linux, systemd, libpciaccess, gettext
 , libtasn1, iptables, ebtables, libgcrypt, yajl, pmutils, libcap_ng, libapparmor
 , dnsmasq, libnl, libpcap, libxslt, xhtml1, numad, numactl, perlPackages
 , curl, libiconv, gmp, zfs, parted, bridge-utils, dmidecode, dbus, libtirpc, rpcsvc-proto, darwin
···
       sed -i meson.build -e "s|conf.set_quoted('${var}',.*|conf.set_quoted('${var}','${value}')|"
     '';
   in ''
-    PATH=${lib.makeBinPath ([ dnsmasq ] ++ optionals stdenv.isLinux [ iproute iptables ebtables-compat lvm2 systemd numad ] ++ optionals enableIscsi [ openiscsi ])}:$PATH
+    PATH=${lib.makeBinPath ([ dnsmasq ] ++ optionals stdenv.isLinux [ iproute2 iptables ebtables-compat lvm2 systemd numad ] ++ optionals enableIscsi [ openiscsi ])}:$PATH
     # the path to qemu-kvm will be stored in VM's .xml and .save files
     # do not use "''${qemu_kvm}/bin/qemu-kvm" to avoid bound VMs to particular qemu derivations
     substituteInPlace src/lxc/lxc_conf.c \
···
 
   postInstall = let
     # Keep the legacy iptables binary for now for backwards compatibility (comment on #109332)
-    binPath = [ iptables ebtables-compat iproute pmutils numad numactl bridge-utils dmidecode dnsmasq ] ++ optionals enableIscsi [ openiscsi ];
+    binPath = [ iptables ebtables-compat iproute2 pmutils numad numactl bridge-utils dmidecode dnsmasq ] ++ optionals enableIscsi [ openiscsi ];
   in ''
     substituteInPlace $out/libexec/libvirt-guests.sh \
       --replace 'ON_BOOT="start"'       'ON_BOOT=''${ON_BOOT:-start}' \

pkgs/development/libraries/libxkbcommon/default.nix

···
-{ lib, stdenv, fetchurl, meson, ninja, pkg-config, yacc, doxygen
+{ lib, stdenv, fetchurl, meson, ninja, pkg-config, bison, doxygen
 , xkeyboard_config, libxcb, libxml2
 , python3
 , libX11
···
 
   outputs = [ "out" "dev" "doc" ];
 
-  nativeBuildInputs = [ meson ninja pkg-config yacc doxygen ]
+  nativeBuildInputs = [ meson ninja pkg-config bison doxygen ]
     ++ lib.optional withWaylandSupport wayland;
   buildInputs = [ xkeyboard_config libxcb libxml2 ]
     ++ lib.optionals withWaylandSupport [ wayland wayland-protocols ];

pkgs/development/libraries/libxkbcommon/libxkbcommon_7.nix

···
-{ lib, stdenv, fetchurl, pkg-config, yacc, flex, xkeyboard_config, libxcb, libX11 }:
+{ lib, stdenv, fetchurl, pkg-config, bison, flex, xkeyboard_config, libxcb, libX11 }:
 
 stdenv.mkDerivation rec {
   name = "libxkbcommon-0.7.2";
···
   outputs = [ "out" "dev" ];
 
   nativeBuildInputs = [ pkg-config ];
-  buildInputs = [ yacc flex xkeyboard_config libxcb ];
+  buildInputs = [ bison flex xkeyboard_config libxcb ];
 
   configureFlags = [
     "--with-xkb-config-root=${xkeyboard_config}/etc/X11/xkb"

pkgs/development/libraries/physics/yoda/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "yoda";
-  version = "1.8.5";
+  version = "1.9.0";
 
   src = fetchurl {
     url = "https://www.hepforge.org/archive/yoda/YODA-${version}.tar.bz2";
-    sha256 = "1z9jmabsaddhs003zzq73fpq2absd12rnc2sa5qn45zwf62nnbjc";
+    sha256 = "1x7xi6w7lb92x8202kbaxgqg1sly534wana4f38l3gpbzw9dwmcs";
   };
 
   nativeBuildInputs = with python.pkgs; [ cython makeWrapper ];
···
     homepage    = "https://yoda.hepforge.org";
     platforms   = lib.platforms.unix;
     maintainers = with lib.maintainers; [ veprbl ];
-    # https://gitlab.com/hepcedar/yoda/-/issues/24
-    broken      = withRootSupport;
   };
 }

pkgs/development/libraries/protobuf/generic-v3.nix

···
 { lib, stdenv
 , fetchFromGitHub
-, autoreconfHook, zlib, gmock, buildPackages
+, autoreconfHook, zlib, gtest, buildPackages
 , version, sha256
 , ...
 }:
···
 
   postPatch = ''
     rm -rf gmock
-    cp -r ${gmock.src}/googlemock gmock
-    cp -r ${gmock.src}/googletest googletest
+    cp -r ${gtest.src}/googlemock gmock
+    cp -r ${gtest.src}/googletest googletest
     chmod -R a+w gmock
     chmod -R a+w googletest
     ln -s ../googletest gmock/gtest

pkgs/development/libraries/pupnp/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "libupnp";
-  version = "1.14.2";
+  version = "1.14.4";
 
   outputs = [ "out" "dev" ];
 
···
     owner = "mrjimenez";
     repo = "pupnp";
     rev = "release-${version}";
-    sha256 = "sha256-PVlmAtiozF1dqgXsRXPuDY13TchHdb0UnK6mam4chBE=";
+    sha256 = "sha256-4VuTbcEjr9Ffrowb3eOtXFU8zPNu1NXS531EOZpI07A=";
   };
 
   nativeBuildInputs = [

pkgs/development/libraries/rabbitmq-c/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "rabbitmq-c";
-  version = "0.10.0";
+  version = "0.11.0";
 
   src = fetchFromGitHub {
     owner = "alanxz";
     repo = "rabbitmq-c";
     rev = "v${version}";
-    sha256 = "1iv7aww4pam8497s524xjxbbxypyqd01qgrb0b429y3q9x06m4sw";
+    sha256 = "sha256-u1uOrZRiQOU/6vlLdQHypBRSCo3zw7FC1AI9v3NlBVE=";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/development/libraries/science/biology/htslib/default.nix

···
-{ lib, stdenv, fetchurl, zlib, bzip2, lzma, curl, perl }:
+{ lib, stdenv, fetchurl, zlib, bzip2, xz, curl, perl }:
 
 stdenv.mkDerivation rec {
   pname = "htslib";
···
   # perl is only used during the check phase.
   nativeBuildInputs = [ perl ];
 
-  buildInputs = [ zlib bzip2 lzma curl ];
+  buildInputs = [ zlib bzip2 xz curl ];
 
   configureFlags = [ "--enable-libcurl" ]; # optional but strongly recommended
 

pkgs/development/libraries/serf/default.nix

···
-{ lib, stdenv, fetchurl, apr, scons, openssl, aprutil, zlib, kerberos
+{ lib, stdenv, fetchurl, apr, scons, openssl, aprutil, zlib, libkrb5
 , pkg-config, libiconv }:
 
 stdenv.mkDerivation rec {
···
 
   nativeBuildInputs = [ pkg-config scons ];
   buildInputs = [ apr openssl aprutil zlib libiconv ]
-    ++ lib.optional (!stdenv.isCygwin) kerberos;
+    ++ lib.optional (!stdenv.isCygwin) libkrb5;
 
   patches = [ ./scons.patch ];
 
···
     sconsFlags+=" OPENSSL=${openssl}"
     sconsFlags+=" ZLIB=${zlib}"
   '' + lib.optionalString (!stdenv.isCygwin) ''
-    sconsFlags+=" GSSAPI=${kerberos.dev}"
+    sconsFlags+=" GSSAPI=${libkrb5.dev}"
   '';
 
   enableParallelBuilding = true;

pkgs/development/libraries/simdjson/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "simdjson";
-  version = "0.9.1";
+  version = "0.9.2";
 
   src = fetchFromGitHub {
     owner = "simdjson";
     repo = "simdjson";
     rev = "v${version}";
-    sha256 = "sha256-e9Y5QEs9xqfJpaWxnA6iFwHE6TTGyVM7hfFuMEmpW78=";
+    sha256 = "sha256-L/a/vTthh7XkiwuvlGk9q+uLEBf8vaPoV1x1fG44zeg=";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/development/libraries/sope/default.nix

···
 { gnustep, lib, fetchFromGitHub , libxml2, openssl_1_1
-, openldap, mysql, libmysqlclient, postgresql }:
+, openldap, mariadb, libmysqlclient, postgresql }:
 with lib;
 
 gnustep.stdenv.mkDerivation rec {
···
   nativeBuildInputs = [ gnustep.make ];
   buildInputs = flatten ([ gnustep.base libxml2 openssl_1_1 ]
     ++ optional (openldap != null) openldap
-    ++ optionals (mysql != null) [ libmysqlclient mysql ]
+    ++ optionals (mariadb != null) [ libmysqlclient mariadb ]
     ++ optional (postgresql != null) postgresql);
 
   postPatch = ''
···
 
   configureFlags = [ "--prefix=" "--disable-debug" "--enable-xml" "--with-ssl=ssl" ]
     ++ optional (openldap != null) "--enable-openldap"
-    ++ optional (mysql != null) "--enable-mysql"
+    ++ optional (mariadb != null) "--enable-mysql"
     ++ optional (postgresql != null) "--enable-postgresql";
 
   # Yes, this is ugly.

pkgs/development/libraries/tpm2-tss/default.nix

···
 { stdenv, lib, fetchFromGitHub
 , autoreconfHook, autoconf-archive, pkg-config, doxygen, perl
 , openssl, json_c, curl, libgcrypt
-, cmocka, uthash, ibm-sw-tpm2, iproute, procps, which
+, cmocka, uthash, ibm-sw-tpm2, iproute2, procps, which
 }:
 
 stdenv.mkDerivation rec {
···
   ];
   buildInputs = [ openssl json_c curl libgcrypt ];
   checkInputs = [
-    cmocka uthash ibm-sw-tpm2 iproute procps which
+    cmocka uthash ibm-sw-tpm2 iproute2 procps which
   ];
 
   preAutoreconf = "./bootstrap";

pkgs/development/libraries/unixODBCDrivers/default.nix

···
-{ fetchurl, stdenv, unixODBC, cmake, postgresql, mysql, sqlite, zlib, libxml2, dpkg, lib, openssl, kerberos, libuuid, patchelf, libiconv, fetchFromGitHub }:
+{ fetchurl, stdenv, unixODBC, cmake, postgresql, mariadb, sqlite, zlib, libxml2, dpkg, lib, openssl, libkrb5, libuuid, patchelf, libiconv, fetchFromGitHub }:
 
 # I haven't done any parameter tweaking.. So the defaults provided here might be bad
 
···
     };
 
     nativeBuildInputs = [ cmake ];
-    buildInputs = [ unixODBC mysql ];
+    buildInputs = [ unixODBC mariadb ];
 
     cmakeFlags = [ "-DWITH_UNIXODBC=1" ];
 
···
     '';
 
     postFixup = ''
-      patchelf --set-rpath ${lib.makeLibraryPath [ unixODBC openssl.out kerberos libuuid stdenv.cc.cc ]} \
+      patchelf --set-rpath ${lib.makeLibraryPath [ unixODBC openssl.out libkrb5 libuuid stdenv.cc.cc ]} \
         $out/lib/libmsodbcsql-${versionMajor}.${versionMinor}.so.${versionAdditional}
     '';
 

pkgs/development/libraries/uriparser/default.nix

···
-{ lib, stdenv, fetchurl, fetchpatch, cmake, gtest }:
+{ lib, stdenv, fetchurl, cmake, gtest }:
 
 stdenv.mkDerivation rec {
   pname = "uriparser";
-  version = "0.9.4";
+  version = "0.9.5";
 
   # Release tarball differs from source tarball
   src = fetchurl {
     url = "https://github.com/uriparser/uriparser/releases/download/${pname}-${version}/${pname}-${version}.tar.bz2";
-    sha256 = "0yzqp1j6sglyrmwcasgn7zlwg841p3nbxy0h78ngq20lc7jspkdp";
+    sha256 = "0v30qr5hl3xybl9nzwaw46kblwn94w5xpri22wanrrpjlzmn306x";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/development/ocaml-modules/gnuplot/default.nix

···
   pname = "gnuplot";
   version = "0.7";
 
+  useDune2 = true;
+
   minimumOCamlVersion = "4.03";
 
   src = fetchFromGitHub {

pkgs/development/ocaml-modules/mimic/default.nix

···
 
 buildDunePackage rec {
   pname = "mimic";
-  version = "0.0.1";
+  version = "0.0.2";
 
   minimumOCamlVersion = "4.08";
   useDune2 = true;
 
   src = fetchurl {
     url = "https://github.com/mirage/ocaml-git/releases/download/${pname}-v${version}/${pname}-${pname}-v${version}.tbz";
-    sha256 = "0j4l99sgm5mdmv67vakkz2pw45l6i89bpza88xqkgmskfk50c5pk";
+    sha256 = "3ad5af3caa1120ecfdf022de41ba5be8edfbf50270fc99238b82d3d2d6e7c317";
   };
 
   # don't install changelogs for other packages
···
     mirage-flow
     result
     rresult
-    cstruct
     logs
   ];
 
···
     alcotest-lwt
     bigstringaf
     bigarray-compat
+    cstruct
     ke
   ];
 

pkgs/development/ocaml-modules/minisat/default.nix

···
 
 buildDunePackage rec {
   pname = "minisat";
-  version = "0.2";
+  version = "0.3";
+
+  useDune2 = true;
 
   minimumOCamlVersion = "4.05";
 
   src = fetchFromGitHub {
     owner  = "c-cube";
     repo   = "ocaml-minisat";
-    rev    = version;
-    sha256 = "1jibylmb1ww0x42n6wl8bdwicaysgxp0ag244x7w5m3jifq3xs6q";
+    rev    = "v${version}";
+    sha256 = "01wggbziqz5x6d7mwdl40sbf6qal7fd853b224zjf9n0kzzsnczh";
   };
 
   meta = {

pkgs/development/ocaml-modules/mirage-crypto/default.nix

···
   minimumOCamlVersion = "4.08";
 
   pname = "mirage-crypto";
-  version = "0.9.0";
+  version = "0.9.1";
 
   src = fetchurl {
     url = "https://github.com/mirage/mirage-crypto/releases/download/v${version}/mirage-crypto-v${version}.tbz";
-    sha256 = "716684f8a70031f16115e3c84d42141c75fb1e688b7a699bbd09166176ed5217";
+    sha256 = "53e0ae90f19651ab7f09156557ea5ec07bce7a52468ec6687471e0333f3e2133";
   };
 
   useDune2 = true;

pkgs/development/ocaml-modules/opti/default.nix

···
   pname = "opti";
   version = "1.0.3";
 
+  useDune2 = true;
+
   minimumOCamlVersion = "4.02";
 
   src = fetchurl {

pkgs/development/ocaml-modules/parmap/default.nix

···
-{ lib, buildDunePackage, fetchurl }:
+{ lib, buildDunePackage, fetchurl, dune-configurator }:
 
 buildDunePackage rec {
   pname = "parmap";
   version = "1.2";
 
+  useDune2 = true;
+
   src = fetchurl {
     url = "https://github.com/rdicosmo/${pname}/releases/download/${version}/${pname}-${version}.tbz";
     sha256 = "sha256-XUXptzD0eytaypaBQ+EBp4iVFRE6/Y0inS93t/YZrM8=";
   };
+
+  buildInputs = [ dune-configurator ];
 
   doCheck = true;
 

pkgs/development/ocaml-modules/pbkdf/default.nix

···
+{ lib
+, buildDunePackage
+, fetchurl
+, mirage-crypto
+, alcotest
+}:
+
+buildDunePackage rec {
+  pname = "pbkdf";
+  version = "1.1.0";
+
+  useDune2 = true;
+
+  src = fetchurl {
+    url = "https://github.com/abeaumont/ocaml-pbkdf/releases/download/${version}/pbkdf-${version}.tbz";
+    sha256 = "e53ed1bd9abf490c858a341c10fb548bc9ad50d4479acdf95a9358a73d042264";
+  };
+
+  propagatedBuildInputs = [ mirage-crypto ];
+  checkInputs = [ alcotest ];
+  doCheck = true;
+
+  meta = {
+    description = "Password based key derivation functions (PBKDF) from PKCS#5";
+    maintainers = [ lib.maintainers.sternenseemann ];
+    license = lib.licenses.bsd2;
+    homepage = "https://github.com/abeaumont/ocaml-pbkdf";
+  };
+}
+

pkgs/development/perl-modules/Net-CIDR-Lite-prevent-leading-zeroes-ipv4.patch

···
-From 734d31aa2f65b69f5558b9b0dd67af0461ca7f80 Mon Sep 17 00:00:00 2001
-From: Stig Palmquist <[e-mail]>
-Date: Tue, 30 Mar 2021 12:13:37 +0200
-Subject: [PATCH] Security: Prevent leading zeroes in ipv4 octets
-
-https://blog.urth.org/2021/03/29/security-issues-in-perl-ip-address-distros/
-Related to CVE-2021-28918
----
- Lite.pm  |  2 +-
- t/base.t | 13 ++++++++++++-
- 2 files changed, 13 insertions(+), 2 deletions(-)
-
-diff --git a/Lite.pm b/Lite.pm
-index fd6df73..d44f881 100644
---- a/Lite.pm
-+++ b/Lite.pm
-@@ -181,7 +181,7 @@ sub _pack_ipv4 {
-     my @nums = split /\./, shift(), -1;
-     return unless @nums == 4;
-     for (@nums) {
--        return unless /^\d{1,3}$/ and $_ <= 255;
-+        return unless /^\d{1,3}$/ and !/^0\d{1,2}$/ and $_ <= 255;
-     }
-     pack("CC*", 0, @nums);
- }
-diff --git a/t/base.t b/t/base.t
-index cf32c5e..292456d 100644
---- a/t/base.t
-+++ b/t/base.t
-@@ -8,7 +8,7 @@
- use Test;
- use strict;
- $|++;
--BEGIN { plan tests => 39 };
-+BEGIN { plan tests => 42 };
- use Net::CIDR::Lite;
- ok(1); # If we made it this far, we are ok.
- 
-@@ -133,3 +133,14 @@ ok(join(', ', @list_short_range), '10.0.0.1-2, 10.0.0.5');
- })->list_short_range;
- ok(join(', ', @list_short_range), '10.0.0.250-255, 10.0.1.0-20, 10.0.1.22, 10.0.2.250-255, 10.0.3.0-255, 10.0.4.0-255, 10.0.5.0-8');
- 
-+
-+# Tests for vulnerability: https://blog.urth.org/2021/03/29/security-issues-in-perl-ip-address-distros/
-+eval { Net::CIDR::Lite->new("010.0.0.0/8") };
-+ok($@=~/Can't determine ip format/);
-+
-+my $err_octal = Net::CIDR::Lite->new;
-+eval { $err_octal->add("010.0.0.0/8") };
-+ok($@=~/Can't determine ip format/);
-+
-+eval { $err_octal->add("10.01.0.0/8") };
-+ok($@=~/Can't determine ip format/);

pkgs/development/python-modules/adafruit-platformdetect/default.nix

···
 
 buildPythonPackage rec {
   pname = "adafruit-platformdetect";
-  version = "3.4.1";
+  version = "3.5.0";
 
   src = fetchPypi {
     pname = "Adafruit-PlatformDetect";
     inherit version;
-    sha256 = "31275dcf949c8b00598aaf2b0da65d970a0cba28e7cb45691d5f354b8e82fe85";
+    sha256 = "sha256-QJeb9+iiS4QZ7poOBp5oKD5KuagkG6cfTalbNRwrI1M=";
   };
 
   nativeBuildInputs = [ setuptools-scm ];

pkgs/development/python-modules/aiosmtpd/default.nix

···
 { lib, isPy3k, fetchFromGitHub, buildPythonPackage
-, atpublic }:
+, attrs, atpublic }:
 
 buildPythonPackage rec {
   pname = "aiosmtpd";
-  version = "1.2.1";
+  version = "1.4.2";
   disabled = !isPy3k;
 
   # Release not published to Pypi
···
     owner = "aio-libs";
     repo = pname;
     rev = version;
-    sha256 = "14c30dm6jzxiblnsah53fdv68vqhxwvb9x0aq9bc4vcdas747vr7";
+    sha256 = "0hbpyns1j1fpvpj7gyb8cz359j7l4hzfqbig74xp4xih59sih0wj";
   };
 
   propagatedBuildInputs = [
-    atpublic
+    atpublic attrs
   ];
 
   # Tests need network access

pkgs/development/python-modules/backports_lzma/default.nix

···
 , buildPythonPackage
 , fetchPypi
 , isPy3k
-, lzma
+, xz
 , python
 , pythonOlder
 }:
···
     sha256 = "16d8b68e4d3cd4e6c9ddb059850452946da3914c8a8e197a7f2b0954559f2df4";
   };
 
-  buildInputs = [ lzma ];
+  buildInputs = [ xz ];
 
   checkPhase = ''
     ${python.interpreter} test/test_lzma.py

pkgs/development/python-modules/binwalk/default.nix

···
 , cramfsswap
 , sasquatch
 , squashfsTools
-, lzma
 , matplotlib
 , nose
 , pycrypto
···
     sha256 = "1bxgj569fzwv6jhcbl864nmlsi9x1k1r20aywjxc8b9b1zgqrlvc";
   };
 
-  propagatedBuildInputs = [ zlib xz ncompress gzip bzip2 gnutar p7zip cabextract squashfsTools lzma pycrypto ]
+  propagatedBuildInputs = [ zlib xz ncompress gzip bzip2 gnutar p7zip cabextract squashfsTools xz pycrypto ]
   ++ lib.optionals visualizationSupport [ matplotlib pyqtgraph ]
   ++ lib.optionals (!stdenv.isDarwin) [ cramfsprogs cramfsswap sasquatch ];
 

pkgs/development/python-modules/cairocffi/default.nix

···
 , glibcLocales
 , cairo
 , cffi
+, numpy
 , withXcffib ? false, xcffib
 , python
 , glib
···
 }@args:
 
 import ./generic.nix ({
-  version = "1.1.0";
-  sha256 = "1nq53f5jipgy9jgyfxp43j40qfbmrhgn1cj8bp5rrb3liy3wbh7i";
+  version = "1.2.0";
+  sha256 = "sha256-mpebUAxkyBef7ChvM36P5kTsovLNBYYM4LYtJfIuoUA=";
   dlopen_patch = ./dlopen-paths.patch;
   disabled = pythonOlder "3.5";
   inherit withXcffib;

pkgs/development/python-modules/cairocffi/generic.nix

···
     fontDirectories = [ freefont_ttf ];
   };
 
-  checkInputs = [ pytest pytestrunner glibcLocales ];
+  checkInputs = [ numpy pytest pytestrunner glibcLocales ];
   propagatedBuildInputs = [ cairo cffi ] ++ lib.optional withXcffib xcffib;
 
   checkPhase = ''

pkgs/development/python-modules/configargparse/default.nix

···
 }:
 
 buildPythonPackage rec {
-  pname = "ConfigArgParse";
-  version = "1.3";
+  pname = "configargparse";
+  version = "1.4";
 
   src = fetchFromGitHub {
     owner = "bw2";
-    repo = pname;
-    rev = version;
-    sha256 = "147x781lgahn9r3gbhayhx1pf0iysf7q1hnr3kypy3p2k9v7a9mh";
+    repo = "ConfigArgParse";
+    rev = "v${version}";
+    sha256 = "0x6ar7d8qhr7gb1s8asbhqymg9jd635h7cyczqrbmvm8689zhj1d";
   };
 
   checkInputs = [

pkgs/development/python-modules/crytic-compile/default.nix

···
 
 buildPythonPackage rec {
   pname = "crytic-compile";
-  version = "0.1.12";
+  version = "0.1.13";
 
   disabled = pythonOlder "3.6";
 
···
     owner = "crytic";
     repo = "crytic-compile";
     rev = version;
-    sha256 = "1q75n84yxv2cb6x7gqyk3vcwkxpq7pni30wgz3d1bk6pmi2pqgw6";
+    sha256 = "sha256-KJRfkUyUI0M7HevY4XKOtCvU+SFlsJIl3kTIccWfNmw=";
   };
 
   propagatedBuildInputs = [ pysha3 setuptools ];

pkgs/development/python-modules/deeptoolsintervals/default.nix

···
 , fetchPypi
 , pytest
 , zlib
-, lzma
+, xz
 }:
 
 buildPythonPackage rec {
···
     sha256 = "1xnl80nblysj6dylj4683wgrfa425rkx4dp5k65hvwdns9pw753x";
   };
 
-  buildInputs = [ zlib lzma ];
+  buildInputs = [ zlib xz ];
 
   checkInputs = [ pytest ];
 

pkgs/development/python-modules/discordpy/default.nix

···
 
 buildPythonPackage rec {
   pname = "discord.py";
-  version = "1.6.0";
+  version = "1.7.0";
   disabled = pythonOlder "3.5.3";
 
   # only distributes wheels on pypi now
···
     owner = "Rapptz";
     repo = pname;
     rev = "v${version}";
-    sha256 = "036prc4iw91qx31zz48hy3b30kn2qnlg68lgrvv2mcvsjxf2gd1l";
+    sha256 = "1i5k2qb894rjksn21pk9shash1y7v4138rkk8mqr1a1yvgnr5ibg";
   };
 
   propagatedBuildInputs = [ aiohttp websockets ];
   patchPhase = ''
     substituteInPlace "requirements.txt" \
-      --replace "aiohttp>=3.6.0,<3.7.0" "aiohttp" \
       --replace "websockets>=6.0,!=7.0,!=8.0,!=8.0.1,<9.0" "websockets"
   '' + lib.optionalString withVoice ''
     substituteInPlace "discord/opus.py" \

pkgs/development/python-modules/docx2python/default.nix

···
+{ lib, buildPythonPackage, fetchFromGitHub, pytestCheckHook }:
+
+buildPythonPackage rec {
+  pname = "docx2python";
+  version = "unstable-2020-11-15";
+
+  # Pypi does not contain tests
+  src = fetchFromGitHub {
+    owner = "ShayHill";
+    repo = pname;
+    rev = "21b2edafc0a01a6cfb73aefc61747a65917e2cad";
+    sha256 = "1nwg17ziwm9a2x7yxsscj8zgc1d383ifsk5w7qa2fws6gf627kyi";
+  };
+
+  preCheck = "cd test"; # Tests require the `test/resources` folder to be accessible
+  checkInputs = [ pytestCheckHook ];
+  disabledTests = [ # asserts related to file deletions fail
+    "test_docx2python.py"
+    "test_docx_context.py"
+    "test_google_docs.py"
+  ];
+  pythonImportsCheck = [ "docx2python" ];
+
+  meta = with lib; {
+    homepage = "https://github.com/ShayHill/docx2python";
+    description = "Extract docx headers, footers, (formatted) text, footnotes, endnotes, properties, and images";
+    maintainers = [ maintainers.ivar ];
+    license = licenses.mit;
+  };
+}

pkgs/development/python-modules/exdown/default.nix

···
 
 buildPythonPackage rec {
   pname = "exdown";
-  version = "0.8.5";
+  version = "0.8.6";
   format = "pyproject";
 
   disabled = isPy27;
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1ly67whyfn74nr0dncarf3xbd96hacvzgjihx4ibckkc4h9z46bj";
+    sha256 = "sha256-BCn+rkMxQSw/gO+dpzgpYSOqEiooWFzSh7LUYIFr6wE=";
   };
 
   propagatedBuildInputs = lib.optionals (pythonOlder "3.8") [ importlib-metadata ];

pkgs/development/python-modules/fiona/default.nix

···
 , attrs, click, cligj, click-plugins, six, munch, enum34
 , pytest, boto3, mock, giflib, pytz
 , gdal_2 # can't bump to 3 yet, https://github.com/Toblerity/Fiona/issues/745
+, certifi
 }:
 
 buildPythonPackage rec {
···
 
   propagatedBuildInputs = [
     attrs
+    certifi
     click
     cligj
     click-plugins

pkgs/development/python-modules/fipy/default.nix

···
 { lib
 , buildPythonPackage
-, fetchPypi
 , numpy
 , scipy
 , pyamg
···
 , fetchurl
 }:
 
-let
-  not_darwin_inputs = lib.optionals (! stdenv.isDarwin) [ gmsh ];
-in
-  buildPythonPackage rec {
-    pname = "fipy";
-    version = "3.4.1";
+buildPythonPackage rec {
+  pname = "fipy";
+  version = "3.4.2.1";
 
-    src = fetchurl {
-      url = "https://github.com/usnistgov/fipy/releases/download/${version}/FiPy-${version}.tar.gz";
-      sha256 = "0078yg96fknqhywn1v26ryc5z47c0j0c1qwz6p8wsjn0wmzggaqk";
-    };
+  src = fetchurl {
+    url = "https://github.com/usnistgov/fipy/releases/download/${version}/FiPy-${version}.tar.gz";
+    sha256 = "0v5yk9b4hksy3176w4vm4gagb9kxqgv75zcyswlqvl371qwy1grk";
+  };
 
-    propagatedBuildInputs = [
-      numpy
-      scipy
-      pyamg
-      matplotlib
-      tkinter
-      mpi4py
-      future
-      scikit-fmm
-      openssh
-    ] ++ lib.optionals isPy27 [ pysparse ] ++ not_darwin_inputs;
+  propagatedBuildInputs = [
+    numpy
+    scipy
+    pyamg
+    matplotlib
+    tkinter
+    mpi4py
+    future
+    scikit-fmm
+    openssh
+  ] ++ lib.optionals isPy27 [ pysparse ]
+  ++ lib.optionals (!stdenv.isDarwin) [ gmsh ];
 
-    checkInputs = not_darwin_inputs;
-
-    checkPhase = ''
-      export OMPI_MCA_plm_rsh_agent=${openssh}/bin/ssh
-      ${python.interpreter} setup.py test --modules
-    '';
+  checkPhase = ''
+    export OMPI_MCA_plm_rsh_agent=${openssh}/bin/ssh
+    ${python.interpreter} setup.py test --modules
+  '';
 
-    meta = with lib; {
-      homepage = "https://www.ctcms.nist.gov/fipy/";
-      description = "A Finite Volume PDE Solver Using Python";
-      license = licenses.free;
-      maintainers = with maintainers; [ costrouc wd15 ];
-    };
-  }
+  meta = with lib; {
+    homepage = "https://www.ctcms.nist.gov/fipy/";
+    description = "A Finite Volume PDE Solver Using Python";
+    license = licenses.free;
+    maintainers = with maintainers; [ costrouc wd15 ];
+  };
+}

pkgs/development/python-modules/freebox-api/default.nix

···
 , aiohttp
 , buildPythonPackage
 , fetchFromGitHub
-, poetry
+, fetchpatch
+, importlib-metadata
+, poetry-core
+, pytestCheckHook
 , pythonOlder
-, pytestCheckHook
 }:
 
 buildPythonPackage rec {
   pname = "freebox-api";
-  version = "0.0.9";
+  version = "0.0.10";
   format = "pyproject";
-  disabled = pythonOlder "3.6";
+  disabled = pythonOlder "3.7";
 
   src = fetchFromGitHub {
     owner = "hacf-fr";
     repo = pname;
     rev = "v${version}";
-    sha256 = "0qn7jqfbp850aqgfsxjfv14myi6idz6sf7024p6wpqpa2xk0vfiq";
+    sha256 = "sha256-yUcHdSHSgWxZl0z7Ue0MestvGhiXkDsxArNoDk0ZkR4=";
   };
 
-  nativeBuildInputs = [ poetry ];
+  patches = [
+    # Switch to poetry-core, https://github.com/hacf-fr/freebox-api/pull/187
+    (fetchpatch {
+      name = "switch-to-poetry-core.patch";
+      url = "https://github.com/hacf-fr/freebox-api/commit/07356ac65483bc24fb1ed32612e77f2c2eed0134.patch";
+      sha256 = "1zwricrwsqy01pmhrjy41gh4kxb3gki8z8yxlpywd66y7gid547r";
+    })
+  ];
 
-  propagatedBuildInputs = [ aiohttp ];
+  nativeBuildInputs = [
+    poetry-core
+  ];
+
+  propagatedBuildInputs = [
+    aiohttp
+  ] ++ lib.optionals (pythonOlder "3.8") [ importlib-metadata ];
 
-  checkInputs = [ pytestCheckHook ];
+  checkInputs = [
+    pytestCheckHook
+  ];
+
   pythonImportsCheck = [ "freebox_api" ];
 
   meta = with lib; {

pkgs/development/python-modules/google-api-core/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-api-core";
-  version = "1.25.1";
+  version = "1.26.3";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0e152ec37b8481d1be1258d95844a5a7031cd3d83d7c7046d9e9b2d807042440";
+    sha256 = "sha256-uRQ0XH6iOGEWJpOidwO6uASlVQT35umryv8XTYDfMqw=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/google-auth-httplib2/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-auth-httplib2";
-  version = "0.0.4";
+  version = "0.1.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0fdwnx2yd65f5vhnmn39f4xnxac5j6x0pv2p42qifrdi1z32q2cd";
+    sha256 = "sha256-oHw5/WMr7KzT8HcY39YCG/OWl48DrTzkMh0GABXMMKw=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/google-auth-oauthlib/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-auth-oauthlib";
-  version = "0.4.2";
+  version = "0.4.4";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1nai9k86g7g7w1pxk105dllncgax8nc5hpmk758b3jnqkb1mpdk5";
+    sha256 = "sha256-CYMsbnUDL5OBjt8a/+R0YSHWQMYlpb75tclq9nbpju4=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/google-auth/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-auth";
-  version = "1.24.0";
+  version = "1.28.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0bmdqkyv8k8n6s8dss4zpbcq1cdxwicpb42kwybd02ia85mh43hb";
+    sha256 = "sha256-m9Q20ZqwRwAaE0ByDStinrlt1QMljFJJIewq8+6IqA4=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/google-cloud-asset/default.nix

···
     sha256 = "05q0yaw6b553qmzylr45zin17h8mvi8yyyxhbv3cxa7f0ahviw8w";
   };
 
+  postPatch = ''
+    substituteInPlace setup.py \
+      --replace '"google-cloud-org-policy >= 0.1.2, < 0.2.0dev"' '"google-cloud-org-policy >= 0.1.2, < 0.2.1"'
+  '';
+
   propagatedBuildInputs = [
     grpc_google_iam_v1
     google-api-core

pkgs/development/python-modules/google-cloud-bigquery-datatransfer/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-bigquery-datatransfer";
-  version = "3.0.1";
+  version = "3.1.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "c5669410018eb41cecf6f9c90136d24d0ca9ed141bda8fbb3d52cd3de7162960";
+    sha256 = "sha256-mAZSVxiTiLbMeXR4xLK9+G6ejNyspdFw3tAnZGREpYY=";
   };
 
   propagatedBuildInputs = [ google-api-core libcst proto-plus ];

pkgs/development/python-modules/google-cloud-core/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-core";
-  version = "1.5.0";
+  version = "1.6.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "01liq4nrd2g3ingg8v0ly4c86db8agnr9h1fiz219c7fz0as0xqj";
+    sha256 = "sha256-xquxhSdUU3n8gu/E3nXOmjdyzK0vxkWtrOWTugl8uwI=";
   };
 
   propagatedBuildInputs = [ google-api-core ];

pkgs/development/python-modules/google-cloud-dataproc/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-dataproc";
-  version = "2.3.0";
+  version = "2.3.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "09e53889a60d84a71c505fe77174d242f00f28f989977aea91f6005cadfa466b";
+    sha256 = "sha256-TADApBkE4DvEFkVFy56Flh2s6XR9uGxzGTf5aspohsA=";
   };
 
   propagatedBuildInputs = [ google-api-core libcst proto-plus ];

pkgs/development/python-modules/google-cloud-error-reporting/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-error-reporting";
-  version = "1.1.0";
+  version = "1.1.2";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "2fd6fe25343f7017c22e2733a0358c64b3171edc1669d0c8a1e1f07f86a048c4";
+    sha256 = "sha256-NT/+2mtIaEMyXnmM1fWX4kEV9pb1+aNas2lNobUPR14=";
   };
 
   postPatch = ''

pkgs/development/python-modules/google-cloud-firestore/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-firestore";
-  version = "2.0.2";
+  version = "2.1.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1q5s2gpkibnjxal9zrz02jfnazf7rxk0bi0ln5a3di6i47kjnga9";
+    sha256 = "sha256-kG68fG9EqwvE72nzc89MXwEQ/YYEM9tYH6zK2iTCFJo=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/google-cloud-logging/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-logging";
-  version = "2.3.0";
+  version = "2.3.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "b5675ce159db4e9c1d755003b76190460766f426a7c3c1519014cdd5ce66e890";
+    sha256 = "sha256-yi3lG7tKi2BkU7vtMIEPsll1UX/JxrNj4G+DJaGQ/+k=";
   };
 
   propagatedBuildInputs = [ google-api-core google-cloud-core proto-plus ];

pkgs/development/python-modules/google-cloud-monitoring/default.nix

···
 , google-cloud-testutils
 , libcst
 , proto-plus
+, pandas
 , pytestCheckHook
 , pytest-asyncio
 , mock
···
 
 buildPythonPackage rec {
   pname = "google-cloud-monitoring";
-  version = "2.0.1";
+  version = "2.2.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "639408cac9660b6c7c2324bf1b2461c9c8e338518b9ebb7ebfac833a61d753eb";
+    sha256 = "sha256-QeMJBJKjW3Zu0p0mSmo5dVOJNwRmmA5FKXRXjCd+zN4=";
   };
 
   propagatedBuildInputs = [ libcst google-api-core proto-plus ];
 
-  checkInputs = [ google-cloud-testutils mock pytestCheckHook pytest-asyncio ];
+  checkInputs = [ google-cloud-testutils mock pandas pytestCheckHook pytest-asyncio ];
 
   disabledTests = [
     # requires credentials

pkgs/development/python-modules/google-cloud-org-policy/default.nix

···
-{ lib, buildPythonPackage, fetchPypi, pythonOlder, google-api-core }:
+{ lib, buildPythonPackage, fetchPypi, pythonOlder, google-api-core, proto-plus }:
 
 buildPythonPackage rec {
   pname = "google-cloud-org-policy";
-  version = "0.1.2";
+  version = "0.2.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0ncgcnbvmgqph54yh2pjx2hh82gnkhsrw5yirp4wlf7jclh6j9xh";
+    sha256 = "sha256-tGNwSv+rMnwdP6SvKAqFhjW19ZqIRWsqCNtiozajUqo=";
   };
 
-  propagatedBuildInputs = [ google-api-core ];
+  propagatedBuildInputs = [ google-api-core proto-plus ];
 
   # No tests in repo
   doCheck = false;

pkgs/development/python-modules/google-cloud-pubsub/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-pubsub";
-  version = "2.4.0";
+  version = "2.4.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "ff9933573dadb02176dc514662354949d0ea784cc4588d22226c2bf7eb90e797";
+    sha256 = "sha256-5gyqZ+JthC/Qja8ZCX79r4K+evuZY5jPZ73cA6hrgSA=";
   };
 
   propagatedBuildInputs = [ grpc_google_iam_v1 google-api-core libcst proto-plus ];

pkgs/development/python-modules/google-cloud-secret-manager/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-secret-manager";
-  version = "2.3.0";
+  version = "2.4.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "4df4b7e3f83bc12d6bd29e69608172586b6ddfc7586dd2a2fd70cc4f18ed05c7";
+    sha256 = "sha256-/ROngNZJld6iA8WjbJLLNzu5vFWPFUNdTikc70kNkQ4=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/google-cloud-spanner/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-spanner";
-  version = "3.0.0";
+  version = "3.3.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "060c53bc6f541660a2fe868fd83a695207d4e7b050e04fe103d1e77634b813c7";
+    sha256 = "sha256-XnOCmxQ6YCO1C7RYHzcZY4ihrt2KommWTkTD9y+B5tg=";
   };
 
   propagatedBuildInputs = [ google-cloud-core grpc_google_iam_v1 libcst proto-plus sqlparse ];

pkgs/development/python-modules/google-cloud-speech/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-speech";
-  version = "2.2.0";
+  version = "2.2.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "013279a411644545ee0d67a5c077d0f19db58b846d758f36a8cc759f9c9e0a19";
+    sha256 = "sha256-AviYDI68Z11M/rqHgQTQugYNemPTA5nW4aVQTiwMYxI=";
   };
 
   propagatedBuildInputs = [ libcst google-api-core proto-plus ];

pkgs/development/python-modules/google-cloud-storage/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-storage";
-  version = "1.35.1";
+  version = "1.37.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "dc076b6af6da991252416639cb93831f8e50c8328d5ac3fb8e03e40cd8de2290";
+    sha256 = "sha256-IAPF7Uc/mzfQRfMMTIvn0w19Dripe80sWLOovFScTMw=";
   };
 
   propagatedBuildInputs = [
···
     "get"
     "post"
     "test_build_api_url"
+    "test_ctor_mtls"
+    "test_open"
   ];
 
   pytestFlagsArray = [

pkgs/development/python-modules/google-cloud-testutils/default.nix

···
-{ lib, buildPythonPackage, fetchPypi, google-auth, six }:
+{ lib, buildPythonPackage, fetchPypi, click, google-auth, six }:
 
 buildPythonPackage rec {
   pname = "google-cloud-testutils";
-  version = "0.1.0";
+  version = "0.2.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1bn1pz00lxym3vkl6l45b3nydpmfdvmylwggh2lspldrxwx39a0k";
+    sha256 = "sha256-ojvnzCO8yxrm3rt0pH3FtRhYtjIvzwNMqS/npKy4lvM=";
   };
 
-  propagatedBuildInputs = [ google-auth six ];
+  propagatedBuildInputs = [ click google-auth six ];
 
   # does not contain tests
   doCheck = false;

pkgs/development/python-modules/google-cloud-texttospeech/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-texttospeech";
-  version = "2.2.0";
+  version = "2.3.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "17igfwh34369gkvsbrm46j1ii61i6268wg2g2dl9c65nf9z3kgfb";
+    sha256 = "sha256-zzssVnXA1xe3270yEOREJ9GdmyRPjV1F4EBelf9AQ/c=";
   };
 
   propagatedBuildInputs = [ libcst google-api-core proto-plus ];

pkgs/development/python-modules/google-cloud-translate/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-translate";
-  version = "3.0.2";
+  version = "3.1.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1s2gvlzfqd2gsrzaz7yl9q8s1k03dlsjahgg95s017vlcn21d0v1";
+    sha256 = "sha256-zVRD2lWRaKtSlZn84Rqpj+a1OT7Wcak524TKsBctueE=";
   };
 
   propagatedBuildInputs = [ google-api-core google-cloud-core libcst proto-plus ];

pkgs/development/python-modules/google-cloud-videointelligence/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-videointelligence";
-  version = "2.0.0";
+  version = "2.1.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1yhmizig41ymr2dz0i6ccrwszp0ivyykmq11vqxp82l9ncjima82";
+    sha256 = "sha256-gn/KWf3A4SkTqt9rqwYcsaxvfKXPvb7DXJ+zryGjWIA=";
   };
 
   propagatedBuildInputs = [ google-api-core proto-plus ];

pkgs/development/python-modules/google-cloud-vision/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-vision";
-  version = "2.2.0";
+  version = "2.3.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "9a205be275739c141873fa9fbd7c3f9ec6170972c85d5c75e9b4c53b5db839a3";
+    sha256 = "sha256-6XYHADzyk0/WSGk9wni9bOtVURJ+U2Eve8LAh0Eg7KI=";
   };
 
   propagatedBuildInputs = [ libcst google-api-core proto-plus];

pkgs/development/python-modules/google-cloud-websecurityscanner/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-websecurityscanner";
-  version = "1.0.0";
+  version = "1.1.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "14sky9bkl00n65ksig3f6psm31pkmkvlcprlk6s9if470j40zrhx";
+    sha256 = "sha256-lrMnp9jVndz0C8VdreVudYdwh7zSdRniPHYm9BNdjak=";
   };
 
   propagatedBuildInputs = [ google-api-core libcst proto-plus ];

pkgs/development/python-modules/googleapis-common-protos/default.nix

···
 
 buildPythonPackage rec {
   pname = "googleapis-common-protos";
-  version = "1.52.0";
+  version = "1.53.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0lakcsd35qm5x4visvw6z5f1niasv9a0mjyf2bd98wqi0z41c1sn";
+    sha256 = "sha256-qI7okDqgqB9sPOwtXPYtPIqmfAZDmwSWtJBI+xhU6/Q=";
   };
 
   propagatedBuildInputs = [ grpc protobuf ];

pkgs/development/python-modules/gsd/default.nix

···
 { lib, buildPythonPackage, fetchFromGitHub, isPy27
-, numpy
-, pytest
+, cython, numpy
+, pytestCheckHook
 }:
 
 buildPythonPackage rec {
-  version = "1.9.3";
+  version = "2.4.1";
   pname = "gsd";
   disabled = isPy27;
 
···
     owner = "glotzerlab";
     repo = pname;
     rev = "v${version}";
-    sha256 = "07hw29r2inyp493dia4fx3ysfr1wxi2jb3n9cmwdi0l54s2ahqvf";
+    sha256 = "02zxfmqw7a5kz8qjdph9a9961mbkd4haxwwa28yjkxs5hzs5x3c8";
   };
 
+  nativeBuildInputs = [ cython ];
   propagatedBuildInputs = [ numpy ];
 
-  checkInputs = [ pytest ];
-  checkPhase = ''
-    pytest
+  checkInputs = [ pytestCheckHook ];
+  preCheck = ''
+    pushd gsd/test
+  '';
+  postCheck = ''
+    popd
   '';
 
   meta = with lib; {

pkgs/development/python-modules/gssapi/default.nix

···
 
 buildPythonPackage rec {
   pname = "gssapi";
-  version = "1.6.10";
+  version = "1.6.12";
   disabled = pythonOlder "3.6";
 
   src = fetchFromGitHub {
     owner = "pythongssapi";
     repo = "python-${pname}";
     rev = "v${version}";
-    sha256 = "11w8z9ik6zzv3pw3319mz91cgbfkgx0mffxbapqnhilzij2jad4q";
+    sha256 = "sha256-x86/KMcXChPLzoCqR9xwemusWktf/seHLQmEKLco3GQ=";
   };
 
   # It's used to locate headers
   postPatch = ''
     substituteInPlace setup.py \
-      --replace "get_output('krb5-config gssapi --prefix')" "'${lib.getDev krb5Full}'"
+      --replace 'get_output(f"{kc} gssapi --prefix")' '"${lib.getDev krb5Full}"'
   '';
 
   nativeBuildInputs = [

pkgs/development/python-modules/hetzner/default.nix

···
 
 buildPythonPackage rec {
   pname = "hetzner";
-  version = "0.8.2";
+  version = "0.8.3";
 
   src = fetchFromGitHub {
     repo = "hetzner";
     owner = "aszlig";
     rev = "v${version}";
-    sha256 = "152fklxff08s71v0b78yp5ajwpqyszm3sd7j0qsrwa2x9ik4968h";
+    sha256 = "0nhm7j2y4rgmrl0c1rklg982qllp7fky34dchqwd4czbsdnv9j7a";
   };
 
   meta = with lib; {

pkgs/development/python-modules/hstspreload/default.nix

···
 
 buildPythonPackage rec {
   pname = "hstspreload";
-  version = "2021.2.15";
+  version = "2021.3.29";
   disabled = isPy27;
 
   src = fetchFromGitHub {
     owner = "sethmlarson";
     repo = pname;
     rev = version;
-    sha256 = "sha256-vHq4DjDh7hBNAK/h/KdzqaEgrG5bg7VQ8fVWuxV7vOg=";
+    sha256 = "sha256-F5EXwCoXYmFkV0VWT5leIWZU2xH1t6T0LuxodAANS8E=";
   };
 
   # tests require network connection

pkgs/development/python-modules/kerberos/default.nix

···
 { lib
 , buildPythonPackage
 , fetchPypi
-, kerberos
+, libkrb5
 }:
 
 buildPythonPackage rec {
···
     sha256 = "cdd046142a4e0060f96a00eb13d82a5d9ebc0f2d7934393ed559bac773460a2c";
   };
 
-  nativeBuildInputs = [ kerberos ];
+  nativeBuildInputs = [ libkrb5 ];
 
   # No tests in archive
   doCheck = false;

pkgs/development/python-modules/lark-parser/default.nix

···
 { lib
 , buildPythonPackage
 , fetchFromGitHub
+, regex
+  # Test inputs
+, pytestCheckHook
 }:
 
 buildPythonPackage rec {
   pname = "lark-parser";
-  version = "0.8.8";
+  version = "0.11.2";
 
   src = fetchFromGitHub {
     owner = "lark-parser";
     repo = "lark";
     rev = version;
-    sha256 = "1q2dvkkfx9dvag5v5ps0ki4avh7i003gn9sj30jy1rsv1bg4y2mb";
+    sha256 = "1v1piaxpz4780km2z5i6sr9ygi9wpn09yyh999b3f4y0dcz20pbd";
   };
 
-  # tests of Nearley support require js2py
-  preCheck = ''
-    rm -r tests/test_nearley
-  '';
+  propagatedBuildInputs = [ regex ];
 
-  meta = {
+  checkInputs = [ pytestCheckHook ];
+  disabledTestPaths = [
+    "tests/test_nearley" # requires Js2Py package (not in nixpkgs)
+  ];
+  disabledTests = [
+    "test_override_rule"  # has issue with file access paths
+  ];
+
+  meta = with lib; {
     description = "A modern parsing library for Python, implementing Earley & LALR(1) and an easy interface";
     homepage = "https://github.com/lark-parser/lark";
-    license = lib.licenses.mit;
-    maintainers = with lib.maintainers; [ fridh ];
+    license = licenses.mit;
+    maintainers = with maintainers; [ fridh drewrisinger ];
   };
 }

pkgs/development/python-modules/libcst/default.nix

···
 
 buildPythonPackage rec {
   pname = "libcst";
-  version = "0.3.17";
+  version = "0.3.18";
 
   # Some files for tests missing from PyPi
   # https://github.com/Instagram/LibCST/issues/331
···
     owner = "instagram";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-mlSeB9OjCiUVYwcPYNrQdlfcj9DV/+wqVWt91uFsQsU=";
+    sha256 = "sha256-19yGaKBLpGASSPv/aSX0kx9lh2JxKExHJDKKtuBbuqI=";
   };
 
   disabled = pythonOlder "3.6";

pkgs/development/python-modules/milc/default.nix

···
 , appdirs
 , argcomplete
 , colorama
-, gnugrep
+, nose2
+, semver
 }:
 
 buildPythonPackage rec {
   pname = "milc";
-  version = "1.0.10";
+  version = "1.3.0";
 
   src = fetchFromGitHub {
     owner = "clueboard";
     repo = "milc";
     rev = version;
-    sha256 = "04mk057b6jh0k4maqkg80kpilxak9r7vlr9xqwzczh2gs3g2x573";
+    sha256 = "sha256-koyOBz+pB/vkTHOR1p77ACO11/ULDIBzqsszUUpnE88=";
   };
 
-  checkInputs = [ gnugrep ];
   propagatedBuildInputs = [ appdirs argcomplete colorama ];
 
-  # Upstream has a nose2 test suite that runs this hello script in a handful of
-  # ways, but it's not in setup.py and makes assumptions about relative paths in
-  # the src repo, so just sanity-check basic functionality.
+  checkInputs = [ nose2 semver ];
+
   checkPhase = ''
-    patchShebangs ./hello
-    ./hello | grep "Hello, World"
+    patchShebangs example hello
+    nose2
   '';
+
+  pythonImportsCheck = [ "milc" ];
 
   meta = with lib; {
     description = "An Opinionated Batteries-Included Python 3 CLI Framework";

pkgs/development/python-modules/proto-plus/default.nix

···
 
 buildPythonPackage rec {
   pname = "proto-plus";
-  version = "1.13.0";
+  version = "1.18.1";
   disabled = !isPy3k;
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1i5jjnwpd288378h37zads08h695iwmhxm0sxbr3ln6aax97rdb1";
+    sha256 = "sha256-z8RUdMftoP48S57KJUISTyoP9VQyQr7GHo0IvOD1vUg=";
   };
 
   propagatedBuildInputs = [ protobuf ];

pkgs/development/python-modules/pyaxmlparser/default.nix

···
-{ buildPythonPackage, lib, lxml, click, fetchFromGitHub, pytest, isPy3k }:
+{ buildPythonPackage, lib, lxml, click, fetchFromGitHub, pytestCheckHook, asn1crypto }:
 
 buildPythonPackage rec {
-  version = "0.3.24";
+  version = "0.3.26";
   pname = "pyaxmlparser";
 
-  # the PyPI tarball doesn't ship tests.
   src = fetchFromGitHub {
     owner = "appknox";
     repo = pname;
     rev = "v${version}";
-    sha256 = "0fys26p7xhbnbdzp80zm6n3mragp38p08nyrsnilfgnlpi6rjpg0";
+    sha256 = "sha256-wD0rN00q4ipKnKubptrgrjNwkBpqsA+ix2xedOOr8Yg=";
   };
 
-  disabled = !isPy3k;
-
-  postPatch = ''
-    substituteInPlace setup.py --replace "click==6.7" "click"
-  '';
-
-  propagatedBuildInputs = [ lxml click ];
+  propagatedBuildInputs = [ asn1crypto click lxml ];
 
-  checkInputs = [ pytest ];
-  checkPhase = ''
-    py.test tests/
-  '';
+  checkInputs = [ pytestCheckHook ];
 
   meta = with lib; {
     description = "Python3 Parser for Android XML file and get Application Name without using Androguard";

pkgs/development/python-modules/pyelftools/default.nix

···
     sha256 = "09igdym2qj2fvfcazbz25qybmgz7ccrn25xn3havfkdkka0z0i3p";
   };
 
-  doCheck = stdenv.is64bit && !stdenv.isDarwin;
+  doCheck = stdenv.hostPlatform.system == "x86_64-linux";
 
   checkPhase = ''
     patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" test/external_tools/readelf

pkgs/development/python-modules/pysam/default.nix

···
 , cython
 , htslib
 , libdeflate
-, lzma
+, xz
 , pytest
 , samtools
 , zlib
···
     curl
     cython
     libdeflate
-    lzma
+    xz
     zlib
   ];
 

pkgs/development/python-modules/python-smarttub/default.nix

···
 
 buildPythonPackage rec {
   pname = "python-smarttub";
-  version = "0.0.19";
+  version = "0.0.21";
   disabled = pythonOlder "3.8";
 
   src = fetchFromGitHub {
     owner = "mdz";
     repo = pname;
     rev = "v${version}";
-    sha256 = "01i4pvgvpl7inwhy53c6b34pi5zvfiv2scn507j8jdg5cjs04g80";
+    sha256 = "sha256-7phx6CI6sqUCZIUxL6ea25UWAcI3NAz66hIleUfN4bk=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/pytorch/default.nix

···
 in buildPythonPackage rec {
   pname = "pytorch";
   # Don't forget to update pytorch-bin to the same version.
-  version = "1.8.0";
+  version = "1.8.1";
 
   disabled = !isPy3k;
 
···
     repo   = "pytorch";
     rev    = "v${version}";
     fetchSubmodules = true;
-    sha256 = "sha256-qdZUtlxHZjCYoGfTdp5Bq3MtfXolWZrvib0kuzF3uIc=";
+    sha256 = "sha256-HERbvmrfhWwH164GFHU/M0KbhVAuhI5sBZSxCZy8mRk=";
   };
 
   patches = lib.optionals stdenv.isDarwin [

pkgs/development/python-modules/riprova/default.nix

···
+{ lib
+, buildPythonPackage
+, fetchPypi
+, six
+}:
+
+buildPythonPackage rec{
+  pname = "riprova";
+  version = "0.2.7";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "04drdvjjbh370csv2vb5zamg2aanxqkfm6w361qkybnra4g4g0dz";
+  };
+
+  propagatedBuildInputs = [ six ];
+
+  # PyPI archive doesn't have tests
+  doCheck = false;
+
+  pythonImportsCheck = [ "riprova" ];
+
+  meta = with lib; {
+    homepage = "https://github.com/h2non/riprova";
+    description = "Small and versatile library to retry failed operations using different backoff strategies";
+    license = licenses.mit;
+    maintainers = with maintainers; [ mmilata ];
+  };
+}

pkgs/development/python-modules/rpy2/2.nix

···
 , rWrapper
 , rPackages
 , pcre
-, lzma
+, xz
 , bzip2
 , zlib
 , icu
···
       readline
       R
       pcre
-      lzma
+      xz
       bzip2
       zlib
       icu

pkgs/development/python-modules/rpy2/default.nix

···
 , rWrapper
 , rPackages
 , pcre
-, lzma
+, xz
 , bzip2
 , zlib
 , icu
···
 
     buildInputs = [
       pcre
-      lzma
+      xz
       bzip2
       zlib
       icu

pkgs/development/python-modules/sphinxcontrib-bibtex/default.nix

···
 }:
 
 buildPythonPackage rec {
-  version = "2.1.4";
+  version = "2.2.0";
   pname = "sphinxcontrib-bibtex";
 
   disabled = !isPy3k;
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "f53ec0cd534d2c8f0a51b4b3473ced46e9cb0dd99a7c5019249fe0ef9cbef18e";
+    sha256 = "sha256-dQCEPhVNdpg8I7ylynOAll4HJcRrj0hMEyLQtYps47I=";
   };
 
   propagatedBuildInputs = [ oset pybtex pybtex-docutils sphinx ];

pkgs/development/python-modules/sunpy/default.nix

···
 , pythonOlder
 , asdf
 , astropy
+, setuptools-scm
 , astropy-helpers
 , astropy-extension-helpers
 , beautifulsoup4
···
   };
 
   nativeBuildInputs = [
+    setuptools-scm
     astropy-extension-helpers
   ];
 

pkgs/development/python-modules/uproot3-methods/default.nix

···
 }:
 
 buildPythonPackage rec {
-  version = "0.10.0";
+  version = "0.10.1";
   pname = "uproot3-methods";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1rk9i1ra3panli96ghz80ddpqk77xb1kpxs3wf8rw0jy5d88pc26";
+    sha256 = "sha256-3Wj5C+HqJ2NguWNpg2hJ3ykEX3/k5TT5rCHqAHmO41g=";
   };
 
   nativeBuildInputs = [ awkward0 ];

pkgs/development/r-modules/default.nix

···
     RGtk2 = [ pkgs.gtk2.dev ];
     rhdf5 = [ pkgs.zlib ];
     Rhdf5lib = [ pkgs.zlib ];
-    Rhpc = [ pkgs.zlib pkgs.bzip2.dev pkgs.icu pkgs.lzma.dev pkgs.mpi pkgs.pcre.dev ];
-    Rhtslib = [ pkgs.zlib.dev pkgs.automake pkgs.autoconf pkgs.bzip2.dev pkgs.lzma.dev pkgs.curl.dev ];
+    Rhpc = [ pkgs.zlib pkgs.bzip2.dev pkgs.icu pkgs.xz.dev pkgs.mpi pkgs.pcre.dev ];
+    Rhtslib = [ pkgs.zlib.dev pkgs.automake pkgs.autoconf pkgs.bzip2.dev pkgs.xz.dev pkgs.curl.dev ];
     rjags = [ pkgs.jags ];
-    rJava = [ pkgs.zlib pkgs.bzip2.dev pkgs.icu pkgs.lzma.dev pkgs.pcre.dev pkgs.jdk pkgs.libzip ];
+    rJava = [ pkgs.zlib pkgs.bzip2.dev pkgs.icu pkgs.xz.dev pkgs.pcre.dev pkgs.jdk pkgs.libzip ];
     Rlibeemd = [ pkgs.gsl_1 ];
     rmatio = [ pkgs.zlib.dev ];
     Rmpfr = [ pkgs.gmp pkgs.mpfr.dev ];
···
     RVowpalWabbit = [ pkgs.zlib.dev pkgs.boost ];
     rzmq = [ pkgs.zeromq pkgs.pkg-config ];
     clustermq = [ pkgs.zeromq ];
-    SAVE = [ pkgs.zlib pkgs.bzip2 pkgs.icu pkgs.lzma pkgs.pcre ];
+    SAVE = [ pkgs.zlib pkgs.bzip2 pkgs.icu pkgs.xz pkgs.pcre ];
     sdcTable = [ pkgs.gmp pkgs.glpk ];
     seewave = [ pkgs.fftw.dev pkgs.libsndfile.dev ];
     seqinr = [ pkgs.zlib.dev ];
···
     });
 
     littler = old.littler.overrideAttrs (attrs: with pkgs; {
-      buildInputs = [ pcre lzma zlib bzip2 icu which ] ++ attrs.buildInputs;
+      buildInputs = [ pcre xz zlib bzip2 icu which ] ++ attrs.buildInputs;
       postInstall = ''
         install -d $out/bin $out/share/man/man1
         ln -s ../library/littler/bin/r $out/bin/r

pkgs/development/ruby-modules/gem-config/default.nix

···
 # This seperates "what to build" (the exact gem versions) from "how to build"
 # (to make gems behave if necessary).
 
-{ lib, fetchurl, writeScript, ruby, kerberos, libxml2, libxslt, python, stdenv, which
+{ lib, fetchurl, writeScript, ruby, libkrb5, libxml2, libxslt, python, stdenv, which
 , libiconv, postgresql, v8, clang, sqlite, zlib, imagemagick, lasem
 , pkg-config , ncurses, xapian, gpgme, util-linux, tzdata, icu, libffi
 , cmake, libssh2, openssl, libmysqlclient, darwin, git, perl, pcre, gecode_3, curl
···
   };
 
   timfel-krb5-auth = attrs: {
-    buildInputs = [ kerberos ];
+    buildInputs = [ libkrb5 ];
   };
 
   tiny_tds = attrs: {

pkgs/development/tools/analysis/flow/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "flow";
-  version = "0.147.0";
+  version = "0.148.0";
 
   src = fetchFromGitHub {
     owner  = "facebook";
     repo   = "flow";
     rev    = "refs/tags/v${version}";
-    sha256 = "sha256-3U8BOYUHl1YiOnxAIV2V6Ib+LZ0DydtSfwAxN2Hj09g=";
+    sha256 = "sha256-DPHDuTBCsRq+u5kYHwImIXPxq04kW2HiqYsxJrun6n8=";
   };
 
   installPhase = ''

pkgs/development/tools/analysis/spin/default.nix

···
-{ stdenv, lib, fetchurl, makeWrapper, yacc, gcc
+{ stdenv, lib, fetchurl, makeWrapper, bison, gcc
 , withISpin ? true, tk, swarm, graphviz }:
 
 let
···
   };
 
   nativeBuildInputs = [ makeWrapper ];
-  buildInputs = [ yacc ];
+  buildInputs = [ bison ];
 
   sourceRoot = "Spin/Src${version}";
 

pkgs/development/tools/analysis/tfsec/default.nix

···
 
 buildGoPackage rec {
   pname = "tfsec";
-  version = "0.39.14";
+  version = "0.39.16";
 
   src = fetchFromGitHub {
     owner = "tfsec";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-Peq51XN8EEvHWdSL3ngBx74t7V4RUrZa4RpGnvZ0Ml8=";
+    sha256 = "sha256-5We3Nk/AU5dj37vG4pvqzvNztK01PAPadQV/CgHZe8w=";
   };
 
   goPackagePath = "github.com/tfsec/tfsec";

pkgs/development/tools/build-managers/jam/default.nix

···
-{ lib, stdenv, fetchurl, yacc }:
+{ lib, stdenv, fetchurl, bison }:
 
 stdenv.mkDerivation rec {
   name = "jam-2.6.1";
···
     sha256 = "19xkvkpycxfsncxvin6yqrql3x3z9ypc1j8kzls5k659q4kv5rmc";
   };
 
-  nativeBuildInputs = [ yacc ];
+  nativeBuildInputs = [ bison ];
 
   preConfigure = ''
     unset AR

pkgs/development/tools/build-managers/sbt/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "sbt";
-  version = "1.4.9";
+  version = "1.5.0";
 
   src = fetchurl {
     url = "https://github.com/sbt/sbt/releases/download/v${version}/sbt-${version}.tgz";
-    sha256 = "sha256-lUaBGfdkFJk2czCmCkuKYhHm6n+L3n1kfGexndj9224=";
+    sha256 = "1dj241cj3v8kzqnz5s499rijpl7wv4rw171swqnc0xza90513pxa";
   };
 
   postPatch = ''

pkgs/development/tools/cdecl/default.nix

···
-{lib, stdenv, fetchurl, yacc, flex, readline, ncurses, gnused}:
+{lib, stdenv, fetchurl, bison, flex, readline, ncurses, gnused}:
 
 stdenv.mkDerivation {
   name = "cdecl-2.5";
···
     makeFlags="$makeFlags PREFIX=$out BINDIR=$out/bin MANDIR=$out/man1 CATDIR=$out/cat1 CC=$CC";
     mkdir -p $out/bin;
   '';
-  buildInputs = [yacc flex readline ncurses];
+  buildInputs = [bison flex readline ncurses];
 
   meta = {
     description = "Translator English -- C/C++ declarations";

pkgs/development/tools/dapr/cli/default.nix

···
 
 buildGoModule rec {
   pname = "dapr";
-  version = "1.0.1";
+  version = "1.1.0";
 
-  vendorSha256 = "13fb6fdjqrsl74569nh2l7x9w7w61bcvkksj410s2f85bicc29rf";
+  vendorSha256 = "0fng5a1pvpbwil79xapdalzgkgc9dwsdxs6bznjfwnkyd1vvw6fm";
 
   src = fetchFromGitHub {
-    sha256 = "15zz212sm83l6l7npislixxn23fg190b44bfxnrjrlyjbz370kch";
+    sha256 = "0x2mvlzlmcik6ys6xp722px9l4lj9ssyxb06bzxd7yj7m1wwcwp9";
 
     owner = "dapr";
     repo = "cli";

pkgs/development/tools/database/shmig/default.nix

···
 { stdenv, fetchFromGitHub
 , withMySQL ? true, withPSQL ? false, withSQLite ? false
-, mysql, postgresql, sqlite, gawk, gnugrep, findutils, gnused
+, mariadb, postgresql, sqlite, gawk, gnugrep, findutils, gnused
 , lib
 }:
 
···
     patchShebangs .
 
     substituteInPlace shmig \
-      --replace "\`which mysql\`" "${lib.optionalString withMySQL "${mysql.client}/bin/mysql"}" \
+      --replace "\`which mysql\`" "${lib.optionalString withMySQL "${mariadb.client}/bin/mysql"}" \
       --replace "\`which psql\`" "${lib.optionalString withPSQL "${postgresql}/bin/psql"}" \
       --replace "\`which sqlite3\`" "${lib.optionalString withSQLite "${sqlite}/bin/sqlite3"}" \
       --replace "awk" "${gawk}/bin/awk" \

pkgs/development/tools/diesel-cli/default.nix

···
 { stdenv, lib, rustPlatform, fetchFromGitHub, openssl, pkg-config, Security
 , sqliteSupport ? true, sqlite
 , postgresqlSupport ? true, postgresql
-, mysqlSupport ? true, mysql, zlib, libiconv
+, mysqlSupport ? true, mariadb, zlib, libiconv
 }:
 
 assert lib.assertMsg (sqliteSupport == true || postgresqlSupport == true || mysqlSupport == true)
···
     ++ optional (stdenv.isDarwin && mysqlSupport) libiconv
     ++ optional sqliteSupport sqlite
     ++ optional postgresqlSupport postgresql
-    ++ optionals mysqlSupport [ mysql zlib ];
+    ++ optionals mysqlSupport [ mariadb zlib ];
 
   buildAndTestSubdir = "diesel_cli";
 

pkgs/development/tools/ginkgo/default.nix

···
 
 buildGoModule rec {
   pname = "ginkgo";
-  version = "1.15.2";
+  version = "1.16.0";
 
   src = fetchFromGitHub {
     owner = "onsi";
     repo = "ginkgo";
     rev = "v${version}";
-    sha256 = "sha256-lZ2PIfZSvBxVIAEpRgsLvTWPFRsh2ZpXkame6pk0Cio=";
+    sha256 = "sha256-phVpOKgMhebkVQlMDO/9IrETe72hXTgyGJtlKipKgv0=";
   };
-  vendorSha256 = "sha256:1nqam6y2dar8320yb5fg9chsvswq8fb1rrvr5kbcaf4mzmqpy7vw";
+  vendorSha256 = "sha256-tS8YCGVOsfQp02vY6brmE3pxi70GG9DYcp1JDkcVG9Y=";
   doCheck = false;
 
   meta = with lib; {

pkgs/development/tools/git-quick-stats/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "git-quick-stats";
-  version = "2.1.7";
+  version = "2.1.8";
 
   src = fetchFromGitHub {
     repo = "git-quick-stats";
     owner = "arzzen";
     rev = version;
-    sha256 = "sha256-DFssuvafgAZY26Ycv/SV5EF1B5rax3R41PCLZL09A0s=";
+    sha256 = "sha256-sK8HOfeiV0xn540bU7inZl/hV6uzitJ4Szqk96a8DMc=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/development/tools/go-containerregistry/default.nix

···
+{ lib, buildGoModule, fetchFromGitHub }:
+
+buildGoModule rec {
+  pname = "go-containerregistry";
+  version = "0.4.1";
+
+  src = fetchFromGitHub {
+    owner = "google";
+    repo = pname;
+    rev = "v${version}";
+    hash = "sha256-3mvGHAPKDUmrQkBKwlxnF6PG0ZpZDqlM9SMkCyC5ytE=";
+  };
+
+  vendorSha256 = null;
+
+  subPackages = [ "cmd/crane" "cmd/gcrane" ];
+
+  buildFlagsArray = [
+    "-ldflags=-s -w -X github.com/google/go-containerregistry/cmd/crane/cmd.Version=${version} -X github.com/google/go-containerregistry/pkg/v1/remote/transport.Version=${version}"
+  ];
+
+  # NOTE: no tests
+  doCheck = false;
+
+  meta = with lib; {
+    description = "A tool for interacting with remote images and registries";
+    homepage = "https://github.com/google/go-containerregistry";
+    license = licenses.apsl20;
+    maintainers = with maintainers; [ yurrriq ];
+  };
+}

pkgs/development/tools/go-swagger/default.nix

···
 
 buildGoModule rec {
   pname = "go-swagger";
-  version = "0.26.1";
+  version = "0.27.0";
 
   src = fetchFromGitHub {
     owner = "go-swagger";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-gA7YpzroIP26u/kmbwlcYkWVfeJ8YDEAl0H9GGQrXA8=";
+    sha256 = "sha256-S3/sXmgogxhMv53Gd/ir6ScirYQtt5kn04ZfRiS6NoA=";
   };
 
-  vendorSha256 = "sha256-eRcE6ai7076HqTWRJ8zKoV6/PJRgUpKvKF+0T7MgLQE=";
+  vendorSha256 = "sha256-ABGjrMZdgsAaEhJlGbvbX77t7TsodraadNyItESMbEc=";
 
   doCheck = false;
 

pkgs/development/tools/misc/act/default.nix

···
 
 buildGoModule rec {
   pname = "act";
-  version = "0.2.20";
+  version = "0.2.21";
 
   src = fetchFromGitHub {
     owner = "nektos";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-HgFm58zdaycOH65jfu3QsfFemhXymp3OTekISih+8WA=";
+    sha256 = "sha256-XDxG7F+oBatlb4ROBryt2Fop402riKmYoqZLJrUzBUQ=";
   };
 
-  vendorSha256 = "sha256-9LEyxIBe4c938RQbLOQOsAb9MGNtjngm48P3P83BTNw=";
+  vendorSha256 = "sha256-PwVDMSl36m+6ISJQvyrkCjaL3xp5VkaZtfxyMpNn+KI=";
 
   doCheck = false;
 

pkgs/development/tools/misc/autoconf/2.13.nix

···
-{lib, stdenv, fetchurl, m4, perl, lzma}:
+{lib, stdenv, fetchurl, m4, perl, xz}:
 
 stdenv.mkDerivation rec {
   name = "autoconf-2.13";
···
     sha256 = "07krzl4czczdsgzrrw9fiqx35xcf32naf751khg821g5pqv12qgh";
   };
 
-  nativebuildInputs = [ lzma ];
+  nativebuildInputs = [ xz ];
   buildInputs = [ m4 perl ];
 
   doCheck = true;

pkgs/development/tools/misc/avrdude/default.nix

···
-{ lib, stdenv, fetchurl, yacc, flex, libusb-compat-0_1, libelf, libftdi1, readline
+{ lib, stdenv, fetchurl, bison, flex, libusb-compat-0_1, libelf, libftdi1, readline
 # docSupport is a big dependency, disabled by default
 , docSupport ? false, texLive ? null, texinfo ? null, texi2html ? null
 }:
···
 
   configureFlags = lib.optionals docSupport "--enable-doc";
 
-  buildInputs = [ yacc flex libusb-compat-0_1 libelf libftdi1 readline ]
+  buildInputs = [ bison flex libusb-compat-0_1 libelf libftdi1 readline ]
     ++ lib.optionals docSupport [ texLive texinfo texi2html ];
 
   meta = with lib; {

pkgs/development/tools/misc/hydra/common.nix

···
 , makeWrapper, autoconf, automake, libtool, unzip, pkg-config, sqlite, libpqxx
 , top-git, mercurial, darcs, subversion, breezy, openssl, bzip2, libxslt
 , perl, postgresql, nukeReferences, git, boehmgc, nlohmann_json
-, docbook_xsl, openssh, gnused, coreutils, findutils, gzip, lzma, gnutar
+, docbook_xsl, openssh, gnused, coreutils, findutils, gzip, xz, gnutar
 , rpm, dpkg, cdrkit, pixz, lib, boost, autoreconfHook, src ? null, version ? null
 , migration ? false, patches ? []
 , tests ? {}, mdbook
···
 
   hydraPath = lib.makeBinPath (
     [ sqlite subversion openssh nix coreutils findutils pixz
-      gzip bzip2 lzma gnutar unzip git top-git mercurial /*darcs*/ gnused breezy
+      gzip bzip2 xz gnutar unzip git top-git mercurial /*darcs*/ gnused breezy
     ] ++ lib.optionals stdenv.isLinux [ rpm dpkg cdrkit ] );
 
   nativeBuildInputs = [ autoreconfHook pkg-config mdbook ];

pkgs/development/tools/misc/terracognita/default.nix

···
 
 buildGoModule rec {
   pname = "terracognita";
-  version = "0.6.2";
+  version = "0.6.3";
 
   src = fetchFromGitHub {
     owner = "cycloidio";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-RX2L9EwxfZ+utptTDR3+W9ACVPALF/hiE40SJTmZuLs=";
+    sha256 = "sha256-rRSBPnvv4941IUGN/6+8/hzgYDqgPErNkd7tFrslPiQ=";
   };
 
   vendorSha256 = "sha256-sN9GTcG5cZxvMaLqNjY2jfLkf8a3lugM2aV3bBdT5Ww=";

pkgs/development/tools/misc/texinfo/4.13a.nix

···
-{ stdenv, fetchurl, texinfo, ncurses, lzma }:
+{ stdenv, fetchurl, texinfo, ncurses, xz }:
 
 stdenv.mkDerivation rec {
   pname = "texinfo";
···
   };
 
   buildInputs = [ ncurses ];
-  nativeBuildInputs = [ lzma ];
+  nativeBuildInputs = [ xz ];
 
   # Disabled because we don't have zdiff in the stdenv bootstrap.
   #doCheck = true;

pkgs/development/tools/packet-cli/default.nix

···
 
 buildGoModule rec {
   pname = "packet-cli";
-  version = "0.1.1";
+  version = "0.3.0";
 
   src = fetchFromGitHub {
     owner = "packethost";
     repo = pname;
     rev = version;
-    sha256 = "089fcn7yslijjivyvwl85j32gfwif8aazqdhm6hi676lz80ssppp";
+    sha256 = "sha256-P1Bn6vli0d/MroHUsioTWBrjWN+UZmSo3qmzo+fCDwM=";
   };
 
-  vendorSha256 = "1p3v4pzw9hc1iviv1zghw9imbd23nlp24dpa8hf0w8a03jvpy96x";
+  vendorSha256 = "sha256-PjKiUdhN87guPAa0loZrWYuwbl0HaspuIjmKgyq4Zp8=";
 
   postInstall = ''
     ln -s $out/bin/packet-cli $out/bin/packet

pkgs/development/tools/rubocop/Gemfile.lock

···
     rainbow (3.0.0)
     regexp_parser (2.1.1)
     rexml (3.2.4)
-    rubocop (1.12.0)
+    rubocop (1.12.1)
       parallel (~> 1.10)
       parser (>= 3.0.0.0)
       rainbow (>= 2.2.2, < 4.0)

pkgs/development/tools/rubocop/default.nix

···
 
   meta = with lib; {
     description = "Automatic Ruby code style checking tool";
-    homepage = "https://docs.rubocop.org/";
+    homepage = "https://rubocop.org/";
     license = licenses.mit;
     maintainers = with maintainers; [ marsam leemachin ];
   };

pkgs/development/tools/rubocop/gemset.nix

···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "1i3y0h6awywx4rdmjdan908jmnyk589pndbjypxkfbkqvjx514fw";
+      sha256 = "0hi2c3a6alya9yx07nirnjzlc0mvmidnx67874njp6wf7d5xqqr9";
       type = "gem";
     };
-    version = "1.12.0";
+    version = "1.12.1";
   };
   rubocop-ast = {
     dependencies = ["parser"];

pkgs/development/tools/sd-local/default.nix

···
 
 buildGoModule rec {
   pname = "sd-local";
-  version = "1.0.29";
+  version = "1.0.30";
 
   src = fetchFromGitHub {
     owner = "screwdriver-cd";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-Po6kP6kAY5W3SQJ3iFCtzifSlQ+JgLIDhuk2UHSwAxM=";
+    sha256 = "sha256-Ha0E0e9CPR8dnApw0cR4A7Tzi3shYVtSeaQ+6I80qcU=";
   };
 
   vendorSha256 = "sha256-4xuWehRrmVdS2F6r00LZLKq/oHlWqCTQ/jYUKeIJ6DI=";

pkgs/development/tools/tracy/default.nix

···
 { stdenv, lib, darwin, fetchFromGitHub, tbb, gtk3, glfw, pkg-config, freetype, Carbon, AppKit, capstone }:
 
-stdenv.mkDerivation rec {
+let
+  disableLTO = stdenv.cc.isClang && stdenv.isDarwin;  # workaround issue #19098
+in stdenv.mkDerivation rec {
   pname = "tracy";
-  version = "0.7.6";
+  version = "0.7.7";
 
   src = fetchFromGitHub {
     owner = "wolfpld";
     repo = "tracy";
     rev = "v${version}";
-    sha256 = "sha256-Fk/Kuc7DwmdoyLx/YjdEHQ7S0M+ksAXl9QqeSPH2vJ8=";
+    sha256 = "sha256-jp+Geqk39ZPoe2KzUJJ0w5hvCnyUlHGwVKn73lJJt94=";
   };
 
   nativeBuildInputs = [ pkg-config ];
···
 
   NIX_CFLAGS_COMPILE = [ ]
     ++ lib.optional stdenv.isLinux "-ltbb"
-    ++ lib.optional stdenv.cc.isClang "-faligned-allocation";
+    ++ lib.optional stdenv.cc.isClang "-faligned-allocation"
+    ++ lib.optional disableLTO "-fno-lto";
+
+  NIX_CFLAGS_LINK = lib.optional disableLTO "-fno-lto";
 
   buildPhase = ''
     make -j $NIX_BUILD_CORES -C profiler/build/unix release
···
     install -D ./update/build/unix/update-release $out/bin/update
   '';
 
-  fixupPhase = lib.optionalString stdenv.isDarwin ''
+  postFixup = lib.optionalString stdenv.isDarwin ''
     install_name_tool -change libcapstone.4.dylib ${capstone}/lib/libcapstone.4.dylib $out/bin/Tracy
   '';
 

pkgs/development/tools/vendir/default.nix

···
 
 buildGoModule rec {
   pname = "vendir";
-  version = "0.17.0";
+  version = "0.18.0";
 
   src = fetchFromGitHub {
     owner = "vmware-tanzu";
     repo = "carvel-vendir";
     rev = "v${version}";
-    sha256 = "14yd14z4666alwsn2jhcvg2kijvw4qjr4h3gikchiir38w520fs9";
+    sha256 = "sha256-+VZ1EWrEvTbWeO/o7EkkF2Xcro7UpCrnsOJjOCtfNzY=";
   };
 
   vendorSha256 = null;

pkgs/development/tools/vogl/default.nix

···
 { mkDerivation, lib, fetchFromGitHub
 , cmake, git, pkg-config, wget, zip
 , qtbase, qtx11extras
-, libdwarf, libjpeg_turbo, libunwind, lzma, tinyxml, libX11
+, libdwarf, libjpeg_turbo, libunwind, xz, tinyxml, libX11
 , SDL2, SDL2_gfx, SDL2_image, SDL2_ttf
 , freeglut, libGLU
 , fetchpatch
···
   buildInputs = [
     git wget zip
     qtbase qtx11extras
-    libdwarf libjpeg_turbo libunwind lzma tinyxml libX11
+    libdwarf libjpeg_turbo libunwind xz tinyxml libX11
     SDL2 SDL2_gfx SDL2_image SDL2_ttf
     freeglut libGLU
   ];

pkgs/development/tools/vultr-cli/default.nix

···
 
 buildGoModule rec {
   pname = "vultr-cli";
-  version = "2.3.0";
+  version = "2.4.0";
 
   src = fetchFromGitHub {
     owner = "vultr";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-FXOwLYxUMkE+wDY30vjnSZ7zPWZWuWmIH4Uuc0CC7lU=";
+    sha256 = "sha256-TNytKq2LqLWxNrqesOJbNQUTirvPkxLMqJmtbmFq+0Y=";
   };
 
   vendorSha256 = null;

pkgs/development/tools/xcbuild/toolchains.nix

···
     fi
   done
 
-  ln -s ${buildPackages.yacc}/bin/yacc $toolchain/bin/yacc
-  ln -s ${buildPackages.yacc}/bin/bison $toolchain/bin/bison
+  ln -s ${buildPackages.bison}/bin/yacc $toolchain/bin/yacc
+  ln -s ${buildPackages.bison}/bin/bison $toolchain/bin/bison
   ln -s ${buildPackages.flex}/bin/flex $toolchain/bin/flex
   ln -s ${buildPackages.flex}/bin/flex++ $toolchain/bin/flex++
   ln -s $toolchain/bin/flex $toolchain/bin/lex

pkgs/games/cockatrice/default.nix

···
 
 mkDerivation rec {
   pname = "cockatrice";
-  version = "2021-01-26-Release-2.8.0";
+  version = "2021-02-03-Development-2.8.1-beta";
 
   src = fetchFromGitHub {
     owner = "Cockatrice";
     repo = "Cockatrice";
     rev = version;
-    sha256 = "0q8ffcklb2b7hcqhy3d2f9kz9aw22pp04pc9y4sslyqmf17pwnz9";
+    sha256 = "0g1d7zq4lh4jf08mvvgp6m2r2gdvy4y1mhf46c0s8607h2l8vavh";
   };
 
   buildInputs = [
···
   meta = {
     homepage = "https://github.com/Cockatrice/Cockatrice";
     description = "A cross-platform virtual tabletop for multiplayer card games";
-    license = lib.licenses.gpl2;
+    license = lib.licenses.gpl2Plus;
     maintainers = with lib.maintainers; [ evanjs ];
     platforms = with lib.platforms; linux;
   };

pkgs/games/devilutionx/default.nix

···
 { lib, stdenv, fetchFromGitHub, cmake, SDL2, SDL2_mixer, SDL2_ttf, libsodium, pkg-config }:
 stdenv.mkDerivation rec {
-  version = "2020-10-20";
-  pname = "devilutionx-unstable";
+  pname = "devilutionx";
+  version = "unstable-2020-10-20";
 
   src = fetchFromGitHub {
     owner = "diasurgical";
···
   cmakeFlags = [
     "-DBINARY_RELEASE=ON"
   ];
-
-  enableParallelBuilding = true;
 
   nativeBuildInputs = [ pkg-config cmake ];
   buildInputs = [ libsodium SDL2 SDL2_mixer SDL2_ttf ];

pkgs/games/freeciv/default.nix

···
 { lib, stdenv, fetchFromGitHub, autoreconfHook, lua5_3, pkg-config, python3
-, zlib, bzip2, curl, lzma, gettext, libiconv
+, zlib, bzip2, curl, xz, gettext, libiconv
 , sdlClient ? true, SDL, SDL_mixer, SDL_image, SDL_ttf, SDL_gfx, freetype, fluidsynth
 , gtkClient ? false, gtk3
 , qtClient ? false, qt5
···
   nativeBuildInputs = [ autoreconfHook pkg-config ]
     ++ optional qtClient [ qt5.wrapQtAppsHook ];
 
-  buildInputs = [ lua5_3 zlib bzip2 curl lzma gettext libiconv ]
+  buildInputs = [ lua5_3 zlib bzip2 curl xz gettext libiconv ]
     ++ optionals sdlClient [ SDL SDL_mixer SDL_image SDL_ttf SDL_gfx freetype fluidsynth ]
     ++ optionals gtkClient [ gtk3 ]
     ++ optionals qtClient  [ qt5.qtbase ]

pkgs/games/sm64ex/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "sm64ex";
-  version = "unstable-2020-06-19";
+  version = "unstable-2020-10-09";
 
   src = fetchFromGitHub {
     owner = "sm64pc";
     repo = "sm64ex";
-    rev = "f5005418348cf1a53bfa75ff415a513ef0b9b273";
-    sha256 = "0adyshkqk5c4lxhdxc3j6ax4svfka26486qpa5q2gl2nixwg9zxn";
+    rev = "57c203465b2b3eee03dcb796ed1fad07d8283a2c";
+    sha256 = "0k6a3r9f4spa7y2v1lyqs9lwa05lw8xgywllb7w828nal8y33cs6";
   };
 
   nativeBuildInputs = [ python3 pkg-config ];

pkgs/games/spring/default.nix

···
-{ lib, stdenv, fetchFromGitHub, cmake, lzma, boost, libdevil, zlib, p7zip
+{ lib, stdenv, fetchFromGitHub, cmake, xz, boost, libdevil, zlib, p7zip
 , openal, libvorbis, glew, freetype, xorg, SDL2, libGLU, libGL
 , asciidoc, docbook_xsl, docbook_xsl_ns, curl, makeWrapper
 , jdk ? null, python ? null, systemd, libunwind, which, minizip
···
                 "-DPREFER_STATIC_LIBS:BOOL=OFF"];
 
   nativeBuildInputs = [ cmake makeWrapper docbook_xsl docbook_xsl_ns asciidoc ];
-  buildInputs = [ lzma boost libdevil zlib p7zip openal libvorbis freetype SDL2
+  buildInputs = [ xz boost libdevil zlib p7zip openal libvorbis freetype SDL2
     xorg.libX11 xorg.libXcursor libGLU libGL glew curl
     systemd libunwind which minizip ]
     ++ lib.optional withAI jdk

pkgs/games/unciv/default.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "unciv";
-  version = "3.13.11-patch2";
+  version = "3.13.12-patch1";
 
   src = fetchurl {
     url = "https://github.com/yairm210/Unciv/releases/download/${version}/Unciv.jar";
-    sha256 = "sha256-UN/M1G36nYy1mhKz0xA3/oZ8hWrkyeXWm9dMxL9PSDo=";
+    sha256 = "sha256-SgDfa3henwUb+oKybFJhvo1GkmC24wWz3U78etk+Dsk=";
   };
 
   dontUnpack = true;

pkgs/games/warzone2100/default.nix

···
 { lib
-, mkDerivation
+, stdenv
 , fetchurl
 , cmake
 , ninja
-, zip, unzip
+, zip
 , pkg-config
 , asciidoctor
 , gettext
 
-, qtbase
-, qtscript
 , SDL2
 , libtheora
 , libvorbis
 , openal
 , openalSoft
-, glew
 , physfs
-, fribidi
-, libXrandr
 , miniupnpc
 , libsodium
 , curl
···
 , harfbuzz
 , sqlite
 , which
+, vulkan-headers
+, vulkan-loader
+, shaderc
 
 , withVideos ? false
 }:
···
   };
 in
 
-mkDerivation rec {
+stdenv.mkDerivation rec {
   inherit pname;
-  version  = "3.4.1";
+  version  = "4.0.0";
 
   src = fetchurl {
     url = "mirror://sourceforge/${pname}/releases/${version}/${pname}_src.tar.xz";
-    sha256 = "0savalmw1kp1sf8vg5aqrl5hc77p4jacxy5y9qj8k2hi2vqdfb7a";
+    sha256 = "1d94072yns2xrjpagw1mqq7iyywhwz7vn3lgjdwmbgjy79jzcs1k";
   };
 
   buildInputs = [
-    qtbase
-    qtscript
     SDL2
     libtheora
     libvorbis
     openal
     openalSoft
-    glew
     physfs
-    fribidi
-    libXrandr
     miniupnpc
     libsodium
     curl
···
     freetype
     harfbuzz
     sqlite
+    vulkan-headers
+    vulkan-loader
   ];
 
   nativeBuildInputs = [
+    pkg-config
     cmake
     ninja
-    zip unzip
+    zip
     asciidoctor
     gettext
+    shaderc
   ];
 
   postPatch = ''

pkgs/misc/drivers/foo2zjs/default.nix

···
 { lib, stdenv, fetchurl, foomatic-filters, bc, unzip, ghostscript, systemd, vim, time }:
 
 stdenv.mkDerivation rec {
-  name = "foo2zjs-20180519";
+  pname = "foo2zjs";
+  version = "20210116";
 
   src = fetchurl {
-    url = "http://www.loegria.net/mirrors/foo2zjs/${name}.tar.gz";
-    sha256 = "1rmw4jmxn2lqp124mapvnic0ma8ipyvisx2vj848mvad5g5w9x3z";
+    url = "http://www.loegria.net/mirrors/foo2zjs/foo2zjs-${version}.tar.gz";
+    sha256 = "14x3wizvncdy0xgvmcx541qanwb7bg76abygqy17bxycn1zh5r1x";
   };
 
   nativeBuildInputs = [ unzip ];

pkgs/misc/emulators/cdemu/libmirage.nix

···
 { callPackage, gobject-introspection, cmake, pkg-config
-, glib, libsndfile, zlib, bzip2, lzma, libsamplerate, intltool
+, glib, libsndfile, zlib, bzip2, xz, libsamplerate, intltool
 , pcre, util-linux, libselinux, libsepol }:
 
 let pkg = import ./base.nix {
···
   pkgSha256 = "08mfvqyk3833ksfd47i4j3ppmrw5ry219km6h7lywdh9hm9x14yf";
 };
 in callPackage pkg {
-  buildInputs = [ glib libsndfile zlib bzip2 lzma libsamplerate intltool ];
+  buildInputs = [ glib libsndfile zlib bzip2 xz libsamplerate intltool ];
   drvParams = {
     PKG_CONFIG_GOBJECT_INTROSPECTION_1_0_GIRDIR = "${placeholder "out"}/share/gir-1.0";
     PKG_CONFIG_GOBJECT_INTROSPECTION_1_0_TYPELIBDIR = "${placeholder "out"}/lib/girepository-1.0";

pkgs/misc/emulators/dlx/default.nix

···
-{ lib, stdenv, fetchurl, unzip }:
+{ lib, stdenv, fetchzip }:
 
-stdenv.mkDerivation {
-  name = "dlx-2012.07.08";
+stdenv.mkDerivation rec {
+  pname = "dlx";
+  version = "2012-07-08";
 
-  src = fetchurl {
+  src = fetchzip {
     url = "https://www.davidviner.com/zip/dlx/dlx.zip";
-    sha256 = "0q5hildq2xcig7yrqi26n7fqlanyssjirm7swy2a9icfxpppfpkn";
+    sha256 = "0508linnar9ivy3xr99gzrb2l027ngx12dlxaxs7w67cnwqnb0dg";
   };
 
-  nativeBuildInputs = [ unzip ];
-
   makeFlags = [ "CC=${stdenv.cc.targetPrefix}cc" "LINK=${stdenv.cc.targetPrefix}cc" "CFLAGS=-O2" ];
-
   hardeningDisable = [ "format" ];
 
   installPhase = ''
     mkdir -p $out/include/dlx $out/share/dlx/{examples,doc} $out/bin
-    mv -v masm mon dasm $out/bin/
-    mv -v *.i auto.a $out/include/dlx/
-    mv -v *.a *.m $out/share/dlx/examples/
-    mv -v README.txt MANUAL.TXT $out/share/dlx/doc/
+    mv masm mon dasm $out/bin/
+    mv *.i auto.a $out/include/dlx/
+    mv *.a *.m $out/share/dlx/examples/
+    mv README.txt MANUAL.TXT $out/share/dlx/doc/
   '';
 
-  meta = {
-    homepage = "http://www.davidviner.com/dlx.php";
-    description = "DLX Simulator";
-    license = lib.licenses.gpl2;
-    platforms = lib.platforms.all;
+  meta = with lib; {
+    homepage = "https://www.davidviner.com/dlx.html?name=DLX+Simulator";
+    description = "An DLX simulator written in C";
+    license = licenses.gpl2Only;
+    platforms = platforms.linux;
   };
 }

pkgs/misc/emulators/ryujinx/default.nix

···
 { lib, stdenv, fetchFromGitHub, fetchurl, makeWrapper, makeDesktopItem, linkFarmFromDrvs
 , dotnet-sdk_5, dotnetPackages, dotnetCorePackages, cacert
-, SDL2, libX11, ffmpeg, openal, libsoundio
+, SDL2, libX11, libgdiplus, ffmpeg, openal, libsoundio
 , gtk3, gobject-introspection, gdk-pixbuf, wrapGAppsHook
 }:
 
···
     SDL2
     gtk3
     libX11
+    libgdiplus
     ffmpeg
     openal
     libsoundio
   ];
 in stdenv.mkDerivation rec {
   pname = "ryujinx";
-  version = "1.0.6574"; # Versioning is based off of the official appveyor builds: https://ci.appveyor.com/project/gdkchan/ryujinx
+  version = "1.0.6807"; # Versioning is based off of the official appveyor builds: https://ci.appveyor.com/project/gdkchan/ryujinx
 
   src = fetchFromGitHub {
     owner = "Ryujinx";
     repo = "Ryujinx";
-    rev = "80ed8596c165127fb52026c697a9b6b515dabbd4";
-    sha256 = "0jhrl8g9fbz3w2hzmy9jm22cvjfa0x5vh3912rz1rvnd41qb9vs8";
+    rev = "0ee314fb3b9d476d0d207a3595bde24af9c4b69b";
+    sha256 = "1yyjy5qblsdg186hr81qpc07n0cqla67q3hjf2rrzq5pyb10bldy";
   };
 
   nativeBuildInputs = [ dotnet-sdk_5 dotnetPackages.Nuget cacert makeWrapper wrapGAppsHook gobject-introspection gdk-pixbuf ];
···
 
   patches = [
     ./log.patch # Without this, Ryujinx attempts to write logs to the nix store. This patch makes it write to "~/.config/Ryujinx/Logs" on Linux.
-    ./disable-updater.patch # This disables the auto-updater, which does not work as it attempts to modify the nix store.
   ];
 
   configurePhase = ''
···
     maintainers = [ maintainers.ivar ];
     platforms = [ "x86_64-linux" ];
   };
+  passthru.updateScript = ./updater.sh;
 }

pkgs/misc/emulators/ryujinx/deps.nix

···
     sha256 = "0nb46jiscnsywwdfy7zhx1bw4jfmca3s6l8dhbi99gc4bvp8ar7p";
   })
   (fetchNuGet {
-    name = "GtkSharp";
-    version = "3.22.25.128";
-    sha256 = "0z0wx0p3gc02r8d7y88k1rw307sb2vapbr1k1yc5qdc38fxz5jsy";
-  })
-  (fetchNuGet {
     name = "GtkSharp.Dependencies";
     version = "1.1.0";
     sha256 = "1g1rhcn38ww97638rds6l5bysra43hkhv47fy71fvq89623zgyxn";
+  })
+  (fetchNuGet {
+    name = "GtkSharp";
+    version = "3.22.25.128";
+    sha256 = "0z0wx0p3gc02r8d7y88k1rw307sb2vapbr1k1yc5qdc38fxz5jsy";
   })
   (fetchNuGet {
     name = "LibHac";
···
     sha256 = "0mp8ihqlb7fsa789frjzidrfjc1lrhk88qp3xm5qvr7vf4wy4z8x";
   })
   (fetchNuGet {
+    name = "Microsoft.NET.Test.Sdk";
+    version = "16.8.0";
+    sha256 = "1ln2mva7j2mpsj9rdhpk8vhm3pgd8wn563xqdcwd38avnhp74rm9";
+  })
+  (fetchNuGet {
     name = "Microsoft.NETCore.App.Host.osx-x64";
     version = "5.0.0";
     sha256 = "1nirb155gzn2ws1ayaqspjmjaizw87jq2684mzkn18jv4si0hbpf";
···
     sha256 = "193xwf33fbm0ni3idxzbr5fdq3i2dlfgihsac9jj7whj0gd902nh";
   })
   (fetchNuGet {
-    name = "Microsoft.NET.Test.Sdk";
-    version = "16.8.0";
-    sha256 = "1ln2mva7j2mpsj9rdhpk8vhm3pgd8wn563xqdcwd38avnhp74rm9";
-  })
-  (fetchNuGet {
     name = "Microsoft.TestPlatform.ObjectModel";
     version = "16.8.0";
     sha256 = "0ii9d88py6mjsxzj9v3zx4izh6rb9ma6s9kj85xmc0xrw7jc2g3m";
···
     sha256 = "0fnkv3ky12227zqg4zshx4kw2mvysq2ppxjibfw02cc3iprv4njq";
   })
   (fetchNuGet {
+    name = "Microsoft.Win32.SystemEvents";
+    version = "5.0.0";
+    sha256 = "0sja4ba0mrvdamn0r9mhq38b9dxi08yb3c1hzh29n1z6ws1hlrcq";
+  })
+  (fetchNuGet {
     name = "Mono.Posix.NETStandard";
     version = "1.0.0";
     sha256 = "0xlja36hwpjm837haq15mjh2prcf68lyrmn72nvgpz8qnf9vappw";
···
     sha256 = "00j6nv2xgmd3bi347k00m7wr542wjlig53rmj28pmw7ddcn97jbn";
   })
   (fetchNuGet {
-    name = "runtime.any.System.Globalization";
+    name = "runtime.any.System.Globalization.Calendars";
     version = "4.3.0";
-    sha256 = "1daqf33hssad94lamzg01y49xwndy2q97i2lrb7mgn28656qia1x";
+    sha256 = "1ghhhk5psqxcg6w88sxkqrc35bxcz27zbqm2y5p5298pv3v7g201";
   })
   (fetchNuGet {
-    name = "runtime.any.System.Globalization.Calendars";
+    name = "runtime.any.System.Globalization";
     version = "4.3.0";
-    sha256 = "1ghhhk5psqxcg6w88sxkqrc35bxcz27zbqm2y5p5298pv3v7g201";
+    sha256 = "1daqf33hssad94lamzg01y49xwndy2q97i2lrb7mgn28656qia1x";
   })
   (fetchNuGet {
     name = "runtime.any.System.IO";
···
     sha256 = "0l8xz8zn46w4d10bcn3l4yyn4vhb3lrj2zw8llvz7jk14k4zps5x";
   })
   (fetchNuGet {
-    name = "runtime.any.System.Reflection";
-    version = "4.3.0";
-    sha256 = "02c9h3y35pylc0zfq3wcsvc5nqci95nrkq0mszifc0sjx7xrzkly";
-  })
-  (fetchNuGet {
     name = "runtime.any.System.Reflection.Extensions";
     version = "4.3.0";
     sha256 = "0zyri97dfc5vyaz9ba65hjj1zbcrzaffhsdlpxc9bh09wy22fq33";
···
     sha256 = "0x1mm8c6iy8rlxm8w9vqw7gb7s1ljadrn049fmf70cyh42vdfhrf";
   })
   (fetchNuGet {
-    name = "runtime.any.System.Resources.ResourceManager";
+    name = "runtime.any.System.Reflection";
     version = "4.3.0";
-    sha256 = "03kickal0iiby82wa5flar18kyv82s9s6d4xhk5h4bi5kfcyfjzl";
+    sha256 = "02c9h3y35pylc0zfq3wcsvc5nqci95nrkq0mszifc0sjx7xrzkly";
   })
   (fetchNuGet {
-    name = "runtime.any.System.Runtime";
+    name = "runtime.any.System.Resources.ResourceManager";
     version = "4.3.0";
-    sha256 = "1cqh1sv3h5j7ixyb7axxbdkqx6cxy00p4np4j91kpm492rf4s25b";
+    sha256 = "03kickal0iiby82wa5flar18kyv82s9s6d4xhk5h4bi5kfcyfjzl";
   })
   (fetchNuGet {
     name = "runtime.any.System.Runtime.Handles";
···
     sha256 = "0c3g3g3jmhlhw4klrc86ka9fjbl7i59ds1fadsb2l8nqf8z3kb19";
   })
   (fetchNuGet {
-    name = "runtime.any.System.Text.Encoding";
+    name = "runtime.any.System.Runtime";
     version = "4.3.0";
-    sha256 = "0aqqi1v4wx51h51mk956y783wzags13wa7mgqyclacmsmpv02ps3";
+    sha256 = "1cqh1sv3h5j7ixyb7axxbdkqx6cxy00p4np4j91kpm492rf4s25b";
   })
   (fetchNuGet {
     name = "runtime.any.System.Text.Encoding.Extensions";
···
     sha256 = "0lqhgqi0i8194ryqq6v2gqx0fb86db2gqknbm0aq31wb378j7ip8";
   })
   (fetchNuGet {
+    name = "runtime.any.System.Text.Encoding";
+    version = "4.3.0";
+    sha256 = "0aqqi1v4wx51h51mk956y783wzags13wa7mgqyclacmsmpv02ps3";
+  })
+  (fetchNuGet {
     name = "runtime.any.System.Threading.Tasks";
     version = "4.3.0";
     sha256 = "03mnvkhskbzxddz4hm113zsch1jyzh2cs450dk3rgfjp8crlw1va";
···
     sha256 = "0c2p354hjx58xhhz7wv6div8xpi90sc6ibdm40qin21bvi7ymcaa";
   })
   (fetchNuGet {
-    name = "runtime.native.System";
-    version = "4.0.0";
-    sha256 = "1ppk69xk59ggacj9n7g6fyxvzmk1g5p4fkijm0d7xqfkig98qrkf";
-  })
-  (fetchNuGet {
-    name = "runtime.native.System";
-    version = "4.3.0";
-    sha256 = "15hgf6zaq9b8br2wi1i3x0zvmk410nlmsmva9p0bbg73v6hml5k4";
-  })
-  (fetchNuGet {
     name = "runtime.native.System.IO.Compression";
     version = "4.1.0";
     sha256 = "0d720z4lzyfcabmmnvh0bnj76ll7djhji2hmfh3h44sdkjnlkknk";
···
     name = "runtime.native.System.Net.Http";
     version = "4.0.1";
     sha256 = "1hgv2bmbaskx77v8glh7waxws973jn4ah35zysnkxmf0196sfxg6";
+  })
+  (fetchNuGet {
+    name = "runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.0";
+    sha256 = "18pzfdlwsg2nb1jjjjzyb5qlgy6xjxzmhnfaijq5s2jw3cm3ab97";
   })
   (fetchNuGet {
     name = "runtime.native.System.Security.Cryptography";
···
     sha256 = "0k57aa2c3b10wl3hfqbgrl7xq7g8hh3a3ir44b31dn5p61iiw3z9";
   })
   (fetchNuGet {
-    name = "runtime.native.System.Security.Cryptography.OpenSsl";
+    name = "runtime.native.System";
+    version = "4.0.0";
+    sha256 = "1ppk69xk59ggacj9n7g6fyxvzmk1g5p4fkijm0d7xqfkig98qrkf";
+  })
+  (fetchNuGet {
+    name = "runtime.native.System";
     version = "4.3.0";
-    sha256 = "18pzfdlwsg2nb1jjjjzyb5qlgy6xjxzmhnfaijq5s2jw3cm3ab97";
+    sha256 = "15hgf6zaq9b8br2wi1i3x0zvmk410nlmsmva9p0bbg73v6hml5k4";
   })
   (fetchNuGet {
     name = "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl";
···
     sha256 = "1pizj82wisch28nfdaszwqm9bz19lnl0s5mq8c0zybm2vhnrhvk4";
   })
   (fetchNuGet {
+    name = "SixLabors.Fonts";
+    version = "1.0.0-beta0013";
+    sha256 = "0r0aw8xxd32rwcawawcz6asiyggz02hnzg5hvz8gimq8hvwx1wql";
+  })
+  (fetchNuGet {
+    name = "SixLabors.ImageSharp.Drawing";
+    version = "1.0.0-beta11";
+    sha256 = "0hl0rs3kr1zdnx3gdssxgli6fyvmwzcfp99f4db71s0i8j8b2bp5";
+  })
+  (fetchNuGet {
+    name = "SixLabors.ImageSharp";
+    version = "1.0.2";
+    sha256 = "0fhk9sn8k18slfb26wz8mal0j699f7djwhxgv97snz6b10wynfaj";
+  })
+  (fetchNuGet {
     name = "System.AppContext";
     version = "4.1.0";
     sha256 = "0fv3cma1jp4vgj7a8hqc9n7hr1f1kjp541s6z0q1r6nazb4iz9mz";
···
     name = "System.CodeDom";
     version = "5.0.0";
     sha256 = "14zs2wqkmdlxzj8ikx19n321lsbarx5vl2a8wrachymxn8zb5njh";
-  })
-  (fetchNuGet {
-    name = "System.Collections";
-    version = "4.0.11";
-    sha256 = "1ga40f5lrwldiyw6vy67d0sg7jd7ww6kgwbksm19wrvq9hr0bsm6";
-  })
-  (fetchNuGet {
-    name = "System.Collections";
-    version = "4.3.0";
-    sha256 = "19r4y64dqyrq6k4706dnyhhw7fs24kpp3awak7whzss39dakpxk9";
   })
   (fetchNuGet {
     name = "System.Collections.Concurrent";
···
     sha256 = "1sdwkma4f6j85m3dpb53v9vcgd0zyc9jb33f8g63byvijcj39n20";
   })
   (fetchNuGet {
-    name = "System.ComponentModel";
+    name = "System.Collections";
+    version = "4.0.11";
+    sha256 = "1ga40f5lrwldiyw6vy67d0sg7jd7ww6kgwbksm19wrvq9hr0bsm6";
+  })
+  (fetchNuGet {
+    name = "System.Collections";
     version = "4.3.0";
-    sha256 = "0986b10ww3nshy30x9sjyzm0jx339dkjxjj3401r3q0f6fx2wkcb";
+    sha256 = "19r4y64dqyrq6k4706dnyhhw7fs24kpp3awak7whzss39dakpxk9";
   })
   (fetchNuGet {
     name = "System.ComponentModel.EventBasedAsync";
···
     name = "System.ComponentModel.TypeConverter";
     version = "4.3.0";
     sha256 = "17ng0p7v3nbrg3kycz10aqrrlw4lz9hzhws09pfh8gkwicyy481x";
+  })
+  (fetchNuGet {
+    name = "System.ComponentModel";
+    version = "4.3.0";
+    sha256 = "0986b10ww3nshy30x9sjyzm0jx339dkjxjj3401r3q0f6fx2wkcb";
   })
   (fetchNuGet {
     name = "System.Console";
···
     sha256 = "0knqa0zsm91nfr34br8gx5kjqq4v81zdhqkacvs2hzc8nqk0ddhc";
   })
   (fetchNuGet {
+    name = "System.Drawing.Common";
+    version = "5.0.1";
+    sha256 = "14h722wq58k1wmgxmpws91xc7kh8109ijw0hcxjq9qkbhbi6pwmb";
+  })
+  (fetchNuGet {
     name = "System.Dynamic.Runtime";
     version = "4.0.11";
     sha256 = "1pla2dx8gkidf7xkciig6nifdsb494axjvzvann8g2lp3dbqasm9";
   })
   (fetchNuGet {
-    name = "System.Globalization";
-    version = "4.0.11";
-    sha256 = "070c5jbas2v7smm660zaf1gh0489xanjqymkvafcs4f8cdrs1d5d";
-  })
-  (fetchNuGet {
-    name = "System.Globalization";
-    version = "4.3.0";
-    sha256 = "1cp68vv683n6ic2zqh2s1fn4c2sd87g5hpp6l4d4nj4536jz98ki";
-  })
-  (fetchNuGet {
     name = "System.Globalization.Calendars";
     version = "4.0.1";
     sha256 = "0bv0alrm2ck2zk3rz25lfyk9h42f3ywq77mx1syl6vvyncnpg4qh";
···
     sha256 = "02a5zfxavhv3jd437bsncbhd2fp1zv4gxzakp1an9l6kdq1mcqls";
   })
   (fetchNuGet {
-    name = "System.IO";
-    version = "4.1.0";
-    sha256 = "1g0yb8p11vfd0kbkyzlfsbsp5z44lwsvyc0h3dpw6vqnbi035ajp";
+    name = "System.Globalization";
+    version = "4.0.11";
+    sha256 = "070c5jbas2v7smm660zaf1gh0489xanjqymkvafcs4f8cdrs1d5d";
   })
   (fetchNuGet {
-    name = "System.IO";
+    name = "System.Globalization";
     version = "4.3.0";
-    sha256 = "05l9qdrzhm4s5dixmx68kxwif4l99ll5gqmh7rqgw554fx0agv5f";
+    sha256 = "1cp68vv683n6ic2zqh2s1fn4c2sd87g5hpp6l4d4nj4536jz98ki";
+  })
+  (fetchNuGet {
+    name = "System.IO.Compression.ZipFile";
+    version = "4.0.1";
+    sha256 = "0h72znbagmgvswzr46mihn7xm7chfk2fhrp5krzkjf29pz0i6z82";
   })
   (fetchNuGet {
     name = "System.IO.Compression";
···
     sha256 = "0iym7s3jkl8n0vzm3jd6xqg9zjjjqni05x45dwxyjr2dy88hlgji";
   })
   (fetchNuGet {
-    name = "System.IO.Compression.ZipFile";
+    name = "System.IO.FileSystem.Primitives";
     version = "4.0.1";
-    sha256 = "0h72znbagmgvswzr46mihn7xm7chfk2fhrp5krzkjf29pz0i6z82";
+    sha256 = "1s0mniajj3lvbyf7vfb5shp4ink5yibsx945k6lvxa96r8la1612";
+  })
+  (fetchNuGet {
+    name = "System.IO.FileSystem.Primitives";
+    version = "4.3.0";
+    sha256 = "0j6ndgglcf4brg2lz4wzsh1av1gh8xrzdsn9f0yznskhqn1xzj9c";
   })
   (fetchNuGet {
     name = "System.IO.FileSystem";
···
     sha256 = "0z2dfrbra9i6y16mm9v1v6k47f0fm617vlb7s5iybjjsz6g1ilmw";
   })
   (fetchNuGet {
-    name = "System.IO.FileSystem.Primitives";
-    version = "4.0.1";
-    sha256 = "1s0mniajj3lvbyf7vfb5shp4ink5yibsx945k6lvxa96r8la1612";
+    name = "System.IO";
+    version = "4.1.0";
+    sha256 = "1g0yb8p11vfd0kbkyzlfsbsp5z44lwsvyc0h3dpw6vqnbi035ajp";
   })
   (fetchNuGet {
-    name = "System.IO.FileSystem.Primitives";
+    name = "System.IO";
     version = "4.3.0";
-    sha256 = "0j6ndgglcf4brg2lz4wzsh1av1gh8xrzdsn9f0yznskhqn1xzj9c";
+    sha256 = "05l9qdrzhm4s5dixmx68kxwif4l99ll5gqmh7rqgw554fx0agv5f";
+  })
+  (fetchNuGet {
+    name = "System.Linq.Expressions";
+    version = "4.1.0";
+    sha256 = "1gpdxl6ip06cnab7n3zlcg6mqp7kknf73s8wjinzi4p0apw82fpg";
   })
   (fetchNuGet {
     name = "System.Linq";
···
     name = "System.Linq";
     version = "4.3.0";
     sha256 = "1w0gmba695rbr80l1k2h4mrwzbzsyfl2z4klmpbsvsg5pm4a56s7";
-  })
-  (fetchNuGet {
-    name = "System.Linq.Expressions";
-    version = "4.1.0";
-    sha256 = "1gpdxl6ip06cnab7n3zlcg6mqp7kknf73s8wjinzi4p0apw82fpg";
   })
   (fetchNuGet {
     name = "System.Management";
···
     sha256 = "05kji1mv4sl75iwmc613p873145nynm02xiajx8pn0h2kx53d23s";
   })
   (fetchNuGet {
+    name = "System.Numerics.Vectors";
+    version = "4.5.0";
+    sha256 = "1kzrj37yzawf1b19jq0253rcs8hsq1l2q8g69d7ipnhzb0h97m59";
+  })
+  (fetchNuGet {
     name = "System.ObjectModel";
     version = "4.0.12";
     sha256 = "1sybkfi60a4588xn34nd9a58png36i0xr4y4v4kqpg8wlvy5krrj";
···
     sha256 = "04r1lkdnsznin0fj4ya1zikxiqr0h6r6a1ww2dsm60gqhdrf0mvx";
   })
   (fetchNuGet {
-    name = "System.Reflection";
-    version = "4.1.0";
-    sha256 = "1js89429pfw79mxvbzp8p3q93il6rdff332hddhzi5wqglc4gml9";
-  })
-  (fetchNuGet {
-    name = "System.Reflection";
-    version = "4.3.0";
-    sha256 = "0xl55k0mw8cd8ra6dxzh974nxif58s3k1rjv1vbd7gjbjr39j11m";
-  })
-  (fetchNuGet {
-    name = "System.Reflection.Emit";
-    version = "4.0.1";
-    sha256 = "0ydqcsvh6smi41gyaakglnv252625hf29f7kywy2c70nhii2ylqp";
-  })
-  (fetchNuGet {
-    name = "System.Reflection.Emit";
-    version = "4.3.0";
-    sha256 = "11f8y3qfysfcrscjpjym9msk7lsfxkk4fmz9qq95kn3jd0769f74";
-  })
-  (fetchNuGet {
     name = "System.Reflection.Emit.ILGeneration";
     version = "4.0.1";
     sha256 = "1pcd2ig6bg144y10w7yxgc9d22r7c7ww7qn1frdfwgxr24j9wvv0";
···
     sha256 = "0ql7lcakycrvzgi9kxz1b3lljd990az1x6c4jsiwcacrvimpib5c";
   })
   (fetchNuGet {
+    name = "System.Reflection.Emit";
+    version = "4.0.1";
+    sha256 = "0ydqcsvh6smi41gyaakglnv252625hf29f7kywy2c70nhii2ylqp";
+  })
+  (fetchNuGet {
+    name = "System.Reflection.Emit";
+    version = "4.3.0";
+    sha256 = "11f8y3qfysfcrscjpjym9msk7lsfxkk4fmz9qq95kn3jd0769f74";
+  })
+  (fetchNuGet {
     name = "System.Reflection.Extensions";
     version = "4.0.1";
     sha256 = "0m7wqwq0zqq9gbpiqvgk3sr92cbrw7cp3xn53xvw7zj6rz6fdirn";
···
     sha256 = "0y2ssg08d817p0vdag98vn238gyrrynjdj4181hdg780sif3ykp1";
   })
   (fetchNuGet {
+    name = "System.Reflection";
+    version = "4.1.0";
+    sha256 = "1js89429pfw79mxvbzp8p3q93il6rdff332hddhzi5wqglc4gml9";
+  })
+  (fetchNuGet {
+    name = "System.Reflection";
+    version = "4.3.0";
+    sha256 = "0xl55k0mw8cd8ra6dxzh974nxif58s3k1rjv1vbd7gjbjr39j11m";
+  })
+  (fetchNuGet {
     name = "System.Resources.ResourceManager";
     version = "4.0.1";
     sha256 = "0b4i7mncaf8cnai85jv3wnw6hps140cxz8vylv2bik6wyzgvz7bi";
···
     sha256 = "0sjqlzsryb0mg4y4xzf35xi523s4is4hz9q4qgdvlvgivl7qxn49";
   })
   (fetchNuGet {
-    name = "System.Runtime";
-    version = "4.1.0";
-    sha256 = "02hdkgk13rvsd6r9yafbwzss8kr55wnj8d5c7xjnp8gqrwc8sn0m";
-  })
-  (fetchNuGet {
-    name = "System.Runtime";
-    version = "4.3.0";
-    sha256 = "066ixvgbf2c929kgknshcxqj6539ax7b9m570cp8n179cpfkapz7";
+    name = "System.Runtime.CompilerServices.Unsafe";
+    version = "4.7.0";
+    sha256 = "16r6sn4czfjk8qhnz7bnqlyiaaszr0ihinb7mq9zzr1wba257r54";
   })
   (fetchNuGet {
     name = "System.Runtime.CompilerServices.Unsafe";
···
     sha256 = "0sw2gfj2xr7sw9qjn0j3l9yw07x73lcs97p8xfc9w1x9h5g5m7i8";
   })
   (fetchNuGet {
+    name = "System.Runtime.InteropServices.RuntimeInformation";
+    version = "4.0.0";
+    sha256 = "0glmvarf3jz5xh22iy3w9v3wyragcm4hfdr17v90vs7vcrm7fgp6";
+  })
+  (fetchNuGet {
+    name = "System.Runtime.InteropServices.RuntimeInformation";
+    version = "4.3.0";
+    sha256 = "0q18r1sh4vn7bvqgd6dmqlw5v28flbpj349mkdish2vjyvmnb2ii";
+  })
+  (fetchNuGet {
     name = "System.Runtime.InteropServices";
     version = "4.1.0";
     sha256 = "01kxqppx3dr3b6b286xafqilv4s2n0gqvfgzfd4z943ga9i81is1";
···
     sha256 = "00hywrn4g7hva1b2qri2s6rabzwgxnbpw9zfxmz28z09cpwwgh7j";
   })
   (fetchNuGet {
-    name = "System.Runtime.InteropServices.RuntimeInformation";
-    version = "4.0.0";
-    sha256 = "0glmvarf3jz5xh22iy3w9v3wyragcm4hfdr17v90vs7vcrm7fgp6";
-  })
-  (fetchNuGet {
-    name = "System.Runtime.InteropServices.RuntimeInformation";
-    version = "4.3.0";
-    sha256 = "0q18r1sh4vn7bvqgd6dmqlw5v28flbpj349mkdish2vjyvmnb2ii";
-  })
-  (fetchNuGet {
     name = "System.Runtime.Numerics";
     version = "4.0.1";
     sha256 = "1y308zfvy0l5nrn46mqqr4wb4z1xk758pkk8svbz8b5ij7jnv4nn";
···
     name = "System.Runtime.Serialization.Primitives";
     version = "4.1.1";
     sha256 = "042rfjixknlr6r10vx2pgf56yming8lkjikamg3g4v29ikk78h7k";
+  })
+  (fetchNuGet {
+    name = "System.Runtime";
+    version = "4.1.0";
+    sha256 = "02hdkgk13rvsd6r9yafbwzss8kr55wnj8d5c7xjnp8gqrwc8sn0m";
+  })
+  (fetchNuGet {
+    name = "System.Runtime";
+    version = "4.3.0";
+    sha256 = "066ixvgbf2c929kgknshcxqj6539ax7b9m570cp8n179cpfkapz7";
   })
   (fetchNuGet {
     name = "System.Security.AccessControl";
···
     sha256 = "0clg1bv55mfv5dq00m19cp634zx6inm31kf8ppbq1jgyjf2185dh";
   })
   (fetchNuGet {
-    name = "System.Security.Principal";
-    version = "4.3.0";
-    sha256 = "12cm2zws06z4lfc4dn31iqv7072zyi4m910d4r6wm8yx85arsfxf";
-  })
-  (fetchNuGet {
     name = "System.Security.Principal.Windows";
     version = "4.3.0";
     sha256 = "00a0a7c40i3v4cb20s2cmh9csb5jv2l0frvnlzyfxh848xalpdwr";
···
     sha256 = "1mpk7xj76lxgz97a5yg93wi8lj0l8p157a5d50mmjy3gbz1904q8";
   })
   (fetchNuGet {
-    name = "System.Text.Encoding";
-    version = "4.0.11";
-    sha256 = "1dyqv0hijg265dwxg6l7aiv74102d6xjiwplh2ar1ly6xfaa4iiw";
-  })
-  (fetchNuGet {
-    name = "System.Text.Encoding";
+    name = "System.Security.Principal";
     version = "4.3.0";
-    sha256 = "1f04lkir4iladpp51sdgmis9dj4y8v08cka0mbmsy0frc9a4gjqr";
+    sha256 = "12cm2zws06z4lfc4dn31iqv7072zyi4m910d4r6wm8yx85arsfxf";
   })
   (fetchNuGet {
     name = "System.Text.Encoding.Extensions";
···
     sha256 = "11q1y8hh5hrp5a3kw25cb6l00v5l5dvirkz8jr3sq00h1xgcgrxy";
   })
   (fetchNuGet {
+    name = "System.Text.Encoding";
+    version = "4.0.11";
+    sha256 = "1dyqv0hijg265dwxg6l7aiv74102d6xjiwplh2ar1ly6xfaa4iiw";
+  })
+  (fetchNuGet {
+    name = "System.Text.Encoding";
+    version = "4.3.0";
+    sha256 = "1f04lkir4iladpp51sdgmis9dj4y8v08cka0mbmsy0frc9a4gjqr";
+  })
+  (fetchNuGet {
     name = "System.Text.RegularExpressions";
     version = "4.1.0";
     sha256 = "1mw7vfkkyd04yn2fbhm38msk7dz2xwvib14ygjsb8dq2lcvr18y7";
···
     sha256 = "1bgq51k7fwld0njylfn7qc5fmwrk2137gdq7djqdsw347paa9c2l";
   })
   (fetchNuGet {
-    name = "System.Threading";
-    version = "4.0.11";
-    sha256 = "19x946h926bzvbsgj28csn46gak2crv2skpwsx80hbgazmkgb1ls";
+    name = "System.Threading.Overlapped";
+    version = "4.3.0";
+    sha256 = "1nahikhqh9nk756dh8p011j36rlcp1bzz3vwi2b4m1l2s3vz8idm";
   })
   (fetchNuGet {
-    name = "System.Threading";
-    version = "4.3.0";
-    sha256 = "0rw9wfamvhayp5zh3j7p1yfmx9b5khbf4q50d8k5rk993rskfd34";
+    name = "System.Threading.Tasks.Extensions";
+    version = "4.0.0";
+    sha256 = "1cb51z062mvc2i8blpzmpn9d9mm4y307xrwi65di8ri18cz5r1zr";
   })
   (fetchNuGet {
-    name = "System.Threading.Overlapped";
+    name = "System.Threading.Tasks.Extensions";
     version = "4.3.0";
-    sha256 = "1nahikhqh9nk756dh8p011j36rlcp1bzz3vwi2b4m1l2s3vz8idm";
+    sha256 = "1xxcx2xh8jin360yjwm4x4cf5y3a2bwpn2ygkfkwkicz7zk50s2z";
   })
   (fetchNuGet {
     name = "System.Threading.Tasks";
···
     sha256 = "134z3v9abw3a6jsw17xl3f6hqjpak5l682k2vz39spj4kmydg6k7";
   })
   (fetchNuGet {
-    name = "System.Threading.Tasks.Extensions";
-    version = "4.0.0";
-    sha256 = "1cb51z062mvc2i8blpzmpn9d9mm4y307xrwi65di8ri18cz5r1zr";
-  })
-  (fetchNuGet {
-    name = "System.Threading.Tasks.Extensions";
-    version = "4.3.0";
-    sha256 = "1xxcx2xh8jin360yjwm4x4cf5y3a2bwpn2ygkfkwkicz7zk50s2z";
-  })
-  (fetchNuGet {
     name = "System.Threading.Thread";
     version = "4.3.0";
     sha256 = "0y2xiwdfcph7znm2ysxanrhbqqss6a3shi1z3c779pj2s523mjx4";
···
     sha256 = "15n54f1f8nn3mjcjrlzdg6q3520571y012mx7v991x2fvp73lmg6";
   })
   (fetchNuGet {
+    name = "System.Threading";
+    version = "4.0.11";
+    sha256 = "19x946h926bzvbsgj28csn46gak2crv2skpwsx80hbgazmkgb1ls";
+  })
+  (fetchNuGet {
+    name = "System.Threading";
+    version = "4.3.0";
+    sha256 = "0rw9wfamvhayp5zh3j7p1yfmx9b5khbf4q50d8k5rk993rskfd34";
+  })
+  (fetchNuGet {
     name = "System.Xml.ReaderWriter";
     version = "4.0.11";
     sha256 = "0c6ky1jk5ada9m94wcadih98l6k1fvf6vi7vhn1msjixaha419l5";
···
     sha256 = "0bmz1l06dihx52jxjr22dyv5mxv6pj4852lx68grjm7bivhrbfwi";
   })
   (fetchNuGet {
-    name = "System.Xml.XPath";
+    name = "System.Xml.XPath.XmlDocument";
     version = "4.3.0";
-    sha256 = "1cv2m0p70774a0sd1zxc8fm8jk3i5zk2bla3riqvi8gsm0r4kpci";
+    sha256 = "1h9lh7qkp0lff33z847sdfjj8yaz98ylbnkbxlnsbflhj9xyfqrm";
   })
   (fetchNuGet {
-    name = "System.Xml.XPath.XmlDocument";
+    name = "System.Xml.XPath";
     version = "4.3.0";
-    sha256 = "1h9lh7qkp0lff33z847sdfjj8yaz98ylbnkbxlnsbflhj9xyfqrm";
+    sha256 = "1cv2m0p70774a0sd1zxc8fm8jk3i5zk2bla3riqvi8gsm0r4kpci";
   })
 ]

pkgs/misc/emulators/ryujinx/disable-updater.patch

···
-diff --git a/Ryujinx/Program.cs b/Ryujinx/Program.cs
-index 29043bb8..d3973c7c 100644
---- a/Ryujinx/Program.cs
-+++ b/Ryujinx/Program.cs
-@@ -54,9 +54,6 @@ namespace Ryujinx
-                 }
-             }
-
--            // Delete backup files after updating.
--            Task.Run(Updater.CleanupUpdate);
--
-             Toolkit.Init(new ToolkitOptions
-             {
-                 Backend = PlatformBackend.PreferNative
-@@ -146,11 +143,6 @@ namespace Ryujinx
-                 mainWindow.LoadApplication(launchPathArg);
-             }
-
--            if (ConfigurationState.Instance.CheckUpdatesOnStart.Value && Updater.CanUpdate(false))
--            {
--                _ = Updater.BeginParse(mainWindow, false);
--            }
--
-             Application.Run();
-         }
-
-@@ -200,4 +192,4 @@ namespace Ryujinx
-             Logger.Shutdown();
-         }
-     }
--}
-\ No newline at end of file
-+}

pkgs/misc/emulators/ryujinx/fetch-deps.sh

···
-#!/usr/bin/env nix-shell
-#!nix-shell -i bash -p curl jq common-updater-scripts dotnet-sdk_5
-set -eo pipefail
-cd "$(dirname "${BASH_SOURCE[0]}")"
-
-deps_file="$(realpath "./deps.nix")"
-
-# Setup empty nuget package folder to force reinstall.
-mkdir ./nuget_tmp.packages
-cat >./nuget_tmp.config <<EOF
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
-  <packageSources>
-    <add key="nuget" value="https://api.nuget.org/v3/index.json" />
-  </packageSources>
-  <config>
-    <add key="globalPackagesFolder" value="$(realpath ./nuget_tmp.packages)" />
-  </config>
-</configuration>
-EOF
-
-dotnet restore Ryujinx.sln --configfile ./nuget_tmp.config
-
-echo "{ fetchNuGet }: [" >"$deps_file"
-while read pkg_spec; do
-  { read pkg_name; read pkg_version; } < <(
-    # Build version part should be ignored: `3.0.0-beta2.20059.3+77df2220` -> `3.0.0-beta2.20059.3`
-    sed -nE 's/.*<id>([^<]*).*/\1/p; s/.*<version>([^<+]*).*/\1/p' "$pkg_spec")
-  pkg_sha256="$(nix-hash --type sha256 --flat --base32 "$(dirname "$pkg_spec")"/*.nupkg)"
-  cat >>"$deps_file" <<EOF
-  (fetchNuGet {
-    name = "$pkg_name";
-    version = "$pkg_version";
-    sha256 = "$pkg_sha256";
-  })
-EOF
-done < <(find ./nuget_tmp.packages -name '*.nuspec' | sort)
-echo "]" >>"$deps_file"

pkgs/misc/emulators/ryujinx/updater.sh

···
+#! /usr/bin/env nix-shell
+#! nix-shell -i bash -p coreutils gnused curl common-updater-scripts nix-prefetch-git jq dotnet-sdk_5
+set -eo pipefail
+cd "$(dirname "${BASH_SOURCE[0]}")"
+
+deps_file="$(realpath "./deps.nix")"
+
+nix-prefetch-git https://github.com/ryujinx/ryujinx --quiet > repo_info
+new_hash="$(jq -r ".sha256" < repo_info)"
+new_rev="$(jq -r ".rev" < repo_info)"
+rm repo_info
+
+new_version="$(
+    curl -s https://ci.appveyor.com/api/projects/gdkchan/ryujinx/branch/master \
+        | grep -Po '"version":.*?[^\\]",' \
+        | sed  's/"version":"\(.*\)",/\1/'
+    )"
+old_version="$(sed -nE 's/\s*version = "(.*)".*/\1/p' ./default.nix)"
+
+if [[ "$new_version" == "$old_version" ]]; then
+  echo "Already up to date! Doing nothing"
+  exit 0
+fi
+
+cd ../../../..
+update-source-version ryujinx "$new_version" "$new_hash" --rev="$new_rev"
+
+store_src="$(nix-build . -A ryujinx.src --no-out-link)"
+src="$(mktemp -d /tmp/ryujinx-src.XXX)"
+cp -rT "$store_src" "$src"
+chmod -R +w "$src"
+pushd "$src"
+
+# Setup empty nuget package folder to force reinstall.
+mkdir ./nuget_tmp.packages
+cat >./nuget_tmp.config <<EOF
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <add key="nuget" value="https://api.nuget.org/v3/index.json" />
+  </packageSources>
+  <config>
+    <add key="globalPackagesFolder" value="$(realpath ./nuget_tmp.packages)" />
+  </config>
+</configuration>
+EOF
+
+dotnet restore Ryujinx.sln --configfile ./nuget_tmp.config
+
+echo "{ fetchNuGet }: [" >"$deps_file"
+while read pkg_spec; do
+  { read pkg_name; read pkg_version; } < <(
+    # Build version part should be ignored: `3.0.0-beta2.20059.3+77df2220` -> `3.0.0-beta2.20059.3`
+    sed -nE 's/.*<id>([^<]*).*/\1/p; s/.*<version>([^<+]*).*/\1/p' "$pkg_spec")
+  pkg_sha256="$(nix-hash --type sha256 --flat --base32 "$(dirname "$pkg_spec")"/*.nupkg)"
+  cat >>"$deps_file" <<EOF
+  (fetchNuGet {
+    name = "$pkg_name";
+    version = "$pkg_version";
+    sha256 = "$pkg_sha256";
+  })
+EOF
+done < <(find ./nuget_tmp.packages -name '*.nuspec' | sort)
+echo "]" >>"$deps_file"
+
+popd
+rm -r "$src"

pkgs/misc/emulators/yuzu/base.nix

···
 { pname, version, src, branchName
 , stdenv, lib, fetchFromGitHub, fetchpatch, wrapQtAppsHook
 , cmake, pkg-config
-, libpulseaudio, libjack2, alsaLib, sndio, ecasound
+, libpulseaudio, libjack2, alsaLib, sndio
 , vulkan-loader, vulkan-headers
 , qtbase, qtwebengine, qttools
 , nlohmann_json, rapidjson
···
 
   nativeBuildInputs = [ cmake pkg-config wrapQtAppsHook ];
   buildInputs = [
-    libpulseaudio libjack2 alsaLib sndio ecasound
+    libpulseaudio libjack2 alsaLib sndio
     vulkan-loader vulkan-headers
     qtbase qtwebengine qttools
     nlohmann_json rapidjson

pkgs/misc/emulators/yuzu/default.nix

···
 in {
   mainline = libsForQt5.callPackage ./base.nix rec {
     pname = "yuzu-mainline";
-    version = "546";
+    version = "576";
     branchName = branch;
     src = fetchFromGitHub {
       owner = "yuzu-emu";
       repo = "yuzu-mainline";
       rev = "mainline-0-${version}";
-      sha256 = "0d6cbhp877xyjac1flkyjf6g6igzmvjlk6gcph4m04i4zivb9kf2";
+      sha256 = "121pn3kmghpcf4pzs0mc8z3viyp32rzm7rssva7cdd5016z2648k";
       fetchSubmodules = true;
     };
   };
   early-access = libsForQt5.callPackage ./base.nix rec {
     pname = "yuzu-ea";
-    version = "1480";
+    version = "1536";
     branchName = branch;
     src = fetchFromGitHub {
       owner = "pineappleEA";
       repo = "pineapple-src";
       rev = "EA-${version}";
-      sha256 = "0flc5mckmnr9gj8f78nh9nys96inlkqk3rvpgbpl0mhcg6lmlb2g";
+      sha256 = "0smrx05xxr4b96i8bw6n6pynkl9r21ydfvpjdzxkr9amin20r54y";
     };
   };
 }.${branch}

pkgs/misc/lightspark/default.nix

···
 { lib, stdenv, fetchFromGitHub, pkg-config, cmake, curl, zlib, ffmpeg_3, glew, pcre
-, rtmpdump, cairo, boost, SDL2, SDL2_mixer, libjpeg, pango, lzma, nasm
+, rtmpdump, cairo, boost, SDL2, SDL2_mixer, libjpeg, pango, xz, nasm
 , llvm, glibmm
 }:
 
···
 
   buildInputs = [
     curl zlib ffmpeg_3 glew pcre rtmpdump cairo boost SDL2 SDL2_mixer libjpeg
-    pango lzma nasm llvm glibmm
+    pango xz nasm llvm glibmm
   ];
 
   meta = with lib; {

pkgs/misc/tmux-plugins/default.nix

···
     };
   };
 
+  extrakto = mkTmuxPlugin {
+    pluginName = "extrakto";
+    version = "unstable-2021-04-04";
+    src = fetchFromGitHub {
+      owner = "laktak";
+      repo = "extrakto";
+      rev = "de8ac3e8a9fa887382649784ed8cae81f5757f77";
+      sha256 = "0mkp9r6mipdm7408w7ls1vfn6i3hj19nmir2bvfcp12b69zlzc47";
+    };
+    nativeBuildInputs = [ pkgs.makeWrapper ];
+    postInstall = ''
+    for f in extrakto.sh open.sh tmux-extrakto.sh; do
+      wrapProgram $target/scripts/$f \
+        --prefix PATH : ${with pkgs; lib.makeBinPath (
+        [ pkgs.fzf pkgs.python3 pkgs.xclip ]
+        )}
+    done
+
+    '';
+    meta = {
+      homepage = "https://github.com/laktak/extrakto";
+      description = "Fuzzy find your text with fzf instead of selecting it by hand ";
+      license = lib.licenses.mit;
+      platforms = lib.platforms.unix;
+      maintainers = with lib.maintainers; [ kidd ];
+    };
+  };
+
   fingers = mkTmuxPlugin rec {
     pluginName = "fingers";
     rtpFilePath = "tmux-fingers.tmux";

pkgs/misc/uboot/default.nix

···
       platforms = ["aarch64-linux"];
       license = lib.licenses.unfreeRedistributableFirmware;
     };
+    BL31="${armTrustedFirmwareRK3399}/bl31.elf";
     filesToInstall = ["u-boot.itb" "idbloader.img"];
     postBuild = ''
       ./tools/mkimage -n rk3399 -T rksd -d ${rkbin}/rk33/rk3399_ddr_800MHz_v1.24.bin idbloader.img

pkgs/os-specific/bsd/netbsd/default.nix

···
-{ stdenv, stdenvNoCC, fetchcvs, lib, groff, mandoc, zlib, yacc, flex
+{ stdenv, stdenvNoCC, fetchcvs, lib, groff, mandoc, zlib, bison, flex
 , writeText, buildPackages, splicePackages, symlinkJoin }:
 
 let
···
     sha256 = "0630lbvz6v4ic13bfg8ccwfhqkgcv76bfdw9f36rfsnwfgpxqsmq";
     meta.platforms = lib.platforms.netbsd;
     nativeBuildInputs = [ makeMinimal install mandoc groff flex
-                          yacc genassym gencat lorder tsort stat ];
+                          bison genassym gencat lorder tsort stat ];
     extraPaths = [ sys.src ld_elf_so.src ];
   };
 
···
                    librpcsvc.src libutil.src librt.src libcrypt.src ];
     buildInputs = [ buildPackages.netbsd.headers csu ];
     nativeBuildInputs = [ makeMinimal install mandoc groff flex
-                          yacc genassym gencat lorder tsort stat ];
+                          bison genassym gencat lorder tsort stat ];
     NIX_CFLAGS_COMPILE = "-B${csu}/lib";
     meta.platforms = lib.platforms.netbsd;
     SHLIBINSTALLDIR = "$(out)/lib";

pkgs/os-specific/darwin/apple-source-releases/adv_cmds/boot.nix

···
-{ lib, appleDerivation, fetchzip, bsdmake, perl, flex, yacc
+{ lib, appleDerivation, fetchzip, bsdmake, perl, flex, bison
 }:
 
 # this derivation sucks
···
 };
 
 in appleDerivation {
-  nativeBuildInputs = [ bsdmake perl yacc flex ];
+  nativeBuildInputs = [ bsdmake perl bison flex ];
   buildInputs = [ flex ];
 
   patchPhase = ''

pkgs/os-specific/darwin/apple-source-releases/bootstrap_cmds/default.nix

···
-{ lib, stdenv, appleDerivation, yacc, flex }:
+{ lib, stdenv, appleDerivation, bison, flex }:
 
 appleDerivation {
-  nativeBuildInputs = [ yacc flex ];
+  nativeBuildInputs = [ bison flex ];
 
   buildPhase = ''
     cd migcom.tproj

pkgs/os-specific/darwin/apple-source-releases/file_cmds/default.nix

···
-{ lib, appleDerivation, xcbuildHook, zlib, bzip2, lzma, ncurses, libutil }:
+{ lib, appleDerivation, xcbuildHook, zlib, bzip2, xz, ncurses, libutil }:
 
 appleDerivation {
   nativeBuildInputs = [ xcbuildHook ];
-  buildInputs = [ zlib bzip2 lzma ncurses libutil ];
+  buildInputs = [ zlib bzip2 xz ncurses libutil ];
 
   # some commands not working:
   # mtree: _simple.h not found

pkgs/os-specific/darwin/apple-source-releases/text_cmds/default.nix

···
-{ lib, appleDerivation, xcbuildHook, ncurses, bzip2, zlib, lzma }:
+{ lib, appleDerivation, xcbuildHook, ncurses, bzip2, zlib, xz }:
 
 appleDerivation {
   nativeBuildInputs = [ xcbuildHook ];
-  buildInputs = [ ncurses bzip2 zlib lzma ];
+  buildInputs = [ ncurses bzip2 zlib xz ];
 
   # patches to use ncursees
   # disables md5
   patchPhase = ''
     substituteInPlace text_cmds.xcodeproj/project.pbxproj \
-		  --replace 'FC6C98FB149A94EB00DDCC47 /* libcurses.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libcurses.dylib; path = /usr/lib/libcurses.dylib; sourceTree = "<absolute>"; };' 'FC6C98FB149A94EB00DDCC47 /* libncurses.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libncurses.dylib; path = /usr/lib/libncurses.dylib; sourceTree = "<absolute>"; };' \
+          --replace 'FC6C98FB149A94EB00DDCC47 /* libcurses.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libcurses.dylib; path = /usr/lib/libcurses.dylib; sourceTree = "<absolute>"; };' 'FC6C98FB149A94EB00DDCC47 /* libncurses.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libncurses.dylib; path = /usr/lib/libncurses.dylib; sourceTree = "<absolute>"; };' \
       --replace 'FC7A7EB5149875E00086576A /* PBXTargetDependency */,' ""
   '';
 

pkgs/os-specific/linux/autofs/default.nix

···
 { lib, stdenv, fetchurl, flex, bison, linuxHeaders, libtirpc, mount, umount, nfs-utils, e2fsprogs
-, libxml2, kerberos, kmod, openldap, sssd, cyrus_sasl, openssl, rpcsvc-proto }:
+, libxml2, libkrb5, kmod, openldap, sssd, cyrus_sasl, openssl, rpcsvc-proto }:
 
 let
   version = "5.1.6";
···
     #make install SUBDIRS="samples" # impure!
   '';
 
-  buildInputs = [ linuxHeaders libtirpc libxml2 kerberos kmod openldap sssd
+  buildInputs = [ linuxHeaders libtirpc libxml2 libkrb5 kmod openldap sssd
                   openssl cyrus_sasl rpcsvc-proto ];
 
   nativeBuildInputs = [ flex bison ];

pkgs/os-specific/linux/cifs-utils/default.nix

···
 { stdenv, lib, fetchurl, autoreconfHook, docutils, pkg-config
-, kerberos, keyutils, pam, talloc, python3 }:
+, libkrb5, keyutils, pam, talloc, python3 }:
 
 stdenv.mkDerivation rec {
   pname = "cifs-utils";
···
 
   nativeBuildInputs = [ autoreconfHook docutils pkg-config ];
 
-  buildInputs = [ kerberos keyutils pam talloc python3 ];
+  buildInputs = [ libkrb5 keyutils pam talloc python3 ];
 
   configureFlags = [ "ROOTSBINDIR=$(out)/sbin" ] ++ lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
     # AC_FUNC_MALLOC is broken on cross builds.

pkgs/os-specific/linux/firmware/firmware-manager/default.nix

···
-{ rustPlatform, lib, fetchFromGitHub, lzma, pkg-config, openssl, dbus, glib, udev, cairo, pango, atk, gdk-pixbuf, gtk3, wrapGAppsHook }:
+{ rustPlatform, lib, fetchFromGitHub, xz, pkg-config, openssl, dbus, glib, udev, cairo, pango, atk, gdk-pixbuf, gtk3, wrapGAppsHook }:
 rustPlatform.buildRustPackage rec {
   pname = "firmware-manager";
   version = "0.1.2";
···
 
   nativeBuildInputs = [ pkg-config wrapGAppsHook ];
 
-  buildInputs = [ lzma openssl dbus glib udev cairo pango atk gdk-pixbuf gtk3 ];
+  buildInputs = [ xz openssl dbus glib udev cairo pango atk gdk-pixbuf gtk3 ];
 
   depsExtraArgs.postPatch = "make prefix='$(out)' toml-gen";
 

pkgs/os-specific/linux/firmware/raspberrypi-wireless/default.nix

···
 
 stdenv.mkDerivation {
   pname = "raspberrypi-wireless-firmware";
-  version = "2020-12-01";
+  version = "2021-01-28";
 
   srcs = [
     (fetchFromGitHub {
       name = "bluez-firmware";
       owner = "RPi-Distro";
       repo = "bluez-firmware";
-      rev = "1e4ee0c05bae10002124b56c0e44bb9ac6581ddc";
-      sha256 = "10n6ibr3ra71f4hlvbpy8csjlgrapawxrr6jmijn470vkcqcpq27";
+      rev = "e7fd166981ab4bb9a36c2d1500205a078a35714d";
+      sha256 = "1dkg8mzn7n4afi50ibrda2s33nw2qj52jjjdv9w560q601gms47b";
     })
     (fetchFromGitHub {
       name = "firmware-nonfree";
       owner = "RPi-Distro";
       repo = "firmware-nonfree";
-      rev = "b66ab26cebff689d0d3257f56912b9bb03c20567";
-      sha256 = "0cffgsp0w7vv7ylpymdddx0bl9dx3pl7snlh30p4rr9srmn8869f";
+      rev = "83938f78ca2d5a0ffe0c223bb96d72ccc7b71ca5";
+      sha256 = "1l4zz86y2hjyvdwjy75abyjwh3wqknd71y3vh1iw5nd0hws8ranp";
     })
   ];
 
···
 
   outputHashMode = "recursive";
   outputHashAlgo = "sha256";
-  outputHash = "17k9y499kjc4zv7ivnsfrgfibwj0ldr3sqdgia4dackbr70jfg2h";
+  outputHash = "0a54gyrq6jfxxvimaa4yjfiyfwf7wv58v0a32l74yrzyarr3ldby";
 
   meta = with lib; {
     description = "Firmware for builtin Wifi/Bluetooth devices in the Raspberry Pi 3+ and Zero W";

pkgs/os-specific/linux/firmware/raspberrypi/default.nix

···
 stdenvNoCC.mkDerivation rec {
   # NOTE: this should be updated with linux_rpi
   pname = "raspberrypi-firmware";
-  version = "1.20201201";
+  version = "1.20210303";
 
   src = fetchFromGitHub {
     owner = "raspberrypi";
     repo = "firmware";
     rev = version;
-    sha256 = "09yha3k72yqx29rwnv2j2zm73lzc4jgmcbmcc6yrl1i07x84lx3n";
+    sha256 = "0pgiw93hq4gfph5dnwbi8w59g0f7yhmagwzam971k529mh5yl86m";
   };
 
   installPhase = ''

pkgs/os-specific/linux/firmware/system76-firmware/default.nix

···
-{ rustPlatform, lib, fetchFromGitHub, lzma, pkg-config, openssl, dbus, efibootmgr, makeWrapper }:
+{ rustPlatform, lib, fetchFromGitHub, xz, pkg-config, openssl, dbus, efibootmgr, makeWrapper }:
 rustPlatform.buildRustPackage rec {
   pname = "system76-firmware";
   # Check Makefile when updating, make sure postInstall matches make install
···
 
   nativeBuildInputs = [ pkg-config makeWrapper ];
 
-  buildInputs = [ lzma openssl dbus ];
+  buildInputs = [ xz openssl dbus ];
 
   cargoBuildFlags = [ "--workspace" ];
 

pkgs/os-specific/linux/gogoclient/default.nix

···
-{lib, stdenv, fetchurl, openssl, nettools, iproute, sysctl}:
+{lib, stdenv, fetchurl, openssl, nettools, iproute2, sysctl}:
 
 let baseName = "gogoclient";
     version  = "1.2";
···
     substituteInPlace "$out/template/linux.sh" \
       --replace "/sbin/ifconfig" "${nettools}/bin/ifconfig" \
       --replace "/sbin/route"    "${nettools}/bin/route" \
-      --replace "/sbin/ip"       "${iproute}/sbin/ip" \
+      --replace "/sbin/ip"       "${iproute2}/sbin/ip" \
       --replace "/sbin/sysctl"   "${sysctl}/bin/sysctl"
     sed -i -e 's/^.*Exec \$route -A.*$/& metric 128/' $out/template/linux.sh
   '';

pkgs/os-specific/linux/hyperv-daemons/default.nix

···
 { stdenv, lib, python, kernel, makeWrapper, writeText
-, gawk, iproute }:
+, gawk, iproute2 }:
 
 let
   libexec = "libexec/hypervkvpd";
···
 
     postFixup = ''
       wrapProgram $out/bin/hv_kvp_daemon \
-        --prefix PATH : $out/bin:${lib.makeBinPath [ gawk iproute ]}
+        --prefix PATH : $out/bin:${lib.makeBinPath [ gawk iproute2 ]}
     '';
   };
 

pkgs/os-specific/linux/iproute/mptcp.nix

···
-{ lib, iproute, fetchFromGitHub }:
+{ lib, iproute2, fetchFromGitHub }:
 
-iproute.overrideAttrs (oa: rec {
+iproute2.overrideAttrs (oa: rec {
   pname = "iproute_mptcp";
   version = "0.95";
 

pkgs/os-specific/linux/ipsec-tools/default.nix

···
-{ lib, stdenv, fetchurl, fetchpatch, linuxHeaders, readline, openssl, flex, kerberos, pam }:
+{ lib, stdenv, fetchurl, fetchpatch, linuxHeaders, readline, openssl, flex, libkrb5, pam }:
 
 # TODO: These tools are supposed to work under NetBSD and FreeBSD as
 # well, so I guess it's not appropriate to place this expression in
···
     sha256 = "0b9gfbz78k2nj0k7jdlm5kajig628ja9qm0z5yksiwz22s3v7dlf";
   };
 
-  buildInputs = [ readline openssl flex kerberos pam ];
+  buildInputs = [ readline openssl flex libkrb5 pam ];
 
   patches = [
     ./dont-create-localstatedir-during-install.patch

pkgs/os-specific/linux/joycond/default.nix

···
+{ lib, stdenv, fetchFromGitHub, cmake, pkg-config, libevdev, udev }:
+
+stdenv.mkDerivation rec {
+  pname = "joycond";
+  version = "unstable-2021-03-27";
+
+  src = fetchFromGitHub {
+    owner = "DanielOgorchock";
+    repo = "joycond";
+    rev = "2d3f553060291f1bfee2e49fc2ca4a768b289df8";
+    sha256 = "0dpmwspll9ar3pxg9rgnh224934par8h8bixdz9i2pqqbc3dqib7";
+  };
+
+  nativeBuildInputs = [ cmake pkg-config ];
+  buildInputs = [ libevdev udev ];
+
+  # CMake has hardcoded install paths
+  installPhase = ''
+    mkdir -p $out/{bin,etc/{systemd/system,udev/rules.d},lib/modules-load.d}
+
+    cp ./joycond $out/bin
+    cp $src/udev/{89,72}-joycond.rules $out/etc/udev/rules.d
+    cp $src/systemd/joycond.service $out/etc/systemd/system
+    cp $src/systemd/joycond.conf $out/lib/modules-load.d
+
+    substituteInPlace $out/etc/systemd/system/joycond.service --replace \
+      "ExecStart=/usr/bin/joycond" "ExecStart=$out/bin/joycond"
+  '';
+
+  meta = with lib; {
+    homepage = "https://github.com/DanielOgorchock/joycond";
+    description = "Userspace daemon to combine joy-cons from the hid-nintendo kernel driver";
+    license = licenses.gpl3Only;
+    maintainers = [ maintainers.ivar ];
+    platforms = platforms.linux;
+  };
+}

pkgs/os-specific/linux/kernel/hardened/patches.json

···
 {
     "4.14": {
         "extra": "-hardened1",
-        "name": "linux-hardened-4.14.227-hardened1.patch",
-        "sha256": "0g8s91cvcxin95is7hhap5i8vkn4k3570s28vnz8mf0jrcgwdgfd",
-        "url": "https://github.com/anthraxx/linux-hardened/releases/download/4.14.227-hardened1/linux-hardened-4.14.227-hardened1.patch"
+        "name": "linux-hardened-4.14.228-hardened1.patch",
+        "sha256": "0pf3c98m2zlgxv9p10p7xw44f6mqnh8ac47jl1abz3yy3hiag0cd",
+        "url": "https://github.com/anthraxx/linux-hardened/releases/download/4.14.228-hardened1/linux-hardened-4.14.228-hardened1.patch"
     },
     "4.19": {
         "extra": "-hardened1",
-        "name": "linux-hardened-4.19.183-hardened1.patch",
-        "sha256": "1xi4fkvdvf1rjhrihi7im415x26hwmvhf3zrklm8hw2rmajdfrca",
-        "url": "https://github.com/anthraxx/linux-hardened/releases/download/4.19.183-hardened1/linux-hardened-4.19.183-hardened1.patch"
+        "name": "linux-hardened-4.19.184-hardened1.patch",
+        "sha256": "1828kkq05808mahkfb0387b1k5qp6pysy4mny1xgpwqdphpp1pq9",
+        "url": "https://github.com/anthraxx/linux-hardened/releases/download/4.19.184-hardened1/linux-hardened-4.19.184-hardened1.patch"
     },
     "5.10": {
         "extra": "-hardened1",
-        "name": "linux-hardened-5.10.26-hardened1.patch",
-        "sha256": "08f4yks3fjv5zi85zbxa3aqfllb6nbr58hm6kchd83l6rknnix4r",
-        "url": "https://github.com/anthraxx/linux-hardened/releases/download/5.10.26-hardened1/linux-hardened-5.10.26-hardened1.patch"
+        "name": "linux-hardened-5.10.27-hardened1.patch",
+        "sha256": "12pzv36p0pdaqqklwv6rpk15c1z1nz2syw1si24514p63v46wmhn",
+        "url": "https://github.com/anthraxx/linux-hardened/releases/download/5.10.27-hardened1/linux-hardened-5.10.27-hardened1.patch"
     },
     "5.11": {
         "extra": "-hardened1",
-        "name": "linux-hardened-5.11.10-hardened1.patch",
-        "sha256": "16083fvl5km751dps7mzjc2fl1qp9jqnyn7lg8jlfxc8w32bbxwv",
-        "url": "https://github.com/anthraxx/linux-hardened/releases/download/5.11.10-hardened1/linux-hardened-5.11.10-hardened1.patch"
+        "name": "linux-hardened-5.11.11-hardened1.patch",
+        "sha256": "0isq152z4h2kl3rviia9xlpsmdx331kx8p1x00jbf4gcw30amc78",
+        "url": "https://github.com/anthraxx/linux-hardened/releases/download/5.11.11-hardened1/linux-hardened-5.11.11-hardened1.patch"
     },
     "5.4": {
         "extra": "-hardened1",
-        "name": "linux-hardened-5.4.108-hardened1.patch",
-        "sha256": "1m208j0svysyn3m0acn10pd4wqjm203ampkhf1wimzpzs8wfasgj",
-        "url": "https://github.com/anthraxx/linux-hardened/releases/download/5.4.108-hardened1/linux-hardened-5.4.108-hardened1.patch"
+        "name": "linux-hardened-5.4.109-hardened1.patch",
+        "sha256": "19likbds74lzym969p6hbchlfii4qnsp8y4ryfkba1vv6hv51zzj",
+        "url": "https://github.com/anthraxx/linux-hardened/releases/download/5.4.109-hardened1/linux-hardened-5.4.109-hardened1.patch"
     }
 }

pkgs/os-specific/linux/kernel/linux-4.14.nix

···
 with lib;
 
 buildLinux (args // rec {
-  version = "4.14.227";
+  version = "4.14.228";
 
   # modDirVersion needs to be x.y.z, will automatically add .0 if needed
   modDirVersion = if (modDirVersionArg == null) then concatStringsSep "." (take 3 (splitVersion "${version}.0")) else modDirVersionArg;
···
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "1iz029v407xv81prrvg4gr2ql8hvm0mpj21x9picwv05pk2d68h7";
+    sha256 = "0nw1jf6x5a990n69aw2da4s4lc1c7mnwiwcda40bl2rkmd24s1qm";
   };
 } // (args.argsOverride or {}))

pkgs/os-specific/linux/kernel/linux-4.19.nix

···
 with lib;
 
 buildLinux (args // rec {
-  version = "4.19.183";
+  version = "4.19.184";
 
   # modDirVersion needs to be x.y.z, will automatically add .0 if needed
   modDirVersion = if (modDirVersionArg == null) then concatStringsSep "." (take 3 (splitVersion "${version}.0")) else modDirVersionArg;
···
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "1xd5hjdjbsw7kpj9csgi8kk4ki3z46sqbiigjsr71psivxfxkkxs";
+    sha256 = "0z5pgal8775rf7pvpxq47dnghr42al2k9py0s9jl3js2wamgdyix";
   };
 } // (args.argsOverride or {}))

pkgs/os-specific/linux/kernel/linux-4.4.nix

···
 { buildPackages, fetchurl, perl, buildLinux, ... } @ args:
 
 buildLinux (args // rec {
-  version = "4.4.263";
+  version = "4.4.264";
   extraMeta.branch = "4.4";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "1qqh3n09pn87n6f7ain3am8k7j043vzm65qcvccq9as129y5w1a2";
+    sha256 = "1b0d735qnk0bcqn9gdsjqxhk8pkb3597ya9f34lv1vjfaqkkxk7l";
   };
 } // (args.argsOverride or {}))

pkgs/os-specific/linux/kernel/linux-4.9.nix

···
 { buildPackages, fetchurl, perl, buildLinux, ... } @ args:
 
 buildLinux (args // rec {
-  version = "4.9.263";
+  version = "4.9.264";
   extraMeta.branch = "4.9";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "1dhmgyg6asqg1pmhnzqymwz4bm6gy8gi0n2gr794as38dhn2szwz";
+    sha256 = "1df2dv26c9z6zsdlqzbcc60f2pszh0hx1n94v65jswlb72a2mipc";
   };
 } // (args.argsOverride or {}))

pkgs/os-specific/linux/kernel/linux-5.10.nix

···
 with lib;
 
 buildLinux (args // rec {
-  version = "5.10.26";
+  version = "5.10.27";
 
   # modDirVersion needs to be x.y.z, will automatically add .0 if needed
   modDirVersion = if (modDirVersionArg == null) then concatStringsSep "." (take 3 (splitVersion "${version}.0")) else modDirVersionArg;
···
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v5.x/linux-${version}.tar.xz";
-    sha256 = "10hlc020imxxh71nvxhnnmd66bcxndfyi78v7wv7y5mcy4rjhlzw";
+    sha256 = "1nb95ll66kxiz702gs903n3gy5ialz8cin58l19rqaai55kck7fr";
   };
 } // (args.argsOverride or {}))

pkgs/os-specific/linux/kernel/linux-5.11.nix

···
 with lib;
 
 buildLinux (args // rec {
-  version = "5.11.10";
+  version = "5.11.11";
 
   # modDirVersion needs to be x.y.z, will automatically add .0 if needed
   modDirVersion = if (modDirVersionArg == null) then concatStringsSep "." (take 3 (splitVersion "${version}.0")) else modDirVersionArg;
···
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v5.x/linux-${version}.tar.xz";
-    sha256 = "07fw48sy8p17jmm24x3rl99cwxiwhwjrxnmy3g542w9kzawaqwnk";
+    sha256 = "1fc3yl4srzla3cbihgnry0pqmgcc17zv0zlkk9zpx99371hpay0a";
   };
 } // (args.argsOverride or {}))

pkgs/os-specific/linux/kernel/linux-5.4.nix

···
 with lib;
 
 buildLinux (args // rec {
-  version = "5.4.108";
+  version = "5.4.109";
 
   # modDirVersion needs to be x.y.z, will automatically add .0 if needed
   modDirVersion = if (modDirVersionArg == null) then concatStringsSep "." (take 3 (splitVersion "${version}.0")) else modDirVersionArg;
···
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v5.x/linux-${version}.tar.xz";
-    sha256 = "0wi1ql7brfsdzvwbxrxvg12zfm54lbdjvfzxk1l3xlqvq83sq4pj";
+    sha256 = "1vmpc6yrr2zm4m3naflwik5111jr8hy0mnyddwk31l0p4xbg8smc";
   };
 } // (args.argsOverride or {}))

pkgs/os-specific/linux/kernel/linux-lqx.nix

···
 { lib, fetchFromGitHub, buildLinux, linux_zen, ... } @ args:
 
 let
-  version = "5.11.8";
+  version = "5.11.11";
   suffix = "lqx1";
 in
 
···
     owner = "zen-kernel";
     repo = "zen-kernel";
     rev = "v${version}-${suffix}";
-    sha256 = "1zvd74l6vb0rwrkwwh67i8l6ipin0p981vzdmiwpbpfzasbw59xk";
+    sha256 = "1wycqy0m6vjaa39rq7ngwr2qmksqfca27z1711nag7j68dk3ywak";
   };
 
   extraMeta = {

pkgs/os-specific/linux/kernel/linux-rpi.nix

···
 
 let
   # NOTE: raspberrypifw & raspberryPiWirelessFirmware should be updated with this
-  modDirVersion = "5.4.79";
-  tag = "1.20201201";
+  modDirVersion = "5.10.17";
+  tag = "1.20210303";
 in
 lib.overrideDerivation (buildLinux (args // {
   version = "${modDirVersion}-${tag}";
···
     owner = "raspberrypi";
     repo = "linux";
     rev = "raspberrypi-kernel_${tag}-1";
-    sha256 = "093p5kh5f27djkhbcw371w079lhhihvg3s4by3wzsd40di4fcgn9";
+    sha256 = "0ffsllayl18ka4mgp4rdy9h0da5gy1n6g0kfvinvzdzabb5wzvrx";
   };
 
   defconfig = {
···
     "4" = "bcm2711_defconfig";
   }.${toString rpiVersion};
 
-  extraConfig = ''
-    # ../drivers/pci/controller/pcie-altera.c:679:8: error: too few arguments to function 'devm_of_pci_get_host_bridge_resources'
-    PCIE_ALTERA n
-  '';
-
   features = {
     efiBootStub = false;
   } // (args.features or {});
+
+  extraConfig = ''
+    # ../drivers/gpu/drm/ast/ast_mode.c:851:18: error: initialization of 'void (*)(struct drm_crtc *, struct drm_atomic_state *)' from incompatible pointer type 'void (*)(struct drm_crtc *, struct drm_crtc_state *)' [-Werror=incompatible-pointer-types]
+    #   851 |  .atomic_flush = ast_crtc_helper_atomic_flush,
+    #       |                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    # ../drivers/gpu/drm/ast/ast_mode.c:851:18: note: (near initialization for 'ast_crtc_helper_funcs.atomic_flush')
+    DRM_AST n
+  '';
 
   extraMeta = if (rpiVersion < 3) then {
     platforms = with lib.platforms; [ arm ];

pkgs/os-specific/linux/kernel/linux-testing.nix

···
 with lib;
 
 buildLinux (args // rec {
-  version = "5.12-rc4";
+  version = "5.12-rc6";
   extraMeta.branch = "5.12";
 
   # modDirVersion needs to be x.y.z, will always add .0
···
 
   src = fetchurl {
     url = "https://git.kernel.org/torvalds/t/linux-${version}.tar.gz";
-    sha256 = "06i6xnfbyn522pj9zksx6ka01yxwv8dsrb2z517grv682sp8j70k";
+    sha256 = "0w0zk2byimdbcvn8myqaq0ab6lyd43493fnkv9a1407dimpxb03d";
   };
 
   # Should the testing kernels ever be built on Hydra?

pkgs/os-specific/linux/kernel/linux-zen.nix

···
 { lib, fetchFromGitHub, buildLinux, ... } @ args:
 
 let
-  version = "5.11.8";
+  version = "5.11.11";
   suffix = "zen1";
 in
 
···
     owner = "zen-kernel";
     repo = "zen-kernel";
     rev = "v${version}-${suffix}";
-    sha256 = "1hb05shhqb6747m131sw30h36ak1m9bwzhfldjypn8phlfkflgkq";
+    sha256 = "0rldvgvdbsqvshrbv2g335qvwzk76l7rpnp9dwzsiv2qphrzxazi";
   };
 
   extraMeta = {

pkgs/os-specific/linux/libcgroup/default.nix

···
-{ lib, stdenv, fetchurl, fetchpatch, pam, yacc, flex }:
+{ lib, stdenv, fetchurl, fetchpatch, pam, bison, flex }:
 
 stdenv.mkDerivation rec {
   pname = "libcgroup";
···
     sha256 = "0lgvyq37gq84sk30sg18admxaj0j0p5dq3bl6g74a1ppgvf8pqz4";
   };
 
-  buildInputs = [ pam yacc flex ];
+  buildInputs = [ pam bison flex ];
 
   patches = [
     (fetchpatch {

pkgs/os-specific/linux/macchanger/default.nix

···
-{ lib, stdenv, fetchFromGitHub, autoreconfHook, texinfo }:
+{ lib, stdenv, fetchFromGitHub, fetchpatch, autoreconfHook, texinfo }:
 
 stdenv.mkDerivation rec {
   pname = "macchanger";
···
     sha256 = "1hypx6sxhd2b1nsxj314hpkhj7q4x9p2kfaaf20rjkkkig0nck9r";
   };
 
+  patches = [
+    (fetchpatch {
+      url = "https://sources.debian.org/data/main/m/macchanger/1.7.0-5.3/debian/patches/02-fix_usage_message.patch";
+      sha256 = "0pxljmq0l0znylbhms09i19qwil74gm8gx3xx2ffx00dajaizj18";
+    })
+    (fetchpatch {
+      url = "https://sources.debian.org/data/main/m/macchanger/1.7.0-5.3/debian/patches/06-update_OUI_list.patch";
+      sha256 = "04kbd784z9nwkjva5ckkvb0yb3pim9valb1viywn1yyh577d0y7w";
+    })
+    (fetchpatch {
+      url = "https://sources.debian.org/data/main/m/macchanger/1.7.0-5.3/debian/patches/08-fix_random_MAC_choice.patch";
+      sha256 = "1vz3appxxsdf1imzrn57amazfwlbrvx6g78b6n88aqgwzy5dm34d";
+    })
+    (fetchpatch {
+      url = "https://sources.debian.org/data/main/m/macchanger/1.7.0-5.3/debian/patches/check-random-device-read-errors.patch";
+      sha256 = "0pra6qnk39crjlidspg3l6hpaqiw43cypahx793l59mqn956cngc";
+    })
+    (fetchpatch {
+      url = "https://sources.debian.org/data/main/m/macchanger/1.7.0-5.3/debian/patches/verify-changed-MAC.patch";
+      sha256 = "0vjhf2fnj1hlghjl821p6idrfc8hmd4lgps5lf1l68ylqvwjw0zj";
+    })
+  ];
+
   nativeBuildInputs = [ autoreconfHook texinfo ];
 
   outputs = [ "out" "info" ];
 
   meta = with lib; {
     description = "A utility for viewing/manipulating the MAC address of network interfaces";
-    maintainers = with maintainers; [ joachifm ma27 ];
+    maintainers = with maintainers; [ joachifm ma27 dotlambda ];
     license = licenses.gpl2Plus;
-    homepage = "https://www.gnu.org/software/macchanger";
+    homepage = "https://github.com/alobbs/macchanger";
     platforms = platforms.linux;
   };
 }

pkgs/os-specific/linux/multipath-tools/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, perl, lvm2, libaio, gzip, readline, systemd, liburcu, json_c }:
+{ lib, stdenv, fetchurl, pkg-config, perl, lvm2, libaio, gzip, readline, systemd, liburcu, json_c, kmod }:
 
 stdenv.mkDerivation rec {
   pname = "multipath-tools";
···
   ];
 
   postPatch = ''
-    substituteInPlace libmultipath/Makefile --replace /usr/include/libdevmapper.h ${lib.getDev lvm2}/include/libdevmapper.h
+    substituteInPlace libmultipath/Makefile \
+      --replace /usr/include/libdevmapper.h ${lib.getDev lvm2}/include/libdevmapper.h
+
+    substituteInPlace multipathd/multipathd.service \
+      --replace /sbin/modprobe ${lib.getBin kmod}/sbin/modprobe \
+      --replace /sbin/multipathd "$out/bin/multipathd"
+
     sed -i -re '
       s,^( *#define +DEFAULT_MULTIPATHDIR\>).*,\1 "'"$out/lib/multipath"'",
     ' libmultipath/defaults.h

pkgs/os-specific/linux/nfs-utils/default.nix

···
 { stdenv, fetchurl, fetchpatch, lib, pkg-config, util-linux, libcap, libtirpc, libevent
-, sqlite, kerberos, kmod, libuuid, keyutils, lvm2, systemd, coreutils, tcp_wrappers
+, sqlite, libkrb5, kmod, libuuid, keyutils, lvm2, systemd, coreutils, tcp_wrappers
 , python3, buildPackages, nixosTests, rpcsvc-proto
 , enablePython ? true
 }:
···
 
   buildInputs = [
     libtirpc libcap libevent sqlite lvm2
-    libuuid keyutils kerberos tcp_wrappers
+    libuuid keyutils libkrb5 tcp_wrappers
   ] ++ lib.optional enablePython python3;
 
   enableParallelBuilding = true;
···
   preConfigure =
     ''
       substituteInPlace configure \
-        --replace '$dir/include/gssapi' ${lib.getDev kerberos}/include/gssapi \
-        --replace '$dir/bin/krb5-config' ${lib.getDev kerberos}/bin/krb5-config
+        --replace '$dir/include/gssapi' ${lib.getDev libkrb5}/include/gssapi \
+        --replace '$dir/bin/krb5-config' ${lib.getDev libkrb5}/bin/krb5-config
     '';
 
   configureFlags =
     [ "--enable-gss"
       "--enable-svcgss"
       "--with-statedir=/var/lib/nfs"
-      "--with-krb5=${lib.getLib kerberos}"
+      "--with-krb5=${lib.getLib libkrb5}"
       "--with-systemd=${placeholder "out"}/etc/systemd/system"
       "--enable-libmount-mount"
       "--with-pluginpath=${placeholder "lib"}/lib/libnfsidmap" # this installs libnfsidmap
···
   # https://bugzilla.kernel.org/show_bug.cgi?id=203793
   doCheck = false;
 
-  disallowedReferences = [ (lib.getDev kerberos) ];
+  disallowedReferences = [ (lib.getDev libkrb5) ];
 
   passthru.tests = {
     nfs3-simple = nixosTests.nfs3.simple;

pkgs/os-specific/linux/openvswitch/lts.nix

···
 { lib, stdenv, fetchurl, makeWrapper, pkg-config, util-linux, which
-, procps, libcap_ng, openssl, python2, iproute , perl
+, procps, libcap_ng, openssl, python2, perl
 , automake, autoconf, libtool, kernel ? null }:
 
 with lib;

pkgs/os-specific/linux/pam_krb5/default.nix

···
-{ lib, stdenv, fetchurl, pam, kerberos }:
+{ lib, stdenv, fetchurl, pam, libkrb5 }:
 
 stdenv.mkDerivation rec {
   name = "pam-krb5-4.10";
···
     sha256 = "09wzxd5zrj5bzqpb01qf148npj5k8hmd2bx2ij1qsy40hdxqyq79";
   };
 
-  buildInputs = [ pam kerberos ];
+  buildInputs = [ pam libkrb5 ];
 
   meta = with lib; {
     homepage = "https://www.eyrie.org/~eagle/software/pam-krb5/";

pkgs/os-specific/linux/pcmciautils/default.nix

···
 { config, lib, stdenv, fetchurl
-, yacc, flex
+, bison, flex
 , sysfsutils, kmod, udev
 , firmware   ? config.pcmciaUtils.firmware or [] # Special pcmcia cards.
 , configOpts ? config.pcmciaUtils.config or null # Special hardware (map memory & port & irq)
···
     sha256 = "0sfm3w2n73kl5w7gb1m6q8gy5k4rgwvzz79n6yhs9w3sag3ix8sk";
   };
 
-  buildInputs = [udev yacc sysfsutils kmod flex];
+  buildInputs = [udev bison sysfsutils kmod flex];
 
   patchPhase = ''
     sed -i "

pkgs/os-specific/linux/pipework/default.nix

···
 { stdenv, lib, fetchFromGitHub, makeWrapper
-, bridge-utils, iproute, lxc, openvswitch, docker, busybox, dhcpcd, dhcp
+, bridge-utils, iproute2, lxc, openvswitch, docker, busybox, dhcpcd, dhcp
 }:
 
 stdenv.mkDerivation {
···
   installPhase = ''
     install -D pipework $out/bin/pipework
     wrapProgram $out/bin/pipework --prefix PATH : \
-      ${lib.makeBinPath [ bridge-utils iproute lxc openvswitch docker busybox dhcpcd dhcp ]};
+      ${lib.makeBinPath [ bridge-utils iproute2 lxc openvswitch docker busybox dhcpcd dhcp ]};
   '';
   meta = with lib; {
     description = "Software-Defined Networking tools for LXC";

pkgs/os-specific/linux/ply/default.nix

···
-{ lib, stdenv, kernel, fetchFromGitHub, autoreconfHook, yacc, flex, p7zip, rsync }:
+{ lib, stdenv, kernel, fetchFromGitHub, autoreconfHook, bison, flex, p7zip, rsync }:
 
 assert kernel != null -> lib.versionAtLeast kernel.version "4.0";
 
···
 in stdenv.mkDerivation {
   pname = "ply";
   inherit version;
-  nativeBuildInputs = [ autoreconfHook flex yacc p7zip rsync ];
+  nativeBuildInputs = [ autoreconfHook flex bison p7zip rsync ];
 
   src = fetchFromGitHub {
     owner = "iovisor";

pkgs/os-specific/linux/power-profiles-daemon/default.nix

···
 , libxslt
 , upower
 , systemd
+, python3
 }:
 
 stdenv.mkDerivation rec {
   pname = "power-profiles-daemon";
-  version = "0.1";
+  version = "0.8.1";
 
   outputs = [ "out" "devdoc" ];
 
···
     owner = "hadess";
     repo = "power-profiles-daemon";
     rev = version;
-    sha256 = "012w3aryw5d43dr9jj5i6wy2a0n21jidr4ggs9ix7d4z9byr175w";
+    sha256 = "sha256-OnCUr7KWVPpYGDseBUcJD/PdOobvFnyNA97NhnKbTKY=";
   };
 
   nativeBuildInputs = [
···
     systemd
     upower
     glib
+    (python3.withPackages (ps: with ps; [ ps.pygobject3 ])) # for cli tool
   ];
 
   mesonFlags = [

pkgs/os-specific/linux/raspberrypi-eeprom/default.nix

···
 }:
 stdenvNoCC.mkDerivation {
   pname = "raspberrypi-eeprom";
-  version = "2020-12-11";
+  version = "2021-03-18";
 
   src = fetchFromGitHub {
     owner = "raspberrypi";
     repo = "rpi-eeprom";
-    rev = "54a9796abbee59067bff9da6b90c1014178f2c21";
-    sha256 = "0yp7bn444n6yisp4hiblrm00rrvrf213amzb4sh96mlb5nhxspqk";
+    rev = "ff27ccf69403b01e337fc4ee6e7ae75244028cce";
+    sha256 = "1q1vlld0xxh9zinf5g0qa6jw1dggq93br938mvrfx3nb2aviiwcj";
   };
 
   buildInputs = [ python3 ];
···
 
     cp rpi-eeprom-config rpi-eeprom-update $out/bin
     cp -r firmware/{beta,critical,old,stable} $out/share/rpi-eeprom
-    cp -r firmware/vl805 $out/bin
   '';
 
   fixupPhase = ''

pkgs/os-specific/linux/rdma-core/default.nix

···
 { lib, stdenv, fetchFromGitHub, cmake, pkg-config, docutils
-, pandoc, ethtool, iproute, libnl, udev, python3, perl
-}:
+, pandoc, ethtool, iproute2, libnl, udev, python3, perl
+} :
 
 let
   version = "34.0";
···
   };
 
   nativeBuildInputs = [ cmake pkg-config pandoc docutils ];
-  buildInputs = [ libnl ethtool iproute udev python3 perl ];
+  buildInputs = [ libnl ethtool iproute2 udev python3 perl ];
 
   cmakeFlags = [
     "-DCMAKE_INSTALL_RUNDIR=/run"

pkgs/os-specific/linux/sssd/default.nix

···
 { lib, stdenv, fetchurl, fetchpatch, glibc, augeas, dnsutils, c-ares, curl,
   cyrus_sasl, ding-libs, libnl, libunistring, nss, samba, nfs-utils, doxygen,
   python, python3, pam, popt, talloc, tdb, tevent, pkg-config, ldb, openldap,
-  pcre, kerberos, cifs-utils, glib, keyutils, dbus, fakeroot, libxslt, libxml2,
+  pcre, libkrb5, cifs-utils, glib, keyutils, dbus, fakeroot, libxslt, libxml2,
   libuuid, ldap, systemd, nspr, check, cmocka, uid_wrapper,
   nss_wrapper, ncurses, Po4a, http-parser, jansson,
   docbook_xsl, docbook_xml_dtd_44,
···
   enableParallelBuilding = true;
   buildInputs = [ augeas dnsutils c-ares curl cyrus_sasl ding-libs libnl libunistring nss
                   samba nfs-utils doxygen python python3 popt
-                  talloc tdb tevent pkg-config ldb pam openldap pcre kerberos
+                  talloc tdb tevent pkg-config ldb pam openldap pcre libkrb5
                   cifs-utils glib keyutils dbus fakeroot libxslt libxml2
                   libuuid ldap systemd nspr check cmocka uid_wrapper
                   nss_wrapper ncurses Po4a http-parser jansson ];

pkgs/os-specific/linux/trace-cmd/default.nix

···
 { lib, stdenv, fetchgit, asciidoc, docbook_xsl, libxslt }:
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "trace-cmd";
-  version = "2.9-dev";
+  version = "2.9.1";
 
-  src = fetchgit (import ./src.nix);
+  src = fetchgit {
+    url    = "git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git/";
+    rev    = "trace-cmd-v${version}";
+    sha256 = "19c63a0qmcppm1456qf4k6a0d1agcvpa6jnbzrdcyc520yax6khw";
+  };
 
   patches = [ ./fix-Makefiles.patch ];
 

pkgs/os-specific/linux/trace-cmd/fix-Makefiles.patch

···
 diff --git a/Makefile b/Makefile
-index bbdf15e..deb8ef7 100644
+index b034042..b8a06bc 100644
 --- a/Makefile
 +++ b/Makefile
-@@ -288,7 +288,7 @@ libtraceevent.a: $(LIBTRACEEVENT_STATIC)
- libtracecmd.a: $(LIBTRACECMD_STATIC)
- libtracecmd.so: $(LIBTRACECMD_SHARED)
+@@ -338,6 +338,7 @@ libtracefs.a: $(LIBTRACEFS_STATIC)
+ libtracefs.so: $(LIBTRACEFS_SHARED)
  
--libs: $(LIBTRACECMD_SHARED) $(LIBTRACEEVENT_SHARED)
-+libs: $(LIBTRACECMD_SHARED) $(LIBTRACEEVENT_SHARED) $(LIBTRACECMD_STATIC) $(LIBTRACEEVENT_STATIC)
+ libs: $(LIBTRACECMD_SHARED) $(LIBTRACEEVENT_SHARED) $(LIBTRACEFS_SHARED)
++libs: $(LIBTRACECMD_STATIC) $(LIBTRACEEVENT_STATIC) $(LIBTRACEFS_STATIC)
  
- plugins: force $(obj)/lib/traceevent/plugins/traceevent_plugin_dir $(obj)/lib/traceevent/plugins/trace_python_dir
- 	$(Q)$(MAKE) -C $(src)/lib/traceevent/plugins
-@@ -344,6 +344,8 @@ install_gui: install_cmd gui
- install_libs: libs
+ test: force $(LIBTRACEEVENT_STATIC) $(LIBTRACEFS_STATIC) $(LIBTRACECMD_STATIC)
+ ifneq ($(CUNIT_INSTALLED),1)
+@@ -414,6 +415,9 @@ install_libs: libs
  	$(Q)$(call do_install,$(LIBTRACECMD_SHARED),$(libdir_SQ)/trace-cmd)
  	$(Q)$(call do_install,$(LIBTRACEEVENT_SHARED),$(libdir_SQ)/traceevent)
+ 	$(Q)$(call do_install,$(LIBTRACEFS_SHARED),$(libdir_SQ)/tracefs)
 +	$(Q)$(call do_install,$(LIBTRACECMD_STATIC),$(libdir_SQ)/trace-cmd)
 +	$(Q)$(call do_install,$(LIBTRACEEVENT_STATIC),$(libdir_SQ)/traceevent)
++	$(Q)$(call do_install,$(LIBTRACEFS_STATIC),$(libdir_SQ)/tracefs)
  	$(Q)$(call do_install,$(src)/include/traceevent/event-parse.h,$(includedir_SQ)/traceevent)
  	$(Q)$(call do_install,$(src)/include/traceevent/trace-seq.h,$(includedir_SQ)/traceevent)
  	$(Q)$(call do_install,$(src)/include/trace-cmd/trace-cmd.h,$(includedir_SQ)/trace-cmd)
 diff --git a/kernel-shark/src/CMakeLists.txt b/kernel-shark/src/CMakeLists.txt
-index e20a030..7fce165 100644
+index 457c100..687e150 100644
 --- a/kernel-shark/src/CMakeLists.txt
 +++ b/kernel-shark/src/CMakeLists.txt
-@@ -93,7 +93,7 @@ if (Qt5Widgets_FOUND AND Qt5Network_FOUND)
+@@ -92,7 +92,7 @@ if (Qt5Widgets_FOUND AND Qt5Network_FOUND)
              DESTINATION ${_INSTALL_PREFIX}/share/icons/${KS_APP_NAME})
  
      install(FILES "${KS_DIR}/org.freedesktop.kshark-record.policy"

pkgs/os-specific/linux/trace-cmd/kernelshark.nix

···
 { lib, mkDerivation, fetchgit, qtbase, cmake, asciidoc, docbook_xsl, json_c, mesa_glu, freeglut, trace-cmd, pkg-config }:
-mkDerivation {
+mkDerivation rec {
   pname = "kernelshark";
-  version = "1.1.0";
+  version = "1.2";
 
-  src = fetchgit (import ./src.nix);
+  src = fetchgit {
+    url    = "git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git/";
+    rev    = "kernelshark-v${version}";
+    sha256 = "0wzzm2imk9n94v96v6sbvbff6j47lz4qj0snhiyv3nj3slg0anvh";
+  };
 
   patches = [ ./fix-Makefiles.patch ];
 
···
     "-DTRACECMD_INCLUDE_DIR=${trace-cmd.dev}/include"
     "-DTRACECMD_LIBRARY=${trace-cmd.lib}/lib/trace-cmd/libtracecmd.a"
     "-DTRACEEVENT_LIBRARY=${trace-cmd.lib}/lib/traceevent/libtraceevent.a"
+    "-DTRACEFS_LIBRARY=${trace-cmd.lib}/lib/tracefs/libtracefs.a"
   ];
 
   preInstall = ''

pkgs/os-specific/linux/trace-cmd/src.nix

···
-{
-  url    = "git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git/";
-  rev    = "ab370b78b9278fe16657742d46cb95c0a65b47d5"; # branch: kernelshark-v1.1
-  sha256 = "0qngwc4qgadrkwlwpz73f12prdkx94kl0bg7g9hib95ipvsdmk1c";
-}

pkgs/os-specific/linux/xpadneo/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "xpadneo";
-  version = "0.8.4";
+  version = "0.9.1";
 
   src = fetchFromGitHub {
     owner = "atar-axis";
     repo = pname;
     rev = "v${version}";
-    sha256 = "113xa2mxs2hc4fpjdk3jhhchy81kli6jxdd6vib7zz61n10cjb85";
+    hash = "sha256-VUcS4OzvPj0o627ZWIOBqEAQJ4JuMCMjgaZoMkL/IHc=";
   };
 
   setSourceRoot = ''
     export sourceRoot=$(pwd)/source/hid-xpadneo/src
   '';
 
-  postPatch = ''
-    # Set kernel module version
-    substituteInPlace hid-xpadneo.c \
-      --subst-var-by DO_NOT_CHANGE ${version}
-  '';
-
   nativeBuildInputs = kernel.moduleBuildDependencies;
   buildInputs = [ bluez ];
 
···
     "-C"
     "${kernel.dev}/lib/modules/${kernel.modDirVersion}/build"
     "M=$(sourceRoot)"
+    "VERSION=${version}"
   ];
 
   buildFlags = [ "modules" ];

pkgs/os-specific/windows/cygwin-setup/default.nix

···
 { lib, stdenv, fetchcvs, autoconf, automake, libtool, flex, bison, pkg-config
-, zlib, bzip2, lzma, libgcrypt
+, zlib, bzip2, xz, libgcrypt
 }:
 
 with lib;
···
       buildInputs = map mkStatic (o.buildInputs or []);
       propagatedBuildInputs = map mkStatic (o.propagatedBuildInputs or []);
     });
-  in map mkStatic [ zlib bzip2 lzma libgcrypt ];
+  in map mkStatic [ zlib bzip2 xz libgcrypt ];
 
   configureFlags = [ "--disable-shared" ];
 

pkgs/servers/home-assistant/appdaemon.nix

···
     description = "Sandboxed Python execution environment for writing automation apps for Home Assistant";
     homepage = "https://github.com/AppDaemon/appdaemon";
     license = licenses.mit;
-    maintainers = with maintainers; [ peterhoeg dotlambda ];
+    maintainers = with maintainers; [ peterhoeg ];
   };
 }

pkgs/servers/home-assistant/cli.nix

···
     description = "Command-line tool for Home Assistant";
     homepage = "https://github.com/home-assistant/home-assistant-cli";
     license = licenses.asl20;
-    maintainers = with maintainers; [ dotlambda ];
+    maintainers = with maintainers; [ ];
   };
 }

pkgs/servers/home-assistant/default.nix

···
     homepage = "https://home-assistant.io/";
     description = "Open source home automation that puts local control and privacy first";
     license = licenses.asl20;
-    maintainers = with maintainers; [ dotlambda globin mic92 hexa ];
+    maintainers = with maintainers; [ globin mic92 hexa ];
     platforms = platforms.linux;
   };
 }

pkgs/servers/home-assistant/frontend.nix

···
     description = "Polymer frontend for Home Assistant";
     homepage = "https://github.com/home-assistant/home-assistant-polymer";
     license = licenses.asl20;
-    maintainers = with maintainers; [ dotlambda globin ];
+    maintainers = with maintainers; [ globin ];
   };
 }

pkgs/servers/http/apt-cacher-ng/default.nix

···
 , fetchurl
 , fuse
 , libevent
-, lzma
+, xz
 , openssl
 , pkg-config
 , systemd
···
   };
 
   nativeBuildInputs = [ cmake doxygen pkg-config ];
-  buildInputs = [ bzip2 fuse libevent lzma openssl systemd tcp_wrappers zlib ];
+  buildInputs = [ bzip2 fuse libevent xz openssl systemd tcp_wrappers zlib ];
 
   meta = with lib; {
     description = "A caching proxy specialized for linux distribution files";

pkgs/servers/http/nix-binary-cache/default.nix

···
 {lib, stdenv
 , coreutils, findutils, nix, xz, bzip2, gnused, gnugrep, openssl
-, lighttpd, iproute }:
+, lighttpd, iproute2 }:
 stdenv.mkDerivation rec {
   version = "2014-06-29-1";
   pname = "nix-binary-cache";
···
       --replace @gnugrep@ "${gnugrep}/bin" \
       --replace @openssl@ "${openssl.bin}/bin" \
       --replace @lighttpd@ "${lighttpd}/sbin" \
-      --replace @iproute@ "${iproute}/sbin" \
+      --replace @iproute@ "${iproute2}/sbin" \
       --replace "xXxXx" "xXxXx"
 
     chmod a+x "$out/bin/nix-binary-cache.cgi"
···
       --replace @gnugrep@ "${gnugrep}/bin" \
       --replace @openssl@ "${openssl.bin}/bin" \
       --replace @lighttpd@ "${lighttpd}/sbin" \
-      --replace @iproute@ "${iproute}/sbin" \
+      --replace @iproute@ "${iproute2}/sbin" \
       --replace "xXxXx" "xXxXx"
 
     chmod a+x "$out/bin/nix-binary-cache-start"

pkgs/servers/irc/ircd-hybrid/default.nix

···
 { lib, stdenv, fetchurl, openssl, zlib }:
 
 stdenv.mkDerivation rec {
-  name = "ircd-hybrid-8.2.35";
+  name = "ircd-hybrid-8.2.36";
 
   src = fetchurl {
     url = "mirror://sourceforge/ircd-hybrid/${name}.tgz";
-    sha256 = "045wd3wa4i1hl7i4faksaj8l5r70ld55bggryaf1ml28ijwjwpca";
+    sha256 = "0sg4g0znl8ic8vklpy96z88gjksc165kl945a6fr1j4xc1bf8gcv";
   };
 
   buildInputs = [ openssl zlib ];

pkgs/servers/jackett/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "jackett";
-  version = "0.17.699";
+  version = "0.17.764";
 
   src = fetchurl {
     url = "https://github.com/Jackett/Jackett/releases/download/v${version}/Jackett.Binaries.Mono.tar.gz";
-    sha256 = "sha256-dftllucRemUdZjYDLKPJ4XJ031OZpsW4bpJDuWPyses=";
+    sha256 = "sha256-x6yjSshTK/dnEPZ/XACDuVpZi0tI1J8tQHBFFvFhCmg=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/servers/ldap/389/default.nix

···
 { lib, stdenv, fetchurl, fetchpatch, autoreconfHook, pkg-config, doxygen, perl, pam, nspr, nss, openldap
-, db, cyrus_sasl, svrcore, icu, net-snmp, kerberos, pcre, perlPackages, libevent, openssl, python3
+, db, cyrus_sasl, svrcore, icu, net-snmp, libkrb5, pcre, perlPackages, libevent, openssl, python3
 }:
 
 stdenv.mkDerivation rec {
···
   nativeBuildInputs = [ autoreconfHook pkg-config doxygen ];
   buildInputs = [
     perl pam nspr nss openldap db cyrus_sasl svrcore icu
-    net-snmp kerberos pcre libevent openssl python3
+    net-snmp libkrb5 pcre libevent openssl python3
   ] ++ (with perlPackages; [ MozillaLdap NetAddrIP DBFile ]);
 
   patches = [

pkgs/servers/mail/mailman/default.nix

···
 
 buildPythonPackage rec {
   pname = "mailman";
-  version = "3.3.1";
+  version = "3.3.4";
   disabled = !isPy3k;
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0idfiv48jjgc0jq4731094ddhraqq8bxnwmjk6sg5ask0jss9kxq";
+    sha256 = "01rx322b8mzcdj9xh4bjwnl0zis6n2wxd31rrij4cw3a2j03xpas";
   };
 
   propagatedBuildInputs = [

pkgs/servers/mail/mailman/hyperkitty.nix

···
 
 buildPythonPackage rec {
   pname = "HyperKitty";
+  # Note: Mailman core must be on the latest version before upgrading HyperKitty.
+  # See: https://gitlab.com/mailman/postorius/-/issues/516#note_544571309
   version = "1.3.3";
   disabled = !isPy3k;
 

pkgs/servers/mail/mailman/postorius.nix

···
 
 buildPythonPackage rec {
   pname = "postorius";
+  # Note: Mailman core must be on the latest version before upgrading Postorious.
+  # See: https://gitlab.com/mailman/postorius/-/issues/516#note_544571309
   version = "1.3.4";
 
   src = fetchPypi {

pkgs/servers/matterbridge/default.nix

···
 
 buildGoModule rec {
   pname = "matterbridge";
-  version = "1.22.0";
+  version = "1.22.1";
 
   vendorSha256 = null;
 
···
 
   src = fetchurl {
     url = "https://github.com/42wim/matterbridge/archive/v${version}.tar.gz";
-    sha256 = "sha256-jwatqxQh4t4tgNiOEjS9vxIM+9XtnH8QNch887+xDnI=";
+    sha256 = "sha256-yV805OWFNOxKIGd6t2kRcUzdB8xYWYHFK+W2u/QPTXg=";
   };
 
   meta = with lib; {

pkgs/servers/monitoring/fusion-inventory/default.nix

···
-{ lib, perlPackages, nix, dmidecode, pciutils, usbutils, iproute, nettools
+{ lib, perlPackages, nix, dmidecode, pciutils, usbutils, iproute2, nettools
 , fetchFromGitHub, makeWrapper
 }:
 
···
     patchShebangs bin
 
     substituteInPlace "lib/FusionInventory/Agent/Tools/Linux.pm" \
-      --replace /sbin/ip ${iproute}/sbin/ip
+      --replace /sbin/ip ${iproute2}/sbin/ip
     substituteInPlace "lib/FusionInventory/Agent/Task/Inventory/Linux/Networks.pm" \
-      --replace /sbin/ip ${iproute}/sbin/ip
+      --replace /sbin/ip ${iproute2}/sbin/ip
   '';
 
   buildTools = [];
···
     for cur in $out/bin/*; do
       if [ -x "$cur" ]; then
         sed -e "s|./lib|$out/lib|" -i "$cur"
-        wrapProgram "$cur" --prefix PATH : ${lib.makeBinPath [nix dmidecode pciutils usbutils nettools iproute]}
+        wrapProgram "$cur" --prefix PATH : ${lib.makeBinPath [nix dmidecode pciutils usbutils nettools iproute2]}
       fi
     done
   '';

pkgs/servers/monitoring/loki/default.nix

···
-{ stdenv, lib, buildGoModule, fetchFromGitHub, makeWrapper, nixosTests, systemd
+{ stdenv
+, lib
+, buildGoModule
+, fetchFromGitHub
+, makeWrapper
+, nixosTests
+, systemd
 }:
 
 buildGoModule rec {
-  version = "2.2.0";
+  version = "2.2.1";
   pname = "grafana-loki";
 
   src = fetchFromGitHub {
     rev = "v${version}";
     owner = "grafana";
     repo = "loki";
-    sha256 = "sha256-mEu9z3lhHSE0NMXXViX4OBbIiNba7/RPr+AFmIM77g4=";
+    sha256 = "sha256-ujZD5GIgMewvEQW3Wnt0eHdMIFs77PkkEecgCDw9290=";
   };
 
   vendorSha256 = null;
···
 
   passthru.tests = { inherit (nixosTests) loki; };
 
-  buildFlagsArray = let t = "github.com/grafana/loki/pkg/build"; in ''
-    -ldflags=-s -w -X ${t}.Version=${version} -X ${t}.BuildUser=nix@nixpkgs -X ${t}.BuildDate=unknown -X ${t}.Branch=unknown -X ${t}.Revision=unknown
-  '';
+  buildFlagsArray = let t = "github.com/grafana/loki/pkg/build"; in
+    ''
+      -ldflags=-s -w -X ${t}.Version=${version} -X ${t}.BuildUser=nix@nixpkgs -X ${t}.BuildDate=unknown -X ${t}.Branch=unknown -X ${t}.Revision=unknown
+    '';
 
   doCheck = true;
 

pkgs/servers/monitoring/mackerel-agent/default.nix

···
-{ stdenv, lib, buildGoModule, fetchFromGitHub, makeWrapper, iproute, nettools }:
+{ stdenv, lib, buildGoModule, fetchFromGitHub, makeWrapper, iproute2, nettools }:
 
 buildGoModule rec {
   pname = "mackerel-agent";
···
 
   nativeBuildInputs = [ makeWrapper ];
   checkInputs = lib.optionals (!stdenv.isDarwin) [ nettools ];
-  buildInputs = lib.optionals (!stdenv.isDarwin) [ iproute ];
+  buildInputs = lib.optionals (!stdenv.isDarwin) [ iproute2 ];
 
   vendorSha256 = "sha256-yomxALecP+PycelOmwrteK/LoW7wsst7os+jcbF46Bs=";
 

pkgs/servers/monitoring/prometheus/bitcoin-exporter.nix

···
+{ lib, fetchFromGitHub, fetchpatch, python3Packages }:
+
+python3Packages.buildPythonApplication rec {
+  pname = "bitcoin-prometheus-exporter";
+  version = "0.5.0";
+
+  format = "other";
+
+  src = fetchFromGitHub {
+    owner = "jvstein";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "0l0j6dyb0vflh386z3g8srysay5sf47g5rg2f5xrkckv86rjr115";
+  };
+
+  patches = [
+    # remove after update to new release
+    (fetchpatch {
+      name = "configurable-listening-address.patch";
+      url = "https://patch-diff.githubusercontent.com/raw/jvstein/bitcoin-prometheus-exporter/pull/11.patch";
+      sha256 = "0a2l8aqgprc1d5k8yg1gisn6imh9hzg6j0irid3pjvp5i5dcnhyq";
+    })
+  ];
+
+  propagatedBuildInputs = with python3Packages; [ prometheus_client bitcoinlib riprova ];
+
+  installPhase = ''
+    mkdir -p $out/bin
+    cp bitcoind-monitor.py $out/bin/
+
+    mkdir -p $out/share/${pname}
+    cp -r dashboard README.md $out/share/${pname}/
+  '';
+
+  meta = with lib; {
+    description = "Prometheus exporter for Bitcoin Core nodes";
+    homepage = "https://github.com/jvstein/bitcoin-prometheus-exporter";
+    license = licenses.bsd3;
+    maintainers = with maintainers; [ mmilata ];
+    platforms = platforms.all;
+  };
+}

pkgs/servers/monitoring/sensu-go/default.nix

···
   generic = { subPackages, pname, postInstall ? "" }:
     buildGoModule rec {
       inherit pname;
-      version = "6.2.3";
+      version = "6.2.7";
       shortRev = "3a1ac58"; # for internal version info
 
       src = fetchFromGitHub {
         owner = "sensu";
         repo = "sensu-go";
         rev = "v${version}";
-        sha256 = "sha256-8+ibl2D8hSzFV+snJAxRNTiyYqCndUDGVCVKt2bkPlQ=";
+        sha256 = "sha256-JPX7MfxdlI6jLHVybAR4xtd/IiVGDrhrYUSlXohhpGc=";
       };
 
       inherit subPackages postInstall;
 
-  vendorSha256 = "sha256-KykxKJxel4E5VB8QAkEpBBaA7hKfSnTDkJ9qlNEln80=";
+  vendorSha256 = "sha256-bGQADjT9SMxZnWb3k7wVSsF7VWWuESBL/VDG76vj+Tk=";
 
   doCheck = false;
 

pkgs/servers/monitoring/thanos/default.nix

···
 { lib, buildGoModule, fetchFromGitHub }:
 buildGoModule rec {
   pname = "thanos";
-  version = "0.18.0";
+  version = "0.19.0";
 
   src = fetchFromGitHub {
     rev = "v${version}";
     owner = "thanos-io";
     repo = "thanos";
-    sha256 = "sha256-GJKTQGMmFJeUQn02GWP4KKpKdM8eT+VxDBDzST+5NXk=";
+    sha256 = "sha256-FryVKOabokw2+RyD94QLVpC9ZGIHPuSXZf5H+eitj80=";
   };
 
-  vendorSha256 = "sha256-s11iJFcJ1Ez6TkhCU3VD2ThU5/9otHz5rDF8z9ux79E=";
+  vendorSha256 = "sha256-GBjPMZ6BwUOKywNf1Bc2WeA14qvKQ0R5gWvVxgO/7Lo=";
 
   doCheck = false;
 

pkgs/servers/mqtt/mosquitto/default.nix

···
-{ stdenv, lib, fetchFromGitHub, cmake, docbook_xsl, libxslt
-, openssl, libuuid, libwebsockets_3_1, c-ares, libuv
-, systemd ? null, withSystemd ? stdenv.isLinux }:
+{ stdenv
+, lib
+, fetchFromGitHub
+, cmake
+, docbook_xsl
+, libxslt
+, c-ares
+, cjson
+, libuuid
+, libuv
+, libwebsockets_3_1
+, openssl
+, withSystemd ? stdenv.isLinux
+, systemd
+}:
 
 stdenv.mkDerivation rec {
   pname = "mosquitto";
-  version = "1.6.12";
+  version = "2.0.10";
 
   src = fetchFromGitHub {
-    owner  = "eclipse";
-    repo   = "mosquitto";
-    rev    = "v${version}";
-    sha256 = "0y9jna2p7wg57vv2g6ls1dj6w89vaw828y9z1wb3vwz1yhvs35s8";
+    owner = "eclipse";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "144vw7b9ja4lci4mplbxs048x9aixd9c3s7rg6wc1k31w099rb12";
   };
 
   postPatch = ''
···
         --replace http://docbook.sourceforge.net/release/xsl/current ${docbook_xsl}/share/xml/docbook-xsl
     done
 
-    for f in {lib,lib/cpp,src}/CMakeLists.txt ; do
-      substituteInPlace $f --replace /sbin/ldconfig true
-    done
-
     # the manpages are not generated when using cmake
     pushd man
     make
     popd
   '';
+
+  nativeBuildInputs = [ cmake docbook_xsl libxslt ];
 
   buildInputs = [
-    openssl libuuid libwebsockets_3_1 c-ares libuv
+    c-ares
+    cjson
+    libuuid
+    libuv
+    libwebsockets_3_1
+    openssl
   ] ++ lib.optional withSystemd systemd;
-
-  nativeBuildInputs = [ cmake docbook_xsl libxslt ];
 
   cmakeFlags = [
     "-DWITH_THREADING=ON"
···
   ] ++ lib.optional withSystemd "-DWITH_SYSTEMD=ON";
 
   meta = with lib; {
-    description = "An open source MQTT v3.1/3.1.1 broker";
+    description = "An open source MQTT v3.1/3.1.1/5.0 broker";
     homepage = "https://mosquitto.org/";
     license = licenses.epl10;
     maintainers = with maintainers; [ peterhoeg ];

pkgs/servers/nats-server/default.nix

···
 
 buildGoPackage rec {
   pname   = "nats-server";
-  version = "2.2.0";
+  version = "2.2.1";
 
   goPackagePath = "github.com/nats-io/${pname}";
 
···
     rev    = "v${version}";
     owner  = "nats-io";
     repo   = pname;
-    sha256 = "sha256-CNCdJUug99a9yE8YxSk7/s1CIEYJd9n8Gahz+B3ZyjI=";
+    sha256 = "sha256-LQ817nZrFkF1zdj2m2SQK58BqDbUPSnncSWR+Woi+Ao=";
   };
 
   meta = {

pkgs/servers/openafs/1.8/default.nix

···
 { lib, stdenv, buildPackages, fetchurl, which, autoconf, automake, flex
-, yacc , glibc, perl, kerberos, libxslt, docbook_xsl, file
+, bison , glibc, perl, libkrb5, libxslt, docbook_xsl, file
 , docbook_xml_dtd_43, libtool_2
 , withDevdoc ? false, doxygen, dblatex # Extra developer documentation
 , ncurses # Extra ncurses utilities. Needed for debugging and monitoring.
···
 
   depsBuildBuild = [ buildPackages.stdenv.cc ];
   nativeBuildInputs = [ autoconf automake flex libxslt libtool_2 perl
-    which yacc ] ++ optionals withDevdoc [ doxygen dblatex ];
+    which bison ] ++ optionals withDevdoc [ doxygen dblatex ];
 
-  buildInputs = [ kerberos ncurses ];
+  buildInputs = [ libkrb5 ncurses ];
 
   patches = [ ./bosserver.patch ./cross-build.patch ] ++ optional (tsmbac != null) ./tsmbac.patch;
 

pkgs/servers/openafs/1.8/module.nix

···
-{ lib, stdenv, fetchurl, which, autoconf, automake, flex, yacc
-, kernel, glibc, perl, libtool_2, kerberos, fetchpatch }:
+{ lib, stdenv, fetchurl, which, autoconf, automake, flex, bison
+, kernel, glibc, perl, libtool_2, libkrb5, fetchpatch }:
 
 with (import ./srcs.nix {
   inherit fetchurl;
···
   name = "openafs-${version}-${kernel.modDirVersion}";
   inherit version src;
 
-  nativeBuildInputs = [ autoconf automake flex libtool_2 perl which yacc ]
+  nativeBuildInputs = [ autoconf automake flex libtool_2 perl which bison ]
     ++ kernel.moduleBuildDependencies;
 
-  buildInputs = [ kerberos ];
+  buildInputs = [ libkrb5 ];
 
   patches = [
     # LINUX 5.8: Replace kernel_setsockopt with new funcs
···
     maintainers = [ maintainers.maggesi maintainers.spacefrogg ];
     broken = versionOlder kernel.version "3.18" || kernel.isHardened;
   };
-
 }

pkgs/servers/openafs/1.9/default.nix

···
 { lib, stdenv, buildPackages, fetchurl, which, autoconf, automake, flex
-, yacc , glibc, perl, kerberos, libxslt, docbook_xsl, file
+, bison , glibc, perl, libkrb5, libxslt, docbook_xsl, file
 , docbook_xml_dtd_43, libtool_2
 , withDevdoc ? false, doxygen, dblatex # Extra developer documentation
 , ncurses # Extra ncurses utilities. Needed for debugging and monitoring.
···
 
   depsBuildBuild = [ buildPackages.stdenv.cc ];
   nativeBuildInputs = [ autoconf automake flex libxslt libtool_2 perl
-    which yacc ] ++ optionals withDevdoc [ doxygen dblatex ];
+    which bison ] ++ optionals withDevdoc [ doxygen dblatex ];
 
-  buildInputs = [ kerberos ncurses ];
+  buildInputs = [ libkrb5 ncurses ];
 
   patches = [ ./bosserver.patch ./cross-build.patch ] ++ optional (tsmbac != null) ./tsmbac.patch;
 

pkgs/servers/openafs/1.9/module.nix

···
-{ lib, stdenv, fetchurl, which, autoconf, automake, flex, yacc
-, kernel, glibc, perl, libtool_2, kerberos, fetchpatch }:
+{ lib, stdenv, fetchurl, which, autoconf, automake, flex, bison
+, kernel, glibc, perl, libtool_2, libkrb5, fetchpatch }:
 
 with (import ./srcs.nix {
   inherit fetchurl;
···
   name = "openafs-${version}-${kernel.modDirVersion}";
   inherit version src;
 
-  nativeBuildInputs = [ autoconf automake flex libtool_2 perl which yacc ]
+  nativeBuildInputs = [ autoconf automake flex libtool_2 perl which bison ]
     ++ kernel.moduleBuildDependencies;
 
-  buildInputs = [ kerberos ];
+  buildInputs = [ libkrb5 ];
 
   patches = [];
 
···
     maintainers = [ maintainers.maggesi maintainers.spacefrogg ];
     broken = versionOlder kernel.version "3.18" || kernel.isHardened;
   };
-
 }

pkgs/servers/openbgpd/default.nix

···
-{ lib, stdenv, fetchFromGitHub, autoconf, automake, libtool, m4, yacc }:
+{ lib, stdenv, fetchFromGitHub, autoconf, automake, libtool, m4, bison }:
 
 let
   openbsd_version =
···
     sha256 = "sha256-TKs6tt/SCWes6kYAGIrSShZgOLf7xKh26xG3Zk7wCCw=";
   };
 
-  nativeBuildInputs = [ autoconf automake libtool m4 yacc ];
+  nativeBuildInputs = [ autoconf automake libtool m4 bison ];
 
   preConfigure = ''
     mkdir ./openbsd

pkgs/servers/pim6sd/default.nix

···
-{ stdenv, fetchFromGitHub, lib, autoreconfHook, yacc, flex }:
+{ stdenv, fetchFromGitHub, lib, autoreconfHook, bison, flex }:
 
 stdenv.mkDerivation rec {
   pname = "pim6sd";
···
     sha256 = "0x7dyark2mp9xqz9cnmmgaf0z143vxn2835clllpji4ylg77zdjw";
   };
 
-  nativeBuildInputs = [ autoreconfHook yacc flex ];
+  nativeBuildInputs = [ autoreconfHook bison flex ];
 
   meta = with lib; {
     description = "PIM for IPv6 sparse mode daemon";

pkgs/servers/plex/raw.nix

···
 # server, and the FHS userenv and corresponding NixOS module should
 # automatically pick up the changes.
 stdenv.mkDerivation rec {
-  version = "1.22.0.4163-d8c4875dd";
+  version = "1.22.1.4275-48e10484b";
   pname = "plexmediaserver";
 
   # Fetch the source
   src = if stdenv.hostPlatform.system == "aarch64-linux" then fetchurl {
     url = "https://downloads.plex.tv/plex-media-server-new/${version}/debian/plexmediaserver_${version}_arm64.deb";
-    sha256 = "16lwcimgnpxcyxbk4qwkqz5mzmizqfzihwqb41awc38qlfbjzh5g";
+    sha256 = "08x5ay0nvsdc2n584bw0vdqxh33wn0mlwyqciwgvwq873jn39j3z";
   } else fetchurl {
     url = "https://downloads.plex.tv/plex-media-server-new/${version}/debian/plexmediaserver_${version}_amd64.deb";
-    sha256 = "0wvqrn7mycrx0rn4zkp6cr2mr59nfqh63czm0awsfpqc6hqggz8y";
+    sha256 = "1h5pkd7fzqlbvqv25cdppglw651yc3026hnyim5vy1s1s182paws";
   };
 
   outputs = [ "out" "basedb" ];

pkgs/servers/pounce/default.nix

···
-{ lib, stdenv, libressl, fetchzip, fetchpatch, pkg-config }:
+{ lib, stdenv, libressl, fetchzip, pkg-config }:
 
 stdenv.mkDerivation rec {
   pname = "pounce";
-  version = "2.1p1";
+  version = "2.3";
 
   src = fetchzip {
     url = "https://git.causal.agency/pounce/snapshot/pounce-${version}.tar.gz";
-    sha256 = "1gphia45swj4ws6nrklqg1hvjrc6yw921v0pf29cvjhwrfl6dl0h";
+    sha256 = "0pk3kwr6k6dz2vdx1kyv7mhj756j4bwsmdlmjzhh8ghczjqp2s2x";
   };
 
   buildInputs = [ libressl ];

pkgs/servers/rtsp-simple-server/default.nix

···
 
 buildGoModule rec {
   pname = "rtsp-simple-server";
-  version = "0.15.2";
+  version = "0.15.3";
 
   src = fetchFromGitHub {
     owner = "aler9";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-XuyE0gubkE08Qei30/q8fLdX8V7zBsbFsdaiqbXgeI4=";
+    sha256 = "sha256-eY3XtGmHp7TM+lXC9tdd51x7sLuuZfBDJxTZ79Ye0Qs=";
   };
 
-  vendorSha256 = "sha256-4R2gA9QwfyBNDasRuDawDFEmXu31yGuZUQZS6cZL3B0=";
+  vendorSha256 = "sha256-SiWcOI1XxrwwTAzp8HC5zOO5e2oSWBMFRYsW2RwPA5I=";
 
   # Tests need docker
   doCheck = false;

pkgs/servers/sabnzbd/default.nix

···
   ]);
   path = lib.makeBinPath [ par2cmdline unrar unzip p7zip ];
 in stdenv.mkDerivation rec {
-  version = "3.2.0";
+  version = "3.2.1";
   pname = "sabnzbd";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
     rev = version;
-    sha256 = "sha256-h+efFsyCqcMktKpKOqaHkfFdJKGAjvIOc6NmIyXnZDA=";
+    sha256 = "sha256-y2uaXa2DPZHBLukAdwKTwXauaJHX5Uft35vsthzGwME=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/servers/sickbeard/sickgear.nix

···
   pythonEnv = python2.withPackages(ps: with ps; [ cheetah ]);
 in stdenv.mkDerivation rec {
   pname = "sickgear";
-  version = "0.23.14";
+  version = "0.23.15";
 
   src = fetchFromGitHub {
     owner = "SickGear";
     repo = "SickGear";
     rev = "release_${version}";
-    sha256 = "sha256-QhBdOXu+KizeSYHUbNflDaDpzjeEFaYkhY+K1MgLzzc=";
+    sha256 = "sha256-xZ2SgYSEamh+Z64VKvIemqJLH/WjJHFji5qIameF5hM=";
   };
 
   dontBuild = true;

pkgs/servers/tailscale/default.nix

···
-{ lib, buildGoModule, fetchFromGitHub, makeWrapper, iptables, iproute }:
+{ lib, buildGoModule, fetchFromGitHub, makeWrapper, iptables, iproute2 }:
 
 buildGoModule rec {
   pname = "tailscale";
···
 
   postInstall = ''
     wrapProgram $out/bin/tailscaled --prefix PATH : ${
-      lib.makeBinPath [ iproute iptables ]
+      lib.makeBinPath [ iproute2 iptables ]
     }
     sed -i -e "s#/usr/sbin#$out/bin#" -e "/^EnvironmentFile/d" ./cmd/tailscaled/tailscaled.service
     install -D -m0444 -t $out/lib/systemd/system ./cmd/tailscaled/tailscaled.service

pkgs/servers/web-apps/wiki-js/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "wiki-js";
-  version = "2.5.197";
+  version = "2.5.201";
 
   src = fetchurl {
     url = "https://github.com/Requarks/wiki/releases/download/${version}/${pname}.tar.gz";
-    sha256 = "sha256-0xM9BtQvSt5WkbKBri+KxB+Ghc4wgY8/TUgI6PCFmm0=";
+    sha256 = "sha256-k2G+jUne/lq0dRJsIQpWlRFg1Nq92bM28YkawKOKlsI=";
   };
 
   sourceRoot = ".";

pkgs/servers/zoneminder/default.nix

···
 { stdenv, lib, fetchFromGitHub, fetchurl, fetchpatch, substituteAll, cmake, makeWrapper, pkg-config
-, curl, ffmpeg_3, glib, libjpeg, libselinux, libsepol, mp4v2, libmysqlclient, mysql, pcre, perl, perlPackages
+, curl, ffmpeg_3, glib, libjpeg, libselinux, libsepol, mp4v2, libmysqlclient, mariadb, pcre, perl, perlPackages
 , polkit, util-linuxMinimal, x264, zlib
 , coreutils, procps, psmisc, nixosTests }:
 
···
     done
 
     substituteInPlace scripts/zmdbbackup.in \
-      --replace /usr/bin/mysqldump ${mysql.client}/bin/mysqldump
+      --replace /usr/bin/mysqldump ${mariadb.client}/bin/mysqldump
 
     substituteInPlace scripts/zmupdate.pl.in \
-      --replace "'mysql'" "'${mysql.client}/bin/mysql'" \
-      --replace "'mysqldump'" "'${mysql.client}/bin/mysqldump'"
+      --replace "'mysql'" "'${mariadb.client}/bin/mysql'" \
+      --replace "'mysqldump'" "'${mariadb.client}/bin/mysqldump'"
 
     for f in scripts/ZoneMinder/lib/ZoneMinder/Config.pm.in \
              scripts/zmupdate.pl.in \
···
   '';
 
   buildInputs = [
-    curl ffmpeg_3 glib libjpeg libselinux libsepol mp4v2 libmysqlclient mysql.client pcre perl polkit x264 zlib
+    curl ffmpeg_3 glib libjpeg libselinux libsepol mp4v2 libmysqlclient mariadb.client pcre perl polkit x264 zlib
     util-linuxMinimal # for libmount
   ] ++ (with perlPackages; [
     # build-time dependencies

pkgs/shells/es/default.nix

···
-{ lib, stdenv, fetchurl, readline, yacc }:
+{ lib, stdenv, fetchurl, readline, bison }:
 
 let
   version = "0.9.1";
···
     sourceRoot=.
   '';
 
-  buildInputs = [ readline yacc ];
+  buildInputs = [ readline bison ];
 
   configureFlags = [ "--with-readline" ];
 

pkgs/shells/zsh/zsh-clipboard/clipboard.plugin.zsh

···
+_cb-yank() {
+  AA=$(clippaste 2>/dev/null) && CUTBUFFER="$AA"
+  zle yank
+}
+_cb-kill-line() {
+  zle kill-line
+  printf "%s" "$CUTBUFFER" | clipcopy 2>/dev/null
+}
+_cb-kill-whole-line() {
+  zle kill-whole-line
+  printf "%s" "$CUTBUFFER" | clipcopy 2>/dev/null
+}
+_cb-kill-word() {
+  zle kill-word
+  printf "%s" "$CUTBUFFER" | clipcopy 2>/dev/null
+}
+_cb-backward-kill-word() {
+  zle backward-kill-word
+  printf "%s" "$CUTBUFFER" | clipcopy 2>/dev/null
+}
+_cb-copy-region-as-kill() {
+  ## https://unix.stackexchange.com/questions/19947/
+  zle copy-region-as-kill
+  zle set-mark-command -n -1
+  printf "%s" "$CUTBUFFER" | clipcopy 2>/dev/null
+}
+
+zle -N _cb-yank
+zle -N _cb-kill-line
+zle -N _cb-kill-whole-line
+zle -N _cb-kill-word
+zle -N _cb-backward-kill-word
+zle -N _cb-copy-region-as-kill
+
+bindkey '^y'   _cb-yank
+bindkey '^k'   _cb-kill-line
+bindkey '^u'   _cb-kill-whole-line
+bindkey '\ed'  _cb-kill-word
+bindkey '\e^?' _cb-backward-kill-word
+bindkey '\ew'  _cb-copy-region-as-kill

pkgs/shells/zsh/zsh-clipboard/default.nix

···
+{ stdenv, lib }:
+
+stdenv.mkDerivation rec {
+  pname = "zsh-clipboard";
+  version = "1.0";
+
+  src = ./.;
+
+  dontBuild = true;
+
+  installPhase = ''
+    install -D -m0444 -t $out/share/zsh/plugins/clipboard ./clipboard.plugin.zsh
+  '';
+
+  meta = with lib; {
+    description = "Ohmyzsh plugin that integrates kill-ring with system clipboard";
+    longDescription = ''
+      Ohmyzsh plugin that integrates kill-ring with system clipboard.
+
+      Key bindings for C-y, C-k, C-u, M-d, M-backspace and M-w are rebound.
+      Behaviour of these keys should not be changed.
+    '';
+    license = licenses.mit;
+    maintainers = with maintainers; [ bb2020 ];
+    platforms = platforms.unix;
+  };
+}

pkgs/tools/admin/acme.sh/default.nix

···
-{ stdenv, lib, fetchFromGitHub, makeWrapper, curl, openssl, socat, iproute, unixtools, dnsutils }:
+{ stdenv, lib, fetchFromGitHub, makeWrapper, curl, openssl, socat, iproute2, unixtools, dnsutils }:
 stdenv.mkDerivation rec {
   pname = "acme.sh";
   version = "2.8.8";
···
           openssl
           curl
           dnsutils
-          (if stdenv.isLinux then iproute else unixtools.netstat)
+          (if stdenv.isLinux then iproute2 else unixtools.netstat)
         ]
       }"
   '';

pkgs/tools/admin/exoscale-cli/default.nix

···
 
 buildGoPackage rec {
   pname = "exoscale-cli";
-  version = "1.27.0";
+  version = "1.27.1";
 
   src = fetchFromGitHub {
     owner  = "exoscale";
     repo   = "cli";
     rev    = "v${version}";
-    sha256 = "sha256-bKciwcYGETwVdUS4qdByHLWKt16PpBtTvW/dvuclIpA=";
+    sha256 = "sha256-YaW7rTeVz2Mbnmp6ORsnALlyVxGnf8K73LXN/fmJMLk=";
   };
 
   goPackagePath = "github.com/exoscale/cli";

pkgs/tools/admin/fioctl/default.nix

···
 
 buildGoModule rec {
   pname = "fioctl";
-  version = "0.14.1";
+  version = "0.15";
 
   src = fetchFromGitHub {
     owner = "foundriesio";
     repo = "fioctl";
     rev = "v${version}";
-    sha256 = "1jbj2w2s78wcnrwyr80jyc11ipjysv5aab3486kphx8ysvvgcwfs";
+    sha256 = "0gmh32h9j6wpkdxxg7vj158lsaxq30x7hjsc9gwpip3bff278hw4";
   };
 
-  vendorSha256 = "1a3x6cv18f0n01f4ac1kprzmby8dphygnwsdl98pmzs3gqqnh284";
+  vendorSha256 = "170z5a1iwwcpz890nficqnz7rr7yzdxr5jx9pa7s31z17lr8kbz9";
 
   runVend = true;
 

pkgs/tools/admin/lxd/default.nix

···
 { lib, hwdata, pkg-config, lxc, buildGoPackage, fetchurl
 , makeWrapper, acl, rsync, gnutar, xz, btrfs-progs, gzip, dnsmasq
-, squashfsTools, iproute, iptables, ebtables, iptables-nftables-compat, libcap
+, squashfsTools, iproute2, iptables, ebtables, iptables-nftables-compat, libcap
 , libco-canonical, dqlite, raft-canonical, sqlite-replication, udev
 , writeShellScriptBin, apparmor-profiles, apparmor-parser
 , criu
···
 
     wrapProgram $out/bin/lxd --prefix PATH : ${lib.makeBinPath (
       networkPkgs
-      ++ [ acl rsync gnutar xz btrfs-progs gzip dnsmasq squashfsTools iproute bash criu ]
+      ++ [ acl rsync gnutar xz btrfs-progs gzip dnsmasq squashfsTools iproute2 bash criu ]
       ++ [ (writeShellScriptBin "apparmor_parser" ''
              exec '${apparmor-parser}/bin/apparmor_parser' -I '${apparmor-profiles}/etc/apparmor.d' "$@"
            '') ]

pkgs/tools/archivers/fsarchiver/default.nix

···
 { lib, stdenv, fetchFromGitHub, autoreconfHook, pkg-config
-, zlib, bzip2, lzma, lzo, lz4, zstd, xz
+, zlib, bzip2, lzo, lz4, zstd, xz
 , libgcrypt, e2fsprogs, util-linux, libgpgerror }:
 
 let
···
   ];
 
   buildInputs = [
-    zlib bzip2 lzma lzo lz4 zstd xz
+    zlib bzip2 xz lzo lz4 zstd xz
     libgcrypt e2fsprogs util-linux libgpgerror
   ];
 

pkgs/tools/archivers/innoextract/default.nix

···
 { lib, stdenv, fetchurl, cmake, makeWrapper
-, boost, lzma
+, boost, xz
 , withGog ? false, unar ? null }:
 
 stdenv.mkDerivation rec {
···
     sha256 = "09l1z1nbl6ijqqwszdwch9mqr54qb7df0wp2sd77v17dq6gsci33";
   };
 
-  buildInputs = [ lzma boost ];
+  buildInputs = [ xz boost ];
 
   # Python is reported as missing during the build, however
   # including Python does not change the output.

pkgs/tools/archivers/p7zip/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "p7zip";
-  version = "17.03";
+  version = "17.04";
 
   src = fetchFromGitHub {
     owner  = "szcnick";
     repo   = pname;
     rev    = "v${version}";
-    sha256 = "0zgpa90z5p30jbpqydiig1h8hn41c76n2x26rh8cc92xw72ni33d";
+    sha256 = "sha256-19F4hPV0nKVuFZNbOcXrcA1uW6Y3HQolaHVIYXGmh18=";
   };
 
   # Default makefile is full of impurities on Darwin. The patch doesn't hurt Linux so I'm leaving it unconditional

pkgs/tools/backup/automysqlbackup/default.nix

···
-{ lib, stdenv, fetchurl, makeWrapper, mysql, mailutils, pbzip2, pigz, bzip2, gzip }:
+{ lib, stdenv, fetchurl, makeWrapper, mariadb, mailutils, pbzip2, pigz, bzip2, gzip }:
 
 stdenv.mkDerivation rec {
   pname = "automysqlbackup";
···
     cp automysqlbackup $out/bin/
     cp automysqlbackup.conf $out/etc/
 
-    wrapProgram $out/bin/automysqlbackup --prefix PATH : ${lib.makeBinPath [ mysql mailutils pbzip2 pigz bzip2 gzip ]}
+    wrapProgram $out/bin/automysqlbackup --prefix PATH : ${lib.makeBinPath [ mariadb mailutils pbzip2 pigz bzip2 gzip ]}
   '';
 
   meta = with lib; {

pkgs/tools/backup/rdedup/default.nix

···
 { lib, stdenv, fetchFromGitHub, rustPlatform, pkg-config, openssl, libsodium
-, llvmPackages, clang, lzma
+, llvmPackages, clang, xz
 , Security }:
 
 rustPlatform.buildRustPackage rec {
···
   ];
 
   nativeBuildInputs = [ pkg-config llvmPackages.libclang clang ];
-  buildInputs = [ openssl libsodium lzma ]
+  buildInputs = [ openssl libsodium xz ]
     ++ (lib.optional stdenv.isDarwin Security);
 
   configurePhase = ''

pkgs/tools/bluetooth/blueman/default.nix

···
 { config, stdenv, lib, fetchurl, intltool, pkg-config, python3Packages, bluez, gtk3
-, obex_data_server, xdg-utils, dnsmasq, dhcp, libappindicator, iproute
+, obex_data_server, xdg-utils, dnsmasq, dhcp, libappindicator, iproute2
 , gnome3, librsvg, wrapGAppsHook, gobject-introspection, autoreconfHook
 , networkmanager, withPulseAudio ? config.pulseaudio or stdenv.isLinux, libpulseaudio, fetchpatch }:
 
 let
   pythonPackages = python3Packages;
-  binPath = lib.makeBinPath [ xdg-utils dnsmasq dhcp iproute ];
+  binPath = lib.makeBinPath [ xdg-utils dnsmasq dhcp iproute2 ];
 
 in stdenv.mkDerivation rec {
   pname = "blueman";
···
   ];
 
   buildInputs = [ bluez gtk3 pythonPackages.python librsvg
-                  gnome3.adwaita-icon-theme iproute libappindicator networkmanager ]
+                  gnome3.adwaita-icon-theme iproute2 libappindicator networkmanager ]
                 ++ pythonPath
                 ++ lib.optional withPulseAudio libpulseaudio;
 

pkgs/tools/compression/pbzx/default.nix

···
-{stdenv, lib, fetchFromGitHub, lzma, xar}:
+{stdenv, lib, fetchFromGitHub, xz, xar}:
 
 stdenv.mkDerivation rec {
   pname = "pbzx";
···
     rev = "v${version}";
     sha256 = "0bwd7wmnhpz1n5p39mh6asfyccj4cm06hwigslcwbb3pdwmvxc90";
   };
-  buildInputs = [ lzma xar ];
+  buildInputs = [ xz xar ];
   buildPhase = ''
     cc pbzx.c -llzma -lxar -o pbzx
   '';

pkgs/tools/compression/pixz/default.nix

···
 {
   lib, stdenv, fetchFromGitHub, autoconf, automake, libtool, pkg-config
   , asciidoc, libxslt, libxml2, docbook_xml_dtd_45, docbook_xsl
-  , libarchive, lzma
+  , libarchive, xz
 }:
 stdenv.mkDerivation rec {
   baseName = "pixz";
···
   buildInputs = [
     autoconf automake libtool asciidoc libxslt libxml2
     docbook_xml_dtd_45 docbook_xsl
-    libarchive lzma
+    libarchive xz
   ];
   preBuild = ''
     echo "XML_CATALOG_FILES='$XML_CATALOG_FILES'"

pkgs/tools/compression/pxz/default.nix

···
-{ lib, stdenv, fetchgit, xz, lzma }:
+{ lib, stdenv, fetchgit, xz }:
 
 let name = "pxz";
     version = "4.999.9beta+git";
···
     sha256 = "0na2kw8cf0qd8l1aywlv9m3xrxnqlcwxfdwp3f7x9vxwqx3k32kc";
   };
 
-  buildInputs = [ lzma ];
+  buildInputs = [ xz ];
 
   patches = [ ./_SC_ARG_MAX.patch ];
 

pkgs/tools/compression/xar/default.nix

···
-{ lib, stdenv, fetchurl, libxml2, lzma, openssl, zlib, bzip2, fts, autoconf }:
+{ lib, stdenv, fetchurl, libxml2, xz, openssl, zlib, bzip2, fts, autoconf }:
 
 stdenv.mkDerivation rec {
   version = "1.6.1";
···
     sha256 = "0ghmsbs6xwg1092v7pjcibmk5wkyifwxw6ygp08gfz25d2chhipf";
   };
 
-  buildInputs = [ libxml2 lzma openssl zlib bzip2 fts autoconf ];
+  buildInputs = [ libxml2 xz openssl zlib bzip2 fts autoconf ];
 
   prePatch = ''
     substituteInPlace configure.ac \

pkgs/tools/filesystems/irods/common.nix

···
-{ lib, stdenv, bzip2, zlib, autoconf, automake, cmake, gnumake, help2man , texinfo, libtool , cppzmq , libarchive, avro-cpp, boost, jansson, zeromq, openssl, pam, libiodbc, kerberos, gcc, libcxx, which, catch2 }:
+{ lib, stdenv, bzip2, zlib, autoconf, automake, cmake, gnumake, help2man , texinfo, libtool , cppzmq , libarchive, avro-cpp, boost, jansson, zeromq, openssl, pam, libiodbc, libkrb5, gcc, libcxx, which, catch2 }:
 
 # Common attributes of irods packages
 
 {
   nativeBuildInputs = [ autoconf automake cmake gnumake help2man texinfo which gcc ];
-  buildInputs = [ bzip2 zlib libtool cppzmq libarchive avro-cpp jansson zeromq openssl pam libiodbc kerberos boost libcxx catch2 ];
+  buildInputs = [ bzip2 zlib libtool cppzmq libarchive avro-cpp jansson zeromq openssl pam libiodbc libkrb5 boost libcxx catch2 ];
 
   cmakeFlags = [
     "-DIRODS_EXTERNALS_FULLPATH_CLANG=${stdenv.cc}"

pkgs/tools/filesystems/irods/default.nix

···
-{ lib, stdenv, fetchFromGitHub, bzip2, zlib, autoconf, automake, cmake, gnumake, help2man , texinfo, libtool , cppzmq , libarchive, avro-cpp_llvm, boost, jansson, zeromq, openssl , pam, libiodbc, kerberos, gcc, libcxx, which, catch2 }:
+{ lib, stdenv, fetchFromGitHub, bzip2, zlib, autoconf, automake, cmake, gnumake, help2man , texinfo, libtool , cppzmq , libarchive, avro-cpp_llvm, boost, jansson, zeromq, openssl , pam, libiodbc, libkrb5, gcc, libcxx, which, catch2 }:
 
 let
   avro-cpp=avro-cpp_llvm;
···
   common = import ./common.nix {
     inherit lib stdenv bzip2 zlib autoconf automake cmake gnumake
             help2man texinfo libtool cppzmq libarchive jansson
-            zeromq openssl pam libiodbc kerberos gcc libcxx
+            zeromq openssl pam libiodbc libkrb5 gcc libcxx
             boost avro-cpp which catch2;
   };
 in rec {

pkgs/tools/filesystems/sasquatch/default.nix

···
 , fetchurl
 , lz4 ? null
 , lz4Support ? false
-, lzma
 , lzo
 , lib, stdenv
 , xz
···
     sha256 = "1xpklm0y43nd9i6jw43y2xh5zvlmj9ar2rvknh0bh7kv8c95aq0d";
   };
 
-  buildInputs = [ lzma lzo xz zlib ]
+  buildInputs = [ xz lzo xz zlib ]
     ++ lib.optional lz4Support lz4;
 
   patches = [ patch ];

pkgs/tools/filesystems/supertag/default.nix

···
+{ lib, rustPlatform, fetchFromGitHub
+, clang, llvmPackages, pkg-config
+, dbus, fuse, sqlite
+}:
+
+rustPlatform.buildRustPackage rec {
+  pname = "supertag";
+  version = "0.1.4";
+
+  src = fetchFromGitHub {
+    owner = "amoffat";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "0jzm7pn38hlr96n0z8gqfsfdbw48y0nnbsgjdq7hpgwmcgvgqdam";
+  };
+
+  cargoSha256 = "1mzmp1jcxgn2swp52r9y7k09fk0z67i1qafzkkzlfxxd10vfr70v";
+
+  LIBCLANG_PATH = "${llvmPackages.libclang}/lib";
+
+  nativeBuildInputs = [ clang pkg-config ];
+  buildInputs = [ dbus fuse sqlite ];
+
+  # The test are requiring extended permissions.
+  doCheck = false;
+
+  meta = with lib; {
+    description = "A tag-based filesystem";
+    longDescription = ''
+      Supertag is a tag-based filesystem, written in Rust, for Linux and MacOS.
+      It provides a tag-based view of your files by removing the hierarchy
+      constraints typically imposed on files and folders. In other words, it
+      allows you to think about your files not as objects stored in folders, but
+      as objects that can be filtered by folders.
+    '';
+    homepage = "https://github.com/amoffat/supertag";
+    license = licenses.agpl3Plus;
+    platforms = [ "i686-linux" "x86_64-linux" ];
+    maintainers = with maintainers; [ oxzi ];
+  };
+}

pkgs/tools/graphics/asymptote/default.nix

···
 { lib, stdenv, fetchFromGitHub, fetchurl, fetchpatch
-, autoreconfHook, bison, glm, yacc, flex
+, autoreconfHook, bison, glm, flex
 , freeglut, ghostscriptX, imagemagick, fftw
 , boehmgc, libGLU, libGL, mesa, ncurses, readline, gsl, libsigsegv
 , python3Packages
···
     autoreconfHook
     bison
     flex
-    yacc
+    bison
     texinfo
   ];
 

pkgs/tools/graphics/graphviz/base.nix

···
 
 { lib, stdenv, fetchFromGitLab, autoreconfHook, pkg-config, cairo, expat, flex
 , fontconfig, gd, gettext, gts, libdevil, libjpeg, libpng, libtool, pango
-, yacc, fetchpatch, xorg ? null, ApplicationServices }:
+, bison, fetchpatch, xorg ? null, ApplicationServices }:
 
 let
   inherit (lib) optional optionals optionalString;
···
   nativeBuildInputs = [ autoreconfHook pkg-config ];
 
   buildInputs = [
-    libpng libjpeg expat yacc libtool fontconfig gd gts libdevil flex pango
+    libpng libjpeg expat bison libtool fontconfig gd gts libdevil flex pango
     gettext
   ] ++ optionals (xorg != null) (with xorg; [ libXrender libXaw libXpm ])
     ++ optionals (stdenv.isDarwin) [ ApplicationServices ];

pkgs/tools/misc/betterdiscordctl/default.nix

···
-{ lib, stdenv, fetchFromGitHub, fetchpatch }:
+{ lib, stdenv, fetchFromGitHub }:
 
 stdenv.mkDerivation rec {
   pname = "betterdiscordctl";
-  version = "1.7.0";
+  version = "1.7.1";
 
   src = fetchFromGitHub {
     owner = "bb010g";
     repo = "betterdiscordctl";
     rev = "v${version}";
-    sha256 = "0qpmm5l8jhm7k0kqblc0bnr9fl4b6z8iddhjar03bb4kqgr962fa";
+    sha256 = "12c3phcfwl4p2jfh22ihm57vxw4nq5kwqirb7y4gzc91swfh5yj1";
   };
-
-  patches = [
-    (fetchpatch { # Required till https://github.com/bb010g/betterdiscordctl/pull/67 is merged upstream.
-      url = "https://github.com/bb010g/betterdiscordctl/pull/67/commits/f1c7170fc2626d9aec4d244977b5a73c401aa1d4.patch";
-      sha256 = "003zqd9ljb9h674sjwjvvdfs7q4cw0p1ydg3lax132vb4vz9k0zi";
-    })
-  ];
 
   preBuild = "sed -i 's/^nix=$/&yes/g;s/^DISABLE_UPGRADE=$/&yes/g' ./betterdiscordctl";
 

pkgs/tools/misc/empty/0.6-Makefile.patch

···
+diff --git a/Makefile b/Makefile
+index 1fe4c41..2c69558 100644
+--- a/Makefile
++++ b/Makefile
+@@ -16,7 +16,7 @@ LIBS =	-lutil
+ PREFIX = /usr/local
+ 
+ all:
+-	${CC} ${CFLAGS} -Wall ${LIBS} -o empty empty.c
++	${CC} ${CFLAGS} -Wall -o empty empty.c ${LIBS}
+ 
+ FreeBSD:	all
+ NetBSD:		all

pkgs/tools/misc/empty/default.nix

···
+{ fetchzip, lib, stdenv, which }:
+
+stdenv.mkDerivation rec {
+  pname = "empty";
+  version = "0.6.21b";
+
+  src = fetchzip {
+    url = "mirror://sourceforge/${pname}/${pname}/${pname}-${version}.tgz";
+    sha256 = "1rkixh2byr70pdxrwr4lj1ckh191rjny1m5xbjsa7nqw1fw6c2xs";
+    stripRoot = false;
+  };
+
+  patches = [
+    ./0.6-Makefile.patch
+  ];
+
+  nativeBuildInputs = [ which ];
+
+  makeFlags = [ "PREFIX=$(out)" ];
+
+  postPatch = ''
+    rm empty
+  '';
+
+  meta = with lib; {
+    homepage = "http://empty.sourceforge.net";
+    description = "A simple tool to automate interactive terminal applications";
+    license = licenses.bsd3;
+    platforms = platforms.all;
+    longDescription = ''
+      The empty utility provides an interface to execute and/or interact with
+      processes under pseudo-terminal sessions (PTYs). This tool is definitely
+      useful in programming of shell scripts designed to communicate with
+      interactive programs like telnet, ssh, ftp, etc. In some cases empty can
+      be the simplest replacement for TCL/expect or other similar programming
+      tools because empty:
+
+      - can be easily invoked directly from shell prompt or script
+      - does not use TCL, Perl, PHP, Python or anything else as an underlying language
+      - is written entirely in C
+      - has small and simple source code
+      - can easily be ported to almost all UNIX-like systems
+    '';
+    maintainers = [ maintainers.djwf ];
+  };
+}

pkgs/tools/misc/fwup/default.nix

···
 , libarchive
 , libconfuse
 , libsodium
-, lzma
+, xz
 , zlib
 , coreutils
 , dosfstools
···
     libarchive
     libconfuse
     libsodium
-    lzma
+    xz
     zlib
   ]
     ++ lib.optionals stdenv.isDarwin [

pkgs/tools/misc/grit/default.nix

···
+{ lib, buildGoModule, fetchFromGitHub }:
+
+buildGoModule rec {
+  pname = "grit";
+  version = "0.2.0";
+
+  src = fetchFromGitHub {
+    owner = "climech";
+    repo = "grit";
+    rev = "v${version}";
+    sha256 = "0v4i8xdf1pgkmwad5jb6n6s4rx48zk57wij0ppzg6zb725wy7r8a";
+  };
+
+  vendorSha256 = "0a1lqfn710fgvrvbimd92102fhjs1wa7r8i0l7s5m7jxks629hw8";
+
+  meta = with lib; {
+    description = "A multitree-based personal task manager";
+    homepage = "https://github.com/climech/grit";
+    license = licenses.mit;
+    platforms = platforms.unix;
+    maintainers = [ maintainers.ivar ];
+  };
+}

pkgs/tools/misc/mcfly/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "mcfly";
-  version = "0.5.5";
+  version = "0.5.6";
 
   src = fetchFromGitHub {
     owner = "cantino";
     repo = "mcfly";
     rev = "v${version}";
-    sha256 = "sha256-4slE/11N9L9Q45w/LF5rNkOZbADjY1n4NxdoNlXPdo8=";
+    sha256 = "sha256-x2cED+WEc50RB8BxiDEm/XnauT1RqqGjSIdL5MMaFBY=";
   };
 
   postInstall = ''
···
     install -Dm644 -t $out/share/mcfly mcfly.fish
   '';
 
-  cargoSha256 = "sha256-MlhltJh+Z2GFHm+qCD8UDEvY+W8EprxVoBv/kj4v1Qc=";
+  cargoSha256 = "sha256-JCV1cj+RncY/myVJTJ5fNkVqTITqGusA71tv7zGG9Uw=";
 
   meta = with lib; {
     homepage = "https://github.com/cantino/mcfly";

pkgs/tools/misc/osinfo-db-tools/default.nix

···
 { lib, stdenv, fetchurl, pkg-config, meson, ninja, gettext, glib, libxml2, perl, python3
-, libxslt, libarchive, bzip2, lzma, json-glib, libsoup
+, libxslt, libarchive, bzip2, xz, json-glib, libsoup
 }:
 
 stdenv.mkDerivation rec {
···
   };
 
   nativeBuildInputs = [ meson ninja pkg-config gettext perl python3 ];
-  buildInputs = [ glib json-glib libxml2 libxslt libarchive bzip2 lzma libsoup ];
+  buildInputs = [ glib json-glib libxml2 libxslt libarchive bzip2 xz libsoup ];
 
   meta = with lib; {
     description = "Tools for managing the osinfo database";

pkgs/tools/misc/ostree/default.nix

···
 , libarchive
 , libcap
 , bzip2
-, yacc
+, bison
 , libxslt
 , docbook-xsl-nons
 , docbook_xml_dtd_42
···
     gobject-introspection
     which
     makeWrapper
-    yacc
+    bison
     libxslt
     docbook-xsl-nons
     docbook_xml_dtd_42

pkgs/tools/misc/ovh-ttyrec/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "ovh-ttyrec";
-  version = "1.1.6.6";
+  version = "1.1.6.7";
 
   src = fetchFromGitHub {
     owner = "ovh";
     repo = "ovh-ttyrec";
     rev = "v${version}";
-    sha256 = "176g3k2pzw6zpvmcc2f8idn6vhlygf7lfzxvrhysav2izc5dd130";
+    sha256 = "sha256-OkSs0Cu79u53+fN57px48f6kJKuOJLjGUar+lLTdUJU=";
   };
 
   nativeBuildInputs = [ zstd ];

pkgs/tools/misc/polar/Gemfile

···
+source 'https://rubygems.org'
+
+gem 'google-protobuf'
+gem 'libusb'
+gem 'rubyserial'
+gem 'nokogiri'
+

pkgs/tools/misc/polar/Gemfile.lock

···
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ffi (1.15.0)
+    google-protobuf (3.15.6)
+    libusb (0.6.4)
+      ffi (~> 1.0)
+      mini_portile2 (~> 2.1)
+    mini_portile2 (2.5.0)
+    nokogiri (1.11.2)
+      mini_portile2 (~> 2.5.0)
+      racc (~> 1.4)
+    racc (1.5.2)
+    rubyserial (0.6.0)
+      ffi (~> 1.9, >= 1.9.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  google-protobuf
+  libusb
+  nokogiri
+  rubyserial
+
+BUNDLED WITH
+   2.1.4

pkgs/tools/misc/polar/default.nix

···
+{ lib, stdenv, fetchFromGitHub, ruby, bundlerEnv }:
+let
+
+  # To create Gemfile.lock and gemset.nix
+  # > nix-shell -p bundix bundler zlib
+  # > bundle install
+  # > bundix
+  gems = bundlerEnv {
+    name = "polar-env";
+    inherit ruby;
+    gemdir = ./.;
+  };
+
+in
+stdenv.mkDerivation rec {
+
+  pname = "polar";
+  # The package has no releases so let's use the latest commit
+  version = "unstable-2021-01-12";
+
+  src = fetchFromGitHub {
+    owner = "cmaion";
+    repo = pname;
+    rev = "be15f5f897f8a919dd639009873147dca2a9cea0";
+    sha256 = "0gqkqfrqnrsy6avg372xwqj22yz8g6r2hnzbw6197b1rf7zr1il7";
+  };
+
+  prePatch = ''
+    for script in polar_*
+    do
+      substituteInPlace $script --replace "#{File.dirname(__FILE__)}/lib" "$out/lib/polar"
+    done
+  '';
+  buildInputs = [ gems ruby ];
+
+  # See: https://nixos.wiki/wiki/Packaging/Ruby
+  #
+  # Put library content under lib/polar and the raw scripts under share/polar.
+  # Then, wrap the scripts so that they use the correct ruby environment and put
+  # these wrapped executables under bin.
+  installPhase = ''
+    install -Dm644 -t $out/etc/udev/rules.d ./pkg/99-polar.rules
+    mkdir -p $out/{bin,lib/polar,share/polar}
+    cp -r lib/* $out/lib/polar/
+    for script in ./polar_*
+    do
+      raw="$out/share/polar/$script"
+      bin="$out/bin/$script"
+      cp "$script" "$raw"
+      cat > $bin <<EOF
+#!/bin/sh -e
+exec ${gems}/bin/bundle exec ${ruby}/bin/ruby "$raw" "\$@"
+EOF
+      chmod +x $bin
+    done
+  '';
+
+  meta = with lib; {
+    description = "Command-line tools to interact with Polar watches";
+    longDescription = ''
+      A set of command line tools written in Ruby to interact with Polar watches
+      and decode raw data files.
+
+      Udev rules can be added as:
+
+        services.udev.packages = [ pkgs.polar ]
+    '';
+    homepage = "https://github.com/cmaion/polar";
+    license = licenses.gpl3Only;
+    maintainers = with maintainers; [ jluttine ];
+    platforms = platforms.linux;
+  };
+}

pkgs/tools/misc/polar/gemset.nix

···
+{
+  ffi = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0nq1fb3vbfylccwba64zblxy96qznxbys5900wd7gm9bpplmf432";
+      type = "gem";
+    };
+    version = "1.15.0";
+  };
+  google-protobuf = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1ak5yqqhr04b4x0axzvpw1xzwmxmfcw0gf4r1ijixv15kidhsj3z";
+      type = "gem";
+    };
+    version = "3.15.6";
+  };
+  libusb = {
+    dependencies = ["ffi" "mini_portile2"];
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "005q4f3bi68yapza1vxamgwz2gpix2akci52s4yvr03hsxi137a6";
+      type = "gem";
+    };
+    version = "0.6.4";
+  };
+  mini_portile2 = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1hdbpmamx8js53yk3h8cqy12kgv6ca06k0c9n3pxh6b6cjfs19x7";
+      type = "gem";
+    };
+    version = "2.5.0";
+  };
+  nokogiri = {
+    dependencies = ["mini_portile2" "racc"];
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0b51df8fwadak075cvi17w0nch6qz1r66564qp29qwfj67j9qp0p";
+      type = "gem";
+    };
+    version = "1.11.2";
+  };
+  racc = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "178k7r0xn689spviqzhvazzvxfq6fyjldxb3ywjbgipbfi4s8j1g";
+      type = "gem";
+    };
+    version = "1.5.2";
+  };
+  rubyserial = {
+    dependencies = ["ffi"];
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1vj5yan6srbvkf5vfp9d9b9z8wyygd0zxcy54c35yhkjl6kwd22q";
+      type = "gem";
+    };
+    version = "0.6.0";
+  };
+}

pkgs/tools/misc/qmk/default.nix

···
+{ lib
+, python3
+, fetchpatch
+}:
+
+python3.pkgs.buildPythonApplication rec {
+  pname = "qmk";
+  version = "0.0.45";
+
+  src = python3.pkgs.fetchPypi {
+    inherit pname version;
+    sha256 = "43f297f36b21d68c34c5efa0ce1449dddb2e28753f80939cadf761ee7a2a0901";
+  };
+
+  patches = [
+    # https://github.com/qmk/qmk_cli/pull/48
+    (fetchpatch {
+      name = "remove-unused-install-requires.patch";
+      url = "https://github.com/qmk/qmk_cli/commit/75b6ada1feccfa5a9bc2bb07a4cc749ef40d02dd.patch";
+      sha256 = "0lwi1dz35p07vha5gwq2jxm5q49vm99ix4jyhd6g6ypqbq1qiwc8";
+    })
+  ];
+
+  nativeBuildInputs = with python3.pkgs; [
+    setuptools-scm
+  ];
+
+  propagatedBuildInputs = with python3.pkgs; [
+    milc
+  ];
+
+  # no tests implemented
+  doCheck = false;
+
+  meta = with lib; {
+    description = "A program to help users work with QMK Firmware";
+    homepage = "https://github.com/qmk/qmk_cli";
+    license = licenses.mit;
+    maintainers = with maintainers; [ bhipple ];
+  };
+}

pkgs/tools/misc/svtplay-dl/default.nix

···
 let
 
   inherit (python3Packages)
-    python nose pycrypto pyyaml requests mock python-dateutil setuptools;
+    python nose cryptography pyyaml requests mock python-dateutil setuptools;
 
 in stdenv.mkDerivation rec {
   pname = "svtplay-dl";
···
     sha256 = "00pz5vv39qjsw67fdlj6942371lyvv368lc82z17nnh723ck54yy";
   };
 
-  pythonPaths = [ pycrypto pyyaml requests ];
+  pythonPaths = [ cryptography pyyaml requests ];
   buildInputs = [ python perl nose mock python-dateutil setuptools ] ++ pythonPaths;
   nativeBuildInputs = [ gitMinimal zip makeWrapper ];
 

pkgs/tools/misc/tz/default.nix

···
 
 buildGoModule rec {
   pname = "tz";
-  version = "0.4";
+  version = "0.5";
 
   src = fetchFromGitHub {
     owner = "oz";
     repo = "tz";
     rev = "v${version}";
-    sha256 = "sha256-36nTau7xjABdeUOioHar28cuawFWW3DBaDH0YAvdufI=";
+    sha256 = "sha256-OwjhV3n1B1yQTNYm4VOW500t0524g85YYiOAAu9yPeo=";
   };
 
   vendorSha256 = "sha256-Soa87I7oMa34LjYKxNAz9Limi0kQ6JUtb/zI4G7yZnw=";

pkgs/tools/misc/uutils-coreutils/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "uutils-coreutils";
-  version = "0.0.4";
+  version = "0.0.6";
 
   src = fetchFromGitHub {
     owner = "uutils";
     repo = "coreutils";
     rev = version;
-    sha256 = "sha256-z5lDKJpFxXDCQq+0Da/63GGoUXacy5TSn+1gJiMvicc=";
+    sha256 = "sha256-dnswE/DU2jCfxWW10Ctjw8woktwWZqyd3E9IuKkle1M=";
   };
 
   postPatch = ''
···
   cargoDeps = rustPlatform.fetchCargoTarball {
     inherit src;
     name = "${pname}-${version}";
-    hash = "sha256-x/nn2JNe8x+I0G2Vbr2PZAHCghwLBDhKAhkHPQFeL0M=";
+    hash = "sha256-92BHPSVIPZLn399AcaJJjRq2WkxzDm8knKN3FIdAxAA=";
   };
 
   nativeBuildInputs = [ rustPlatform.cargoSetupHook sphinx ];

pkgs/tools/misc/uwuify/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "uwuify";
-  version = "0.2.1";
+  version = "0.2.2";
 
   src = fetchFromGitHub {
     owner = "Daniel-Liu-c0deb0t";
     repo = "uwu";
     rev = "v${version}";
-    sha256 = "sha256-tPmLqgrWi7wDoMjMrxodKp4S0ICwV9Kp7Pa151rHho0=";
+    sha256 = "sha256-MzXObbxccwEG7egmQMCdhUukGqZS+NgbYwZjTaqME7I=";
   };
 
-  cargoSha256 = "sha256-HUP6OEvoGJ/BtAl+yuGzqEp1bsxfGAh0UJtXz9/ZiK8=";
+  cargoSha256 = "sha256-iyoGLFIfHToOwqEb5lQ1nXR0W1gLOVMfvw39LX6ib+U=";
   buildInputs = lib.optionals stdenv.isDarwin [ libiconv ];
 
   meta = with lib; {

pkgs/tools/misc/yle-dl/default.nix

···
 
 python3Packages.buildPythonApplication rec {
   pname = "yle-dl";
-  version = "20201022";
+  version = "20210212";
 
   src = fetchFromGitHub {
     owner = "aajanki";
     repo = "yle-dl";
     rev = version;
-    sha256 = "0p56pb3wxdzqgs4fsh4hn06xs0mgzgznqqr0bn2vkkkibnkr1asp";
+    sha256 = "sha256-0JnigYmslQ/7KsQAFg3AaWPAU/tD1lS7lF6OCcv/ze4=";
   };
 
   propagatedBuildInputs = with python3Packages; [

pkgs/tools/networking/ddclient/default.nix

···
-{ lib, fetchurl, perlPackages, iproute, perl }:
+{ lib, fetchurl, perlPackages, iproute2, perl }:
 
 perlPackages.buildPerlPackage rec {
   pname = "ddclient";
···
     touch Makefile.PL
     substituteInPlace ddclient \
       --replace 'in the output of ifconfig' 'in the output of ip addr show' \
-      --replace 'ifconfig -a' '${iproute}/sbin/ip addr show' \
-      --replace 'ifconfig $arg' '${iproute}/sbin/ip addr show $arg' \
+      --replace 'ifconfig -a' '${iproute2}/sbin/ip addr show' \
+      --replace 'ifconfig $arg' '${iproute2}/sbin/ip addr show $arg' \
       --replace '/usr/bin/perl' '${perl}/bin/perl' # Until we get the patchShebangs fixed (issue #55786) we need to patch this manually
   '';
 

pkgs/tools/networking/dhcp/default.nix

···
-{ stdenv, fetchurl, perl, file, nettools, iputils, iproute, makeWrapper
+{ stdenv, fetchurl, perl, file, nettools, iputils, iproute2, makeWrapper
 , coreutils, gnused, openldap ? null
 , buildPackages, lib
 }:
···
 
       cp client/scripts/linux $out/sbin/dhclient-script
       substituteInPlace $out/sbin/dhclient-script \
-        --replace /sbin/ip ${iproute}/sbin/ip
+        --replace /sbin/ip ${iproute2}/sbin/ip
       wrapProgram "$out/sbin/dhclient-script" --prefix PATH : \
         "${nettools}/bin:${nettools}/sbin:${iputils}/bin:${coreutils}/bin:${gnused}/bin"
     '';

pkgs/tools/networking/gobgp/default.nix

···
 
 buildGoModule rec {
   pname = "gobgp";
-  version = "2.25.0";
+  version = "2.26.0";
 
   src = fetchFromGitHub {
     owner = "osrg";
     repo = "gobgp";
     rev = "v${version}";
-    sha256 = "sha256-/aezkwg/BVyNZQ9Vb6rz0OcD9kzjGRMxFvDeFtwr71Y=";
+    sha256 = "sha256-sQmTIjBvCzd8ZXAayhPdRSRwBovH8BFRwazusSE52IE=";
   };
 
   vendorSha256 = "sha256-PWm7XnO6LPaU8g8ymmqRkQv2KSX9kLv9RVaa000mrTY=";

pkgs/tools/networking/gvpe/default.nix

···
-{ lib, stdenv, fetchurl, openssl, gmp, zlib, iproute, nettools }:
+{ lib, stdenv, fetchurl, openssl, gmp, zlib, iproute2, nettools }:
 
 stdenv.mkDerivation rec {
   pname = "gvpe";
···
     ];
 
   preBuild = ''
-    sed -e 's@"/sbin/ifconfig.*"@"${iproute}/sbin/ip link set $IFNAME address $MAC mtu $MTU"@' -i src/device-linux.C
+    sed -e 's@"/sbin/ifconfig.*"@"${iproute2}/sbin/ip link set $IFNAME address $MAC mtu $MTU"@' -i src/device-linux.C
     sed -e 's@/sbin/ifconfig@${nettools}/sbin/ifconfig@g' -i src/device-*.C
   '';
 

pkgs/tools/networking/i2pd/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "i2pd";
-  version = "2.36.0";
+  version = "2.37.0";
 
   src = fetchFromGitHub {
     owner = "PurpleI2P";
     repo = pname;
     rev = version;
-    sha256 = "sha256-f1ew2i/tgRdIAo/oOgFIFquKve+ImRzqoZqmlzfwpz8=";
+    sha256 = "sha256-//ootg0RZR2vzO702jGXuJ5qGMO49GSG0Lw6dKzGGt8=";
   };
 
   buildInputs = with lib; [ boost zlib openssl ]

pkgs/tools/networking/libreswan/default.nix

···
 { lib, stdenv, fetchurl, makeWrapper,
   pkg-config, systemd, gmp, unbound, bison, flex, pam, libevent, libcap_ng, curl, nspr,
-  bash, iproute, iptables, procps, coreutils, gnused, gawk, nss, which, python3,
+  bash, iproute2, iptables, procps, coreutils, gnused, gawk, nss, which, python3,
   docs ? false, xmlto, libselinux, ldns
   }:
 
 let
   binPath = lib.makeBinPath [
-    bash iproute iptables procps coreutils gnused gawk nss.tools which python3
+    bash iproute2 iptables procps coreutils gnused gawk nss.tools which python3
   ];
 in
 
···
     pkg-config
   ];
 
-  buildInputs = [ bash iproute iptables systemd coreutils gnused gawk gmp unbound pam libevent
+  buildInputs = [ bash iproute2 iptables systemd coreutils gnused gawk gmp unbound pam libevent
                   libcap_ng curl nspr nss python3 ldns ]
                 ++ lib.optional docs xmlto
                 ++ lib.optional stdenv.isLinux libselinux;

pkgs/tools/networking/linkchecker/default.nix

···
     ConfigArgParse
     argcomplete
     beautifulsoup4
+    pyopenssl
     dnspython
     pyxdg
     requests

pkgs/tools/networking/maxscale/default.nix

···
 { lib, stdenv, fetchFromGitHub, cmake, pkg-config, glibc
-, bison, curl, flex, gperftools, jansson, jemalloc, kerberos, lua, libmysqlclient
+, bison, curl, flex, gperftools, jansson, jemalloc, libkrb5, lua, libmysqlclient
 , ncurses, openssl, pcre, pcre2, perl, rabbitmq-c, sqlite, tcl
 , libaio, libedit, libtool, libui, libuuid, zlib
 }:
···
   nativeBuildInputs = [ cmake pkg-config ];
 
   buildInputs = [
-    bison curl flex gperftools jansson jemalloc kerberos lua libmysqlclient
+    bison curl flex gperftools jansson jemalloc libkrb5 lua libmysqlclient
     ncurses openssl pcre pcre2 perl rabbitmq-c sqlite tcl
     libaio libedit libtool libui libuuid zlib
   ];

pkgs/tools/networking/miniupnpd/default.nix

···
 { stdenv, lib, fetchurl, iptables, libuuid, pkg-config
-, which, iproute, gnused, coreutils, gawk, makeWrapper
+, which, iproute2, gnused, coreutils, gawk, makeWrapper
 }:
 
 let
-  scriptBinEnv = lib.makeBinPath [ which iproute iptables gnused coreutils gawk ];
+  scriptBinEnv = lib.makeBinPath [ which iproute2 iptables gnused coreutils gawk ];
 in
 stdenv.mkDerivation rec {
   name = "miniupnpd-2.1.20190502";

pkgs/tools/networking/miredo/default.nix

···
-{ lib, stdenv, fetchurl, nettools, iproute, judy }:
+{ lib, stdenv, fetchurl, nettools, iproute2, judy }:
 
 stdenv.mkDerivation rec {
   version = "1.2.6";
···
     substituteInPlace misc/client-hook.bsd \
       --replace '/sbin/route' '${nettools}/bin/route' \
       --replace '/sbin/ifconfig' '${nettools}/bin/ifconfig'
-    substituteInPlace misc/client-hook.iproute --replace '/sbin/ip' '${iproute}/bin/ip'
+    substituteInPlace misc/client-hook.iproute --replace '/sbin/ip' '${iproute2}/bin/ip'
   '';
 
   configureFlags = [ "--with-Judy" ];

pkgs/tools/networking/netboot/default.nix

···
-{ lib, stdenv, fetchurl, yacc, lzo, db4 }:
+{ lib, stdenv, fetchurl, bison, lzo, db4 }:
 
 stdenv.mkDerivation rec {
   name = "netboot-0.10.2";
···
     sha256 = "09w09bvwgb0xzn8hjz5rhi3aibysdadbg693ahn8rylnqfq4hwg0";
   };
 
-  buildInputs = [ yacc lzo db4 ];
+  buildInputs = [ bison lzo db4 ];
 
   hardeningDisable = [ "format" ];
 

pkgs/tools/networking/nfdump/default.nix

···
 { lib, stdenv, fetchFromGitHub
 , autoconf, automake, libtool, pkg-config
-, bzip2, libpcap, flex, yacc }:
+, bzip2, libpcap, flex, bison }:
 
 let version = "1.6.22"; in
 
···
     sha256 = "14x2k85ard1kp99hhd90zsmvyw24g03m84rn13gb4grm9gjggzrj";
   };
 
-  nativeBuildInputs = [ autoconf automake flex libtool pkg-config yacc ];
+  nativeBuildInputs = [ autoconf automake flex libtool pkg-config bison ];
   buildInputs = [ bzip2 libpcap ];
 
   preConfigure = ''

pkgs/tools/networking/openssh/common.nix

···
 , pam
 , etcDir ? null
 , withKerberos ? true
-, kerberos
+, libkrb5
 , libfido2
 , withFIDO ? stdenv.hostPlatform.isUnix && !stdenv.hostPlatform.isMusl
 , linkOpenssl ? true
···
     '';
 
   nativeBuildInputs = [ pkg-config ]
-    # This is not the same as the kerberos from the inputs! pkgs.kerberos is
+    # This is not the same as the libkrb5 from the inputs! pkgs.libkrb5 is
     # needed here to access krb5-config in order to cross compile. See:
     # https://github.com/NixOS/nixpkgs/pull/107606
-    ++ optional withKerberos pkgs.kerberos
+    ++ optional withKerberos pkgs.libkrb5
     ++ extraNativeBuildInputs;
   buildInputs = [ zlib openssl libedit ]
     ++ optional withFIDO libfido2
-    ++ optional withKerberos kerberos
+    ++ optional withKerberos libkrb5
     ++ optional stdenv.isLinux pam;
 
   preConfigure = ''
···
   # Kerberos can be found either by krb5-config or by fall-back shell
   # code in openssh's configure.ac. Neither of them support static
   # build, but patching code for krb5-config is simpler, so to get it
-  # into PATH, kerberos.dev is added into buildInputs.
+  # into PATH, libkrb5.dev is added into buildInputs.
   + optionalString stdenv.hostPlatform.isStatic ''
     sed -i "s,PKGCONFIG --libs,PKGCONFIG --libs --static,g" configure
     sed -i 's#KRB5CONF --libs`#KRB5CONF --libs` -lkrb5support -lkeyutils#g' configure
···
     (if stdenv.isLinux then "--with-pam" else "--without-pam")
   ] ++ optional (etcDir != null) "--sysconfdir=${etcDir}"
     ++ optional withFIDO "--with-security-key-builtin=yes"
-    ++ optional withKerberos (assert kerberos != null; "--with-kerberos5=${kerberos}")
+    ++ optional withKerberos (assert libkrb5 != null; "--with-kerberos5=${libkrb5}")
     ++ optional stdenv.isDarwin "--disable-libutil"
     ++ optional (!linkOpenssl) "--without-openssl";
 

pkgs/tools/networking/openvpn/default.nix

···
 , pkg-config
 , makeWrapper
 , runtimeShell
-, iproute
+, iproute2
 , lzo
 , openssl
 , pam
···
 
         buildInputs = [ lzo openssl ]
           ++ optional stdenv.isLinux pam
-          ++ optional withIpRoute iproute
+          ++ optional withIpRoute iproute2
           ++ optional useSystemd systemd
           ++ optional pkcs11Support pkcs11helper;
 
         configureFlags = optionals withIpRoute [
           "--enable-iproute2"
-          "IPROUTE=${iproute}/sbin/ip"
+          "IPROUTE=${iproute2}/sbin/ip"
         ]
         ++ optional useSystemd "--enable-systemd"
         ++ optional pkcs11Support "--enable-pkcs11"
···
         '' + optionalString useSystemd ''
           install -Dm555 ${update-resolved} $out/libexec/update-systemd-resolved
           wrapProgram $out/libexec/update-systemd-resolved \
-            --prefix PATH : ${makeBinPath [ runtimeShell iproute systemd util-linux ]}
+            --prefix PATH : ${makeBinPath [ runtimeShell iproute2 systemd util-linux ]}
         '';
 
         enableParallelBuilding = true;

pkgs/tools/networking/openvpn/update-systemd-resolved.nix

···
 { lib, stdenv, fetchFromGitHub
 , makeWrapper
-, iproute, systemd, coreutils, util-linux }:
+, iproute2, systemd, coreutils, util-linux }:
 
 stdenv.mkDerivation rec {
   pname = "update-systemd-resolved";
···
 
   installPhase = ''
     wrapProgram $out/libexec/openvpn/update-systemd-resolved \
-      --prefix PATH : ${lib.makeBinPath [ iproute systemd coreutils util-linux ]}
+      --prefix PATH : ${lib.makeBinPath [ iproute2 systemd coreutils util-linux ]}
   '';
 
   meta = with lib; {

pkgs/tools/networking/pptp/default.nix

···
-{ lib, stdenv, fetchurl, perl, ppp, iproute }:
+{ lib, stdenv, fetchurl, perl, ppp, iproute2 }:
 
 stdenv.mkDerivation rec {
   pname = "pptp";
···
   '';
 
   preConfigure = ''
-    makeFlagsArray=( IP=${iproute}/bin/ip PPPD=${ppp}/sbin/pppd \
+    makeFlagsArray=( IP=${iproute2}/bin/ip PPPD=${ppp}/sbin/pppd \
                      BINDIR=$out/sbin MANDIR=$out/share/man/man8 \
                      PPPDIR=$out/etc/ppp )
   '';

pkgs/tools/networking/saldl/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "saldl";
-  version = "40";
+  version = "41";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
     rev = "v${version}";
-    sha256 = "19ajci5h5gdnrvwf0l7xy5s58z2di68rrvcmqpsmpp4lfr37rk2l";
+    sha256 = "sha256-PAX2MUyBWWU8kGkaeoCJteidgszh7ipwDJbrLXzVsn0=";
   };
 
   nativeBuildInputs = [

pkgs/tools/networking/shorewall/default.nix

···
 , fetchurl
 , gnugrep
 , gnused
-, iproute
+, iproute2
 , ipset
 , iptables
 , perl
···
 let
   PATH = lib.concatStringsSep ":"
            [ "${coreutils}/bin"
-             "${iproute}/bin"
+             "${iproute2}/bin"
              "${iptables}/bin"
              "${ipset}/bin"
              "${ebtables}/bin"
···
 
   buildInputs = [
     coreutils
-    iproute
+    iproute2
     ipset
     iptables
     ebtables

pkgs/tools/networking/snabb/default.nix

···
-{ lib, stdenv, fetchFromGitHub, bash, makeWrapper, git, mysql, diffutils, which, coreutils, procps, nettools
+{ lib, stdenv, fetchFromGitHub, bash, makeWrapper, git, mariadb, diffutils, which, coreutils, procps, nettools
 ,supportOpenstack ? true
 }:
 
···
     done
   '' + optionalString supportOpenstack ''
     # We need a way to pass $PATH to the scripts
-    sed -i '2iexport PATH=${git}/bin:${mysql}/bin:${which}/bin:${procps}/bin:${coreutils}/bin' src/program/snabbnfv/neutron_sync_master/neutron_sync_master.sh.inc
+    sed -i '2iexport PATH=${git}/bin:${mariadb}/bin:${which}/bin:${procps}/bin:${coreutils}/bin' src/program/snabbnfv/neutron_sync_master/neutron_sync_master.sh.inc
     sed -i '2iexport PATH=${git}/bin:${coreutils}/bin:${diffutils}/bin:${nettools}/bin' src/program/snabbnfv/neutron_sync_agent/neutron_sync_agent.sh.inc
   '';
 

pkgs/tools/networking/vtun/default.nix

···
-{ lib, stdenv, fetchurl, fetchpatch, openssl, lzo, zlib, yacc, flex }:
+{ lib, stdenv, fetchurl, fetchpatch, openssl, lzo, zlib, bison, flex }:
 
 stdenv.mkDerivation rec {
   name = "vtun-3.0.4";
···
     sed -i -e 's/-m 755//' -e 's/-o root -g 0//' Makefile.in
     sed -i '/strip/d' Makefile.in
   '';
-  buildInputs = [ lzo openssl zlib yacc flex ];
+  buildInputs = [ lzo openssl zlib bison flex ];
 
   configureFlags = [
     "--with-lzo-headers=${lzo}/include/lzo"

pkgs/tools/networking/wget2/default.nix

···
 , libhsts
 , libidn2
 , libpsl
-, lzma
+, xz
 , nghttp2
 , sslSupport ? true
 , openssl
···
 
   nativeBuildInputs = [ autoreconfHook flex lzip pkg-config python3 texinfo ];
 
-  buildInputs = [ brotli bzip2 gpgme libhsts libidn2 libpsl lzma nghttp2 pcre2 zlib zstd ]
+  buildInputs = [ brotli bzip2 gpgme libhsts libidn2 libpsl xz nghttp2 pcre2 zlib zstd ]
     ++ lib.optional sslSupport openssl;
 
   # TODO: include translation files

pkgs/tools/networking/wicd/default.nix

···
 { lib, stdenv, fetchurl, python2Packages
 , wpa_supplicant, dhcp, dhcpcd, wirelesstools
-, nettools, openresolv, iproute, iputils }:
+, nettools, openresolv, iproute2, iputils }:
 
 let
   inherit (python2Packages) python pygobject2 dbus-python pyGtkGlade pycairo;
···
 
     substituteInPlace in/scripts=wicd.in --subst-var-by TEMPLATE-DEFAULT $out/share/other/dhclient.conf.template.default
 
-    sed -i "2iexport PATH=${lib.makeBinPath [ python wpa_supplicant dhcpcd dhcp wirelesstools nettools nettools iputils openresolv iproute ]}\$\{PATH:+:\}\$PATH" in/scripts=wicd.in
+    sed -i "2iexport PATH=${lib.makeBinPath [ python wpa_supplicant dhcpcd dhcp wirelesstools nettools nettools iputils openresolv iproute2 ]}\$\{PATH:+:\}\$PATH" in/scripts=wicd.in
     sed -i "3iexport PYTHONPATH=$(toPythonPath $out):$(toPythonPath ${pygobject2}):$(toPythonPath ${dbus-python})\$\{PYTHONPATH:+:\}\$PYTHONPATH" in/scripts=wicd.in
     sed -i "2iexport PATH=${python}/bin\$\{PATH:+:\}\$PATH" in/scripts=wicd-client.in
     sed -i "3iexport PYTHONPATH=$(toPythonPath $out):$(toPythonPath ${pyGtkGlade})/gtk-2.0:$(toPythonPath ${pygobject2}):$(toPythonPath ${pygobject2})/gtk-2.0:$(toPythonPath ${pycairo}):$(toPythonPath ${dbus-python})\$\{PYTHONPATH:+:\}\$PYTHONPATH" in/scripts=wicd-client.in

pkgs/tools/networking/wireguard-tools/default.nix

···
 , fetchzip
 , nixosTests
 , iptables
-, iproute
+, iproute2
 , makeWrapper
 , openresolv
 , procps
···
       --replace /usr/bin $out/bin
   '' + lib.optionalString stdenv.isLinux ''
     for f in $out/bin/*; do
-      wrapProgram $f --prefix PATH : ${lib.makeBinPath [ procps iproute iptables openresolv ]}
+      wrapProgram $f --prefix PATH : ${lib.makeBinPath [ procps iproute2 iptables openresolv ]}
     done
   '' + lib.optionalString stdenv.isDarwin ''
     for f in $out/bin/*; do

pkgs/tools/networking/ytcc/default.nix

···
 
 python3Packages.buildPythonApplication rec {
   pname = "ytcc";
-  version = "2.1.0";
+  version = "2.2.0";
 
   src = fetchFromGitHub {
     owner = "woefe";
     repo = "ytcc";
     rev = "v${version}";
-    sha256 = "04l5bfyq53r8803q24bfw49ji7jx8z9irhhh30cvq2va1ywwd4ww";
+    sha256 = "1rhnrmanad10zy2as9q5wjfjlk18f51vf801syyfgxvk0pdcsk6w";
   };
 
   nativeBuildInputs = [ gettext ];

pkgs/tools/networking/zerotierone/default.nix

···
-{ lib, stdenv, buildPackages, fetchFromGitHub, openssl, lzo, zlib, iproute, ronn }:
+{ lib, stdenv, buildPackages, fetchFromGitHub, openssl, lzo, zlib, iproute2, ronn }:
 
 stdenv.mkDerivation rec {
   pname = "zerotierone";
···
 
 
   nativeBuildInputs = [ ronn ];
-  buildInputs = [ openssl lzo zlib iproute ];
+  buildInputs = [ openssl lzo zlib iproute2 ];
 
   enableParallelBuilding = true;
 

pkgs/tools/package-management/appimagekit/default.nix

···
   appimagekit_src = fetchFromGitHub {
     owner = "AppImage";
     repo = "AppImageKit";
-    rev = "b0859501df61cde198b54a317c03b41dbafc98b1";
-    sha256 = "0qqg79jw9w9rs8c2w3lla4kz62ihafrf7jm370pp1dl8y2i81jzg";
+    rev = "8bbf694455d00f48d835f56afaa1dabcd9178ba6";
+    sha256 = "sha256-pqg+joomC5CI9WdKP/h/XKPsruMgZEaIOjPLOqnNPZw=";
+    fetchSubmodules = true;
   };
 
-  # squashfuse adapted to nix from cmake experession in "${appimagekit_src}/cmake/dependencies.cmake"
+  # squashfuse adapted to nix from cmake experession in "${appimagekit_src}/lib/libappimage/cmake/dependencies.cmake"
   appimagekit_squashfuse = squashfuse.overrideAttrs (attrs: rec {
-    name = "squashfuse-${version}";
-    version = "20161009";
+    pname = "squashfuse";
+    version = "unstable-2016-10-09";
 
     src = fetchFromGitHub {
       owner = "vasi";
-      repo  = "squashfuse";
-      rev   = "1f980303b89c779eabfd0a0fdd36d6a7a311bf92";
-      sha256 = "0lrw9ff8k15l34wjwyllw3i35hl0cms97jj2hpnr2q8ipgxpb5q5";
+      repo  = pname;
+      rev = "1f980303b89c779eabfd0a0fdd36d6a7a311bf92";
+      sha256 = "sha256-BZd1+7sRYZHthULKk3RlgMIy4uCUei45GbSEiZxLPFM=";
     };
 
     patches = [
-      "${appimagekit_src}/squashfuse.patch"
-      "${appimagekit_src}/squashfuse_dlopen.patch"
+      "${appimagekit_src}/lib/libappimage/src/patches/squashfuse.patch"
+      "${appimagekit_src}/lib/libappimage/src/patches/squashfuse_dlopen.patch"
     ];
 
     postPatch = ''
-      cp -v ${appimagekit_src}/squashfuse_dlopen.[hc] .
+      cp -v ${appimagekit_src}/lib/libappimage/src/patches/squashfuse_dlopen.[hc] .
     '';
 
     preConfigure = ''
···
   });
 
 in stdenv.mkDerivation rec {
-  name = "appimagekit-20180727";
+  pname = "appimagekit";
+  version = "unstable-2020-12-31";
 
   src = appimagekit_src;
 
   patches = [ ./nix.patch ];
+
+  postPatch = ''
+    patchShebangs src/embed-magic-bytes-in-file.sh
+  '';
 
   nativeBuildInputs = [
     pkg-config cmake autoconf automake libtool wget xxd
-    desktop-file-utils
+    desktop-file-utils makeWrapper
   ];
 
   buildInputs = [
-    glib zlib cairo openssl fuse
-    xz inotify-tools libarchive
-    squashfsTools makeWrapper
+    glib zlib cairo openssl fuse xz inotify-tools
+    libarchive squashfsTools appimagekit_squashfuse
   ];
-
-  postPatch = ''
-    substituteInPlace src/appimagetool.c --replace "/usr/bin/file" "${file}/bin/file"
-  '';
 
   preConfigure = ''
     export HOME=$(pwd)
···
     "-DUSE_SYSTEM_XZ=ON"
     "-DUSE_SYSTEM_SQUASHFUSE=ON"
     "-DSQUASHFUSE=${appimagekit_squashfuse}"
-    "-DUSE_SYSTEM_INOTIFY_TOOLS=ON"
     "-DUSE_SYSTEM_LIBARCHIVE=ON"
     "-DUSE_SYSTEM_GTEST=ON"
     "-DUSE_SYSTEM_MKSQUASHFS=ON"
   ];
 
   postInstall = ''
+    mkdir -p $out/lib/appimagekit
     cp "${squashfsTools}/bin/mksquashfs" "$out/lib/appimagekit/"
     cp "${desktop-file-utils}/bin/desktop-file-validate" "$out/bin"
 
     wrapProgram "$out/bin/appimagetool" \
-      --prefix PATH : "${lib.makeBinPath [ file gnupg ]}"
+      --prefix PATH : "${lib.makeBinPath [ file gnupg ]}" \
+      --unset SOURCE_DATE_EPOCH
   '';
 
   checkInputs = [ gtest ];
-  doCheck = false; # fails 1 out of 4 tests, I'm too lazy to debug why
 
   # for debugging
   passthru = {
···
       AppImages.
     '';
     license = licenses.mit;
+    maintainers = with maintainers; [ taeer ];
     homepage = src.meta.homepage;
     platforms = platforms.linux;
   };

pkgs/tools/package-management/appimagekit/nix.patch

···
-diff --git a/cmake/dependencies.cmake b/cmake/dependencies.cmake
-index ea133a3..916606c 100644
---- a/cmake/dependencies.cmake
-+++ b/cmake/dependencies.cmake
-@@ -224,21 +224,23 @@ if(NOT USE_SYSTEM_XZ)
-         LIBRARY_DIRS <INSTALL_DIR>/lib/
-         LIBRARIES "<INSTALL_DIR>/lib/liblzma.a"
-         INCLUDE_DIRS "<SOURCE_DIR>/src/liblzma/api/"
+Submodule lib/libappimage contains modified content
+diff --git a/lib/libappimage/cmake/dependencies.cmake b/lib/libappimage/cmake/dependencies.cmake
+index 8d96484..c7b17a1 100644
+--- a/lib/libappimage/cmake/dependencies.cmake
++++ b/lib/libappimage/cmake/dependencies.cmake
+@@ -91,9 +91,18 @@ if(NOT USE_SYSTEM_SQUASHFUSE)
+         INCLUDE_DIRS "<SOURCE_DIR>"
      )
  else()
-     message(STATUS "Using system xz")
- 
-     import_pkgconfig_target(TARGET_NAME xz PKGCONFIG_TARGET liblzma STATIC)
- endif()
- 
-+set(USE_SYSTEM_SQUASHFUSE OFF CACHE BOOL "Use system squashfuse instead of building our own")
- 
-+if(NOT USE_SYSTEM_SQUASHFUSE)
- # as distros don't provide suitable squashfuse and squashfs-tools, those dependencies are bundled in, can, and should
- # be used from this repository
- # TODO: implement out-of-source builds for squashfuse, as for the other dependencies
- configure_file(
-     ${CMAKE_CURRENT_SOURCE_DIR}/src/patch-squashfuse.sh.in
-     ${CMAKE_CURRENT_BINARY_DIR}/patch-squashfuse.sh
-     @ONLY
- )
- 
- ExternalProject_Add(squashfuse-EXTERNAL
-@@ -259,20 +261,34 @@ ExternalProject_Add(squashfuse-EXTERNAL
-     BUILD_IN_SOURCE ON
-     INSTALL_COMMAND ${MAKE} install
- )
- 
- import_external_project(
-     TARGET_NAME squashfuse
-     EXT_PROJECT_NAME squashfuse-EXTERNAL
-     LIBRARIES "<SOURCE_DIR>/.libs/libsquashfuse.a;<SOURCE_DIR>/.libs/libsquashfuse_ll.a;<SOURCE_DIR>/.libs/libfuseprivate.a"
-     INCLUDE_DIRS "<SOURCE_DIR>"
- )
-+else()
+-    message(STATUS "Using system squashfuse")
 +    message(STATUS "Using system squashfsfuse from ${SQUASHFUSE}")
-+
-+    add_library(squashfuse INTERFACE IMPORTED GLOBAL)
+
+-    import_pkgconfig_target(TARGET_NAME libsquashfuse PKGCONFIG_TARGET squashfuse)
++    add_library(libsquashfuse INTERFACE IMPORTED GLOBAL)
 +
 +    set(squashfuse_INCLUDE_DIRS "${SQUASHFUSE}/include")
 +    set(squashfuse_LIBRARIES "${SQUASHFUSE}/lib/libsquashfuse.a;${SQUASHFUSE}/lib/libsquashfuse_ll.a;${SQUASHFUSE}/lib/libfuseprivate.a")
 +
 +    set_property(
-+      TARGET squashfuse
++      TARGET libsquashfuse
 +      PROPERTY INTERFACE_LINK_LIBRARIES ${squashfuse_LIBRARIES}
 +    )
 +    include_directories(${squashfuse_INCLUDE_DIRS})
-+endif()
- 
- 
- set(USE_SYSTEM_INOTIFY_TOOLS OFF CACHE BOOL "Use system libinotifytools instead of building our own")
- 
- if(NOT USE_SYSTEM_INOTIFY_TOOLS)
-     message(STATUS "Downloading and building inotify-tools")
- 
-     # TODO: build out of source
-     ExternalProject_Add(inotify-tools-EXTERNAL
-         URL https://github.com/downloads/rvoicilas/inotify-tools/inotify-tools-3.14.tar.gz
-@@ -345,20 +361,23 @@ if(NOT USE_SYSTEM_GTEST)
-             INCLUDE_DIRS "<INSTALL_DIR>/include/"
-         )
-     else()
-         message(STATUS "Using system GTest")
- 
-         import_find_pkg_target(gtest GTest GTEST)
-     endif()
  endif()
- 
- 
-+set(USE_SYSTEM_MKSQUASHFS OFF CACHE BOOL "Use system mksquashfs instead of downloading and building our own")
-+
-+if(NOT USE_SYSTEM_MKSQUASHFS)
- # TODO: allow using system wide mksquashfs
- set(mksquashfs_cflags "-DXZ_SUPPORT ${CFLAGS}")
- 
- if(xz_LIBRARIES MATCHES "\\.a$")
-     set(mksquashfs_ldflags "${xz_LIBRARIES}")
- else()
-     set(mksquashfs_ldflags "-l${xz_LIBRARIES}")
- endif()
- 
- if(xz_INCLUDE_DIRS)
-@@ -385,20 +404,25 @@ ExternalProject_Add(mksquashfs
-     INSTALL_COMMAND ${MAKE} -C squashfs-tools/ install INSTALL_DIR=<INSTALL_DIR>
- )
- 
- ExternalProject_Get_Property(mksquashfs INSTALL_DIR)
- set(mksquashfs_INSTALL_DIR "${INSTALL_DIR}")
- mark_as_advanced(mksquashfs_INSTALL_DIR)
- 
- # for later use when packaging as an AppImage
- set(mksquashfs_BINARY "${mksquashfs_INSTALL_DIR}/mksquashfs")
- mark_as_advanced(mksquashfs_BINARY)
-+else()
-+    message(STATUS "Using system mksquashfs")
-+
-+    set(mksquashfs_BINARY "mksquashfs")
-+endif()
- 
- 
- #### build dependency configuration ####
- 
- # only have to build custom xz when not using system libxz
- if(TARGET xz-EXTERNAL)
-     if(TARGET squashfuse-EXTERNAL)
-         ExternalProject_Add_StepDependencies(squashfuse-EXTERNAL configure xz-EXTERNAL)
-     endif()
-     if(TARGET mksquashfs)
-diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
-index 3f25442..974ed0e 100644
---- a/src/CMakeLists.txt
-+++ b/src/CMakeLists.txt
-@@ -197,27 +197,27 @@ target_include_directories(digest_md5
- 
- target_link_libraries(digest_md5
-     PRIVATE
-     libglib
- )
- 
- 
- # install binaries
- if(AUXILIARY_FILES_DESTINATION)
-     install(
--        PROGRAMS ${mksquashfs_INSTALL_DIR}/mksquashfs ${CMAKE_CURRENT_BINARY_DIR}/runtime
-+        PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/runtime
-         DESTINATION ${AUXILIARY_FILES_DESTINATION}
-         COMPONENT applications
-     )
- else()
-     install(
--        PROGRAMS ${mksquashfs_INSTALL_DIR}/mksquashfs ${CMAKE_CURRENT_BINARY_DIR}/runtime
-+        PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/runtime
-         DESTINATION bin
-         COMPONENT applications
-     )
- endif()
- 
- install(
-     TARGETS AppRun appimagetool digest validate
-     RUNTIME DESTINATION bin COMPONENT applications
-     LIBRARY DESTINATION lib COMPONENT applications
-     ARCHIVE DESTINATION lib/static COMPONENT applications
-diff --git a/src/shared.c b/src/shared.c
-index cf5fd5c..4f48dbc 100644
---- a/src/shared.c
-+++ b/src/shared.c
-@@ -34,21 +34,21 @@
+
+
+diff --git a/src/appimagetool.c b/src/appimagetool.c
+index 6b37419..23425e7 100644
+--- a/src/appimagetool.c
++++ b/src/appimagetool.c
+@@ -38,7 +38,7 @@
+ #include <argp.h>
+
+ #include <fcntl.h>
+-#include "squashfuse.h"
++#include <squashfuse.h>
+
+ #include <sys/types.h>
  #include <sys/stat.h>
+@@ -96,7 +96,7 @@ static void die(const char *msg) {
+ }
+
+ /* Function that prints the contents of a squashfs file
+-* using libsquashfuse (#include "squashfuse.h") */
++* using libsquashfuse (#include <squashfuse.h>) */
+ int sfs_ls(char* image) {
+     sqfs_err err = SQFS_OK;
+     sqfs_traverse trv;
+diff --git a/src/appimagetoolnoglib.c b/src/appimagetoolnoglib.c
+index f900e76..ffa87f8 100644
+--- a/src/appimagetoolnoglib.c
++++ b/src/appimagetoolnoglib.c
+@@ -3,7 +3,7 @@
+
+ #include <stdlib.h>
+ #include <fcntl.h>
+-#include "squashfuse.h"
++#include <squashfuse.h>
+
  #include <sys/types.h>
- #include <dirent.h>
- #include <errno.h>
- 
- #include <glib.h>
- #include <glib/gprintf.h>
- #include <glib/gstdio.h>
- #include <gio/gio.h>
- 
+ #include <sys/stat.h>
+@@ -118,7 +118,7 @@ int is_regular_file(const char *path)
+ }
+
+ /* Function that prints the contents of a squashfs file
+- * using libsquashfuse (#include "squashfuse.h") */
++ * using libsquashfuse (#include <squashfuse.h>) */
+ int sfs_ls(char* image) {
+ 	sqfs_err err = SQFS_OK;
+ 	sqfs_traverse trv;
+diff --git a/src/runtime.c b/src/runtime.c
+index bada3af..70a642b 100644
+--- a/src/runtime.c
++++ b/src/runtime.c
+@@ -29,7 +29,7 @@
+
+ #define _GNU_SOURCE
+
 -#include "squashfuse.h"
 +#include <squashfuse.h>
  #include <squashfs_fs.h>
- #include "getsection.h"
- #include "elf.h"
- 
- #include "xdg-basedir.h"
- 
- // own header
- #include "shared.h"
- 
- #if HAVE_LIBARCHIVE3 == 1 // CentOS
+ #include <nonstd.h>

pkgs/tools/package-management/apt/default.nix

···
 { stdenv, lib, fetchurl, pkg-config, cmake, perlPackages, curl, gtest
-, gnutls, libtasn1, lzma, bzip2, lz4, zstd, libseccomp, udev
+, gnutls, libtasn1, xz, bzip2, lz4, zstd, libseccomp, udev
 , db, dpkg, libxslt, docbook_xsl, docbook_xml_dtd_45
 
 # used when WITH_DOC=ON
···
   nativeBuildInputs = [ pkg-config cmake gtest libxslt.bin ];
 
   buildInputs = [
-    perlPackages.perl curl gnutls libtasn1 lzma bzip2 lz4 zstd libseccomp udev db dpkg
+    perlPackages.perl curl gnutls libtasn1 xz bzip2 lz4 zstd libseccomp udev db dpkg
   ] ++ lib.optionals withDocs [
     doxygen perlPackages.Po4a w3m docbook_xml_dtd_45
   ] ++ lib.optionals withNLS [

pkgs/tools/package-management/nix/default.nix

···
   , jq, libarchive, libcpuid
   , lowdown, mdbook
   # Used by tests
-  , gmock
+  , gtest
   , busybox-sandbox-shell
   , storeDir
   , stateDir
···
         ]
         ++ lib.optionals stdenv.isDarwin [ Security ]
         ++ lib.optional (stdenv.isLinux || stdenv.isDarwin) libsodium
-        ++ lib.optionals is24 [ libarchive gmock lowdown ]
+        ++ lib.optionals is24 [ libarchive gtest lowdown ]
         ++ lib.optional (is24 && stdenv.isx86_64) libcpuid
         ++ lib.optional withLibseccomp libseccomp
         ++ lib.optional withAWS

pkgs/tools/package-management/opkg/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, curl, gpgme, libarchive, bzip2, lzma, attr, acl, libxml2
+{ lib, stdenv, fetchurl, pkg-config, curl, gpgme, libarchive, bzip2, xz, attr, acl, libxml2
 , autoreconfHook }:
 
 stdenv.mkDerivation rec {
···
   };
 
   nativeBuildInputs = [ pkg-config autoreconfHook ];
-  buildInputs = [ curl gpgme libarchive bzip2 lzma attr acl libxml2 ];
+  buildInputs = [ curl gpgme libarchive bzip2 xz attr acl libxml2 ];
 
   meta = with lib; {
     description = "A lightweight package management system based upon ipkg";

pkgs/tools/package-management/pacman/default.nix

···
 { stdenv, lib, fetchurl, pkg-config, m4, perl, libarchive, openssl, zlib, bzip2,
-lzma, curl, runtimeShell }:
+xz, curl, runtimeShell }:
 
 stdenv.mkDerivation rec {
   pname = "pacman";
···
   installFlags = [ "sysconfdir=${placeholder "out"}/etc" ];
 
   nativeBuildInputs = [ pkg-config m4 ];
-  buildInputs = [ curl perl libarchive openssl zlib bzip2 lzma ];
+  buildInputs = [ curl perl libarchive openssl zlib bzip2 xz ];
 
   postFixup = ''
     substituteInPlace $out/bin/repo-add \

pkgs/tools/security/enpass/default.nix

···
 , glib, libGLU, libGL, libpulseaudio, zlib, dbus, fontconfig, freetype
 , gtk3, pango
 , makeWrapper , python2Packages, lib
-, lsof, curl, libuuid, cups, mesa, lzma, libxkbcommon
+, lsof, curl, libuuid, cups, mesa, xz, libxkbcommon
 }:
 
 let
···
     curl
     libuuid
     cups
-    lzma
+    xz
     libxkbcommon
   ]);
   package = stdenv.mkDerivation {

pkgs/tools/security/john/default.nix

···
-{ lib, stdenv, fetchurl, openssl, nss, nspr, kerberos, gmp, zlib, libpcap, re2
+{ lib, stdenv, fetchurl, openssl, nss, nspr, libkrb5, gmp, zlib, libpcap, re2
 , gcc, python3Packages, perl, perlPackages, makeWrapper
 }:
 
···
     "--with-systemwide"
   ];
 
-  buildInputs = [ openssl nss nspr kerberos gmp zlib libpcap re2 ];
+  buildInputs = [ openssl nss nspr libkrb5 gmp zlib libpcap re2 ];
   nativeBuildInputs = [ gcc python3Packages.wrapPython perl makeWrapper ];
   propagatedBuildInputs = (with python3Packages; [ dpkt scapy lxml ]) ++ # For pcap2john.py
                           (with perlPackages; [ DigestMD4 DigestSHA1 GetoptLong # For pass_gen.pl

pkgs/tools/security/nuclei/default.nix

···
 
 buildGoModule rec {
   pname = "nuclei";
-  version = "2.3.3";
+  version = "2.3.4";
 
   src = fetchFromGitHub {
     owner = "projectdiscovery";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-6Y93Buxq9HIqeXY92xq5KjSn2nn+u05bKGNNi/myeSo=";
+    sha256 = "sha256-qjbr3kTgIFdxyzRwSvWyh5krrlzD8i1nMeoLZYSbr6g=";
   };
 
   vendorSha256 = "sha256-qmuua7HXnwuy24CSqHKALqNDmXBvSIXYTVu3kaGVoeU=";

pkgs/tools/security/pwncat/default.nix

···
 
 buildPythonApplication rec {
   pname = "pwncat";
-  version = "0.1.0";
+  version = "0.1.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0sfdqphs0v3lj3vffda4w05r6sqir7qafa8lmlh0wr921wyiqwag";
+    sha256 = "62e625e9061f037cfca7b7455a4f7db4213c1d1302e73d4c475c63f924f1805f";
   };
 
   # Tests requires to start containers
   doCheck = false;
 
   meta = with lib; {
-    description = " TCP/UDP communication suite";
+    description = "TCP/UDP communication suite";
     homepage = "https://pwncat.org/";
     license = with licenses; [ mit ];
     maintainers = with maintainers; [ fab ];

pkgs/tools/security/sshguard/default.nix

···
-{ lib, stdenv, fetchurl, autoreconfHook, yacc, flex}:
+{ lib, stdenv, fetchurl, autoreconfHook, bison, flex}:
 
 stdenv.mkDerivation rec {
   version = "2.4.1";
···
 
   doCheck = true;
 
-  nativeBuildInputs = [ autoreconfHook yacc flex ];
+  nativeBuildInputs = [ autoreconfHook bison flex ];
 
   configureFlags = [ "--sysconfdir=/etc" ];
 

pkgs/tools/security/teler/default.nix

···
 
 buildGoModule rec {
   pname = "teler";
-  version = "1.2.1";
+  version = "1.2.2";
 
   src = fetchFromGitHub {
     owner = "kitabisa";
     repo = "teler";
     rev = "v${version}";
-    sha256 = "sha256-lExZWFj0PQFUBJgfhahF8PfYaOndRxKyVHoMlubmEpc=";
+    sha256 = "sha256-i4106PtoCJt5CY9ahczZYe9GufBkaZS+9Peh0IY9r1M=";
   };
 
   vendorSha256 = "sha256-TQjwPem+RMuoF5T02CL/CTvBS6W7Q786gTvYUFIvxjE=";

pkgs/tools/security/tor/default.nix

···
 { lib, stdenv, fetchurl, pkg-config, libevent, openssl, zlib, torsocks
-, libseccomp, systemd, libcap, lzma, zstd, scrypt, nixosTests
+, libseccomp, systemd, libcap, xz, zstd, scrypt, nixosTests
 , writeShellScript
 
 # for update.nix
···
   outputs = [ "out" "geoip" ];
 
   nativeBuildInputs = [ pkg-config ];
-  buildInputs = [ libevent openssl zlib lzma zstd scrypt ] ++
+  buildInputs = [ libevent openssl zlib xz zstd scrypt ] ++
     lib.optionals stdenv.isLinux [ libseccomp systemd libcap ];
 
   patches = [ ./disable-monotonic-timer-tests.patch ];

pkgs/tools/security/zsteg/Gemfile

···
+source 'https://rubygems.org'
+gem 'zsteg'

pkgs/tools/security/zsteg/Gemfile.lock

···
+GEM
+  remote: https://rubygems.org/
+  specs:
+    iostruct (0.0.4)
+    rainbow (3.0.0)
+    zpng (0.3.1)
+      rainbow
+    zsteg (0.2.2)
+      iostruct
+      zpng (>= 0.3.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  zsteg
+
+BUNDLED WITH
+   2.1.4

pkgs/tools/security/zsteg/default.nix

···
+{ lib, bundlerApp }:
+
+bundlerApp {
+  pname = "zsteg";
+
+  gemdir = ./.;
+
+  exes = [ "zsteg" ];
+
+  meta = with lib; {
+    description = "Detect stegano-hidden data in PNG & BMP.";
+    homepage = "http://zed.0xff.me/";
+    license = licenses.mit;
+    maintainers = with maintainers; [ applePrincess ];
+  };
+}

pkgs/tools/security/zsteg/gemset.nix

···
+{
+  iostruct = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0kwp6ryis32j3z7myw8g7v1yszwrwyl04g2c7flr42pwxga1afxc";
+      type = "gem";
+    };
+    version = "0.0.4";
+  };
+  rainbow = {
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0bb2fpjspydr6x0s8pn1pqkzmxszvkfapv0p4627mywl7ky4zkhk";
+      type = "gem";
+    };
+    version = "3.0.0";
+  };
+  zpng = {
+    dependencies = ["rainbow"];
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0ciyab7qxqsxjhfvr6rbpdzg655fi1zygqg9sd9m6wmgc037dj74";
+      type = "gem";
+    };
+    version = "0.3.1";
+  };
+  zsteg = {
+    dependencies = ["iostruct" "zpng"];
+    groups = ["default"];
+    platforms = [];
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1mwajlsgs27449n2yf2f9hz8g46qv9bz9f58i9cz1jg58spvpxpk";
+      type = "gem";
+    };
+    version = "0.2.2";
+  };
+}

pkgs/tools/system/inxi/default.nix

···
 , ps, dnsutils # dig is recommended for multiple categories
 , withRecommends ? false # Install (almost) all recommended tools (see --recommends)
 , withRecommendedSystemPrograms ? withRecommends, util-linuxMinimal, dmidecode
-, file, hddtemp, iproute, ipmitool, usbutils, kmod, lm_sensors, smartmontools
+, file, hddtemp, iproute2, ipmitool, usbutils, kmod, lm_sensors, smartmontools
 , binutils, tree, upower, pciutils
 , withRecommendedDisplayInformationPrograms ? withRecommends, glxinfo, xorg
 }:
···
   prefixPath = programs:
     "--prefix PATH ':' '${lib.makeBinPath programs}'";
   recommendedSystemPrograms = lib.optionals withRecommendedSystemPrograms [
-    util-linuxMinimal dmidecode file hddtemp iproute ipmitool usbutils kmod
+    util-linuxMinimal dmidecode file hddtemp iproute2 ipmitool usbutils kmod
     lm_sensors smartmontools binutils tree upower pciutils
   ];
   recommendedDisplayInformationPrograms = lib.optionals

pkgs/tools/system/nats-top/default.nix

···
+{ lib
+, buildGoModule
+, fetchFromGitHub
+}:
+
+buildGoModule rec {
+  pname = "nats-top";
+  version = "0.4.0";
+
+  src = fetchFromGitHub {
+    owner = "nats-io";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "0b1hpnq8m1xfrn58ammmnx6lmhk319m8z4xjxgckz7wvy2fbzw0n";
+  };
+
+  vendorSha256 = "1a48p9gx5zdc340ma6cqakhi6f3lw9b0kz2597j1jcsk2qb7s581";
+
+  meta = with lib; {
+    description = "top-like tool for monitoring NATS servers";
+    homepage = "https://github.com/nats-io/nats-top";
+    license = with licenses; [ mit ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

pkgs/tools/system/natscli/default.nix

···
+{ lib
+, buildGoModule
+, fetchFromGitHub
+}:
+
+buildGoModule rec {
+  pname = "natscli";
+  version = "0.0.22";
+
+  src = fetchFromGitHub {
+    owner = "nats-io";
+    repo = pname;
+    rev = version;
+    sha256 = "1qc6lpgl878kc316z10x59px6jyfzdwsj7fdr8k4ayln0lplvbq3";
+  };
+
+  vendorSha256 = "1a9d7hqj43qdh0h7pc5wckqshi8lacf6m2107wymzzz62j1msy26";
+
+  meta = with lib; {
+    description = "NATS Command Line Interface";
+    homepage = "https://github.com/nats-io/natscli";
+    license = with licenses; [ asl20 ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

pkgs/tools/system/nkeys/default.nix

···
+{ lib
+, buildGoModule
+, fetchFromGitHub
+}:
+
+buildGoModule rec {
+  pname = "nkeys";
+  version = "0.3.0";
+
+  src = fetchFromGitHub {
+    owner = "nats-io";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "06wbmb3cxjrcfvgfbn6rdfzb4pfaaw11bnvl1r4kig4ag22qcz7b";
+  };
+
+  vendorSha256 = "0kiqlw2411x5c1pamq3mn5wcm8mdn91avwg8xh2a7sy3kqw5d26d";
+
+  meta = with lib; {
+    description = "Public-key signature system for NATS";
+    homepage = "https://github.com/nats-io/nkeys";
+    license = with licenses; [ mit ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

pkgs/tools/system/syslog-ng-incubator/default.nix

···
 { lib, stdenv, fetchFromGitHub, autoreconfHook, pkg-config, glib, syslogng
-, eventlog, perl, python, yacc, protobufc, libivykis, libcap, czmq
+, eventlog, perl, python, bison, protobufc, libivykis, libcap, czmq
 }:
 
 stdenv.mkDerivation rec {
···
     sha256 = "17y85cqcyfbp882gaii731cvz5bg1s8rgda271jh6kgnrz5rbd4s";
   };
 
-  nativeBuildInputs = [ pkg-config autoreconfHook yacc ];
+  nativeBuildInputs = [ pkg-config autoreconfHook bison ];
 
   buildInputs = [
     glib syslogng eventlog perl python protobufc libivykis libcap czmq

pkgs/tools/system/thermald/default.nix

···
 , libevdev
 , libtool
 , libxml2
-, lzma
+, xz
 , pkg-config
 , lib, stdenv
 , upower
···
     dbus-glib
     libevdev
     libxml2
-    lzma
+    xz
     upower
   ];
 

pkgs/tools/system/vboot_reference/default.nix

···
-{ lib, stdenv, fetchFromGitiles, pkg-config, libuuid, openssl, libyaml, lzma }:
+{ lib, stdenv, fetchFromGitiles, pkg-config, libuuid, openssl, libyaml, xz }:
 
 stdenv.mkDerivation rec {
   version = "20180311";
···
   };
 
   nativeBuildInputs = [ pkg-config ];
-  buildInputs = [ openssl libuuid libyaml lzma ];
+  buildInputs = [ openssl libuuid libyaml xz ];
 
   enableParallelBuilding = true;
 

pkgs/tools/text/gpt2tc/0001-add-python-shebang.patch

···
+diff --git a/gpt2convert.py b/gpt2convert.py
+index 34ca909..6e6cac5 100644
+--- a/gpt2convert.py
++++ b/gpt2convert.py
+@@ -1,3 +1,5 @@
++#!/usr/bin/env python3
++
+ import sys
+ import tensorflow as tf
+ import numpy as np

pkgs/tools/text/gpt2tc/0002-fix-download-url.patch

···
+diff --git a/download_model.sh b/download_model.sh
+index 9cb401f..ad1dc62 100755
+--- a/download_model.sh
++++ b/download_model.sh
+@@ -13,5 +13,5 @@ mkdir -p models/$model
+ for filename in checkpoint encoder.json hparams.json model.ckpt.data-00000-of-00001 model.ckpt.index model.ckpt.meta vocab.bpe; do
+   fetch=$model/$filename
+   echo "Fetching $fetch"
+-  curl --output models/$fetch https://storage.googleapis.com/gpt-2/models/$fetch
++  curl --output models/$fetch https://openaipublic.blob.core.windows.net/gpt-2/models/$fetch
+ done

pkgs/tools/text/gpt2tc/default.nix

···
+{ lib, stdenv, fetchurl, autoPatchelfHook, python3 }:
+
+stdenv.mkDerivation rec {
+  pname = "gpt2tc";
+  version = "2020-12-30";
+
+  src = fetchurl {
+    url = "https://bellard.org/nncp/gpt2tc-${version}.tar.gz";
+    hash = "sha256-KFcl7E6iGx50JaJI1jwzKAdkrkbNngPbrEA/ZSyG+uY=";
+  };
+
+  patches = [
+    # Add a shebang to the python script so that nix detects it as such and
+    # wraps it properly. Otherwise, it runs in shell and freezes the system.
+    ./0001-add-python-shebang.patch
+
+    # Update the source URL for the models because the old one is down.
+    ./0002-fix-download-url.patch
+  ];
+
+  nativeBuildInputs = [ autoPatchelfHook ];
+
+  buildInputs = [
+    (python3.withPackages (p: with p; [ numpy tensorflow ]))
+  ];
+
+  dontBuild = true;
+
+  installPhase = ''
+    runHook preInstall
+
+    install -D -m755 -t $out/bin gpt2tc
+    install -T -m755 download_model.sh $out/bin/gpt2-download-model
+    install -T -m755 gpt2convert.py $out/bin/gpt2-convert
+    install -D -m644 -t $out/share/gpt2tc readme.txt gpt2vocab.txt Changelog
+
+    runHook postInstall
+  '';
+
+  meta = with lib; {
+    description = "Text completion and compression using GPT-2";
+    homepage = "https://bellard.org/nncp/gpt2tc.html";
+    license = licenses.unfree;
+    platforms = [ "x86_64-linux" ];
+    maintainers = with maintainers; [ anna328p ];
+  };
+}

pkgs/tools/text/html-tidy/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "html-tidy";
-  version = "5.6.0";
+  version = "5.7.28";
 
   src = fetchFromGitHub {
     owner = "htacg";
     repo = "tidy-html5";
     rev = version;
-    sha256 = "0w175c5d1babq0w1zzdzw9gl6iqbgyq58v8587s7srp05y3hwy9k";
+    sha256 = "sha256-Tny53PtaQWAMAEjqw4tKnmGURfZhhwFQNCJr9jjWZQY=";
   };
 
   nativeBuildInputs = [ cmake libxslt/*manpage*/ ];

pkgs/tools/text/silver-searcher/default.nix

···
-{lib, stdenv, fetchFromGitHub, autoreconfHook, pkg-config, pcre, zlib, lzma}:
+{lib, stdenv, fetchFromGitHub, autoreconfHook, pkg-config, pcre, zlib, xz}:
 
 stdenv.mkDerivation rec {
   pname = "silver-searcher";
···
   NIX_LDFLAGS = lib.optionalString stdenv.isLinux "-lgcc_s";
 
   nativeBuildInputs = [ autoreconfHook pkg-config ];
-  buildInputs = [ pcre zlib lzma ];
+  buildInputs = [ pcre zlib xz ];
 
   meta = with lib; {
     homepage = "https://github.com/ggreer/the_silver_searcher/";

pkgs/tools/text/zimwriterfs/default.nix

···
 , file
 , icu
 , gumbo
-, lzma
+, xz
 , xapian
 , zimlib
 , zlib
···
   };
 
   nativeBuildInputs = [ automake autoconf libtool pkg-config ];
-  buildInputs = [ file icu gumbo lzma zimlib zlib xapian ];
+  buildInputs = [ file icu gumbo xz zimlib zlib xapian ];
   setSourceRoot = ''
     sourceRoot=$(echo */zimwriterfs)
   '';

pkgs/tools/typesetting/tex/tex-match/default.nix

···
+{ rustPlatform, fetchFromGitHub, gtk3, pkg-config, glib, lib }:
+
+rustPlatform.buildRustPackage rec {
+  pname = "tex-match";
+  version = "1.2.0";
+
+  src = fetchFromGitHub {
+    owner = "zoeyfyi";
+    repo = "TeX-Match";
+    rev = "v${version}";
+    sha256 = "1yb81j7mbqqb8jcn78dx4ydp7ncbzvaczkli6cqay5jf5j6dbk1z";
+  };
+
+  nativeBuildInputs = [ pkg-config glib ];
+
+  buildInputs = [ gtk3 ];
+
+  cargoSha256 = "1sm2fd3dhs59rvmfjzrfz0qwqzyc9dllb8ph0wc2x0r3px16c71x";
+
+  meta = with lib; {
+    description = "Search through over 1000 different LaTeX symbols by sketching. A desktop version of detexify";
+    homepage = "https://tex-match.zoey.fyi/";
+    license = licenses.mit;
+    maintainers = [ maintainers.bootstrap-prime ];
+    platforms = platforms.linux;
+  };
+}

pkgs/tools/virtualization/google-compute-engine/default.nix

···
 { lib
 , fetchFromGitHub
-, buildPythonApplication
+, buildPythonPackage
 , bash
 , bashInteractive
 , systemd
···
 , distro
 }:
 
-buildPythonApplication rec {
+buildPythonPackage rec {
   pname = "google-compute-engine";
   version = "20190124";
-  namePrefix = "";
 
   src = fetchFromGitHub {
     owner = "GoogleCloudPlatform";
···
 
   buildInputs = [ bash ];
   propagatedBuildInputs = [ boto setuptools distro ];
-
 
   postPatch = ''
     for file in $(find google_compute_engine -type f); do
···
   '';
 
   doCheck = false;
+  pythonImportsCheck = [ "google_compute_engine" ];
 
   meta = with lib; {
     description = "Google Compute Engine tools and services";

pkgs/top-level/aliases.nix

···
   gnustep-make = gnustep.make; # added 2016-7-6
   gnupg20 = throw "gnupg20 has been removed from nixpkgs as upstream dropped support on 2017-12-31";# added 2020-07-12
   gnuvd = throw "gnuvd was removed because the backend service is missing"; # added 2020-01-14
+  gmock = gtest; # moved from top-level 2021-03-14
   go_1_12 = throw "go_1_12 has been removed"; # added 2020-04-26
   go-pup = pup; # added 2017-12-19
   gobby5 = gobby; # added 2021-02-01
···
   infiniband-diags = rdma-core; # added 2019-08-09
   inotifyTools = inotify-tools;
   inter-ui = inter; # added 2021-03-27
+  iproute = iproute2; # moved from top-level 2021-03-14
   i-score = throw "i-score has been removed: abandoned upstream."; # added 2020-11-21
+  jack2Full = jack2; # moved from top-level 2021-03-14
   jamomacore = throw "jamomacore has been removed: abandoned upstream."; # added 2020-11-21
   jbidwatcher = throw "jbidwatcher was discontinued in march 2021"; # added 2021-03-15
   jbuilder = dune_1; # added 2018-09-09
···
   kicad-with-packages3d = kicad; # added 2019-11-25
   kindlegen = throw "kindlegen has been removed from nixpkgs, as it's abandoned and no longer available for download."; # 2021-03-09
   krename-qt5 = krename; # added 2017-02-18
+  kerberos = libkrb5; # moved from top-level 2021-03-14
   keymon = throw "keymon has been removed from nixpkgs, as it's abandoned and archived."; # 2019-12-10
   kvm = qemu_kvm; # added 2018-04-25
   latinmodern-math = lmmath;
···
   lua5_expat = luaPackages.luaexpat; # added 2017-05-02
   lua5_sec = luaPackages.luasec; # added 2017-05-02
   lxappearance-gtk3 = throw "lxappearance-gtk3 has been removed. Use lxappearance instead, which now defaults to Gtk3";  # added 2020-06-03
+  lzma = xz; # moved from top-level 2021-03-14
   m3d-linux = m33-linux; # added 2016-08-13
   man_db = man-db; # added 2016-05
   manpages = man-pages; # added 2015-12-06
   marathon = throw "marathon has been removed from nixpkgs, as it's unmaintained"; # added 2020-08-15
+  mysql = mariadb; # moved from top-level 2021-03-14
   mariadb-client = hiPrio mariadb.client; #added 2019.07.28
   matcha = throw "matcha was renamed to matcha-gtk-theme"; # added 2020-05-09
   mathics = throw "mathics has been removed from nixpkgs, as it's unmaintained"; # added 2020-08-15
···
   xlibs = xorg; # added 2015-09
   xpraGtk3 = xpra; # added 2018-09-13
   xv = xxv; # added 2020-02-22
+  yacc = bison; # moved from top-level 2021-03-14
   youtubeDL = youtube-dl;  # added 2014-10-26
   ytop = throw "ytop has been abandoned by upstream. Consider switching to bottom instead";
   yubikey-neo-manager = throw "yubikey-neo-manager has been removed because it was broken. Use yubikey-manager-qt instead."; # added 2021-03-08
   yuzu = yuzu-mainline; # added 2021-01-25
   zimreader = throw "zimreader has been removed from nixpkgs as it has been replaced by kiwix-serve and stopped working with modern zimlib versions."; # added 2021-03-28
   zdfmediathk = mediathekview; # added 2019-01-19
+
   gnome_user_docs = gnome-user-docs; # added 2019-11-20
   # spidermonkey is not ABI upwards-ompatible, so only allow this for nix-shell
   spidermonkey = spidermonkey_78; # added 2020-10-09
···
     plasma-vault
     plasma-workspace plasma-workspace-wallpapers
     polkit-kde-agent powerdevil
+    qqc2-breeze-style
     sddm-kcm systemsettings
     xdg-desktop-portal-kde
   ;

pkgs/top-level/all-packages.nix

···
 
   go-chromecast = callPackage ../applications/video/go-chromecast { };
 
+  go-containerregistry = callPackage ../development/tools/go-containerregistry { };
+
   go-rice = callPackage ../tools/misc/go.rice {};
 
   go-2fa = callPackage ../tools/security/2fa {};
···
 
   gringo = callPackage ../tools/misc/gringo { };
 
+  grit = callPackage ../tools/misc/grit { };
+
   grobi = callPackage ../tools/X11/grobi { };
 
   gscan2pdf = callPackage ../applications/graphics/gscan2pdf { };
···
   jellyfin-mpv-shim = python3Packages.callPackage ../applications/video/jellyfin-mpv-shim { };
 
   jotta-cli = callPackage ../applications/misc/jotta-cli { };
+
+  joycond = callPackage ../os-specific/linux/joycond { };
 
   jwt-cli = callPackage ../tools/security/jwt-cli {
     inherit (darwin.apple_sdk.frameworks) Security;
···
 
   wrangler = callPackage ../development/tools/wrangler {
    inherit (darwin.apple_sdk.frameworks) CoreFoundation CoreServices Security;
-   inherit (darwin) libiconv;
   };
 
   wsl-open = callPackage ../tools/misc/wsl-open { };
···
   embree2 = callPackage ../development/libraries/embree/2.x.nix { };
 
   emem = callPackage ../applications/misc/emem { };
+
+  empty = callPackage ../tools/misc/empty { };
 
   emulsion = callPackage ../applications/graphics/emulsion {
     inherit (darwin.apple_sdk.frameworks) AppKit CoreGraphics CoreServices Foundation OpenGL;
···
   gpart = callPackage ../tools/filesystems/gpart { };
 
   gparted = callPackage ../tools/misc/gparted { };
+
+  gpt2tc = callPackage ../tools/text/gpt2tc { };
 
   ldmtool = callPackage ../tools/misc/ldmtool { };
 
···
   gt5 = callPackage ../tools/system/gt5 { };
 
   gtest = callPackage ../development/libraries/gtest { };
-  gmock = gtest; # TODO: move to aliases.nix
 
   gbenchmark = callPackage ../development/libraries/gbenchmark {};
 
···
     pythonPackages = python3Packages;
   };
 
+  nats-top = callPackage ../tools/system/nats-top { };
+
+  natscli = callPackage ../tools/system/natscli { };
+
   nbench = callPackage ../tools/misc/nbench { };
 
   ncrack = callPackage ../tools/security/ncrack { };
···
 
   netsniff-ng = callPackage ../tools/networking/netsniff-ng { };
 
+  nkeys = callPackage ../tools/system/nkeys { };
+
   nyxt = callPackage ../applications/networking/browsers/nyxt { };
 
   nfpm = callPackage ../tools/package-management/nfpm { };
···
   luxcorerender = callPackage ../tools/graphics/luxcorerender { };
 
   xz = callPackage ../tools/compression/xz { };
-  lzma = xz; # TODO: move to aliases.nix
 
   lz4 = callPackage ../tools/compression/lz4 { };
 
···
 
   qjoypad = callPackage ../tools/misc/qjoypad { };
 
+  qmk = callPackage ../tools/misc/qmk { };
+
   qosmic = libsForQt5.callPackage ../applications/graphics/qosmic { };
 
   qownnotes = libsForQt514.callPackage ../applications/office/qownnotes { };
···
 
   super = callPackage ../tools/security/super { };
 
+  supertag = callPackage ../tools/filesystems/supertag { };
+
   supertux-editor = callPackage ../applications/editors/supertux-editor { };
 
   svgbob = callPackage ../tools/graphics/svgbob { };
···
   textadept11 = callPackage ../applications/editors/textadept/11 { };
 
   texworks = libsForQt5.callPackage ../applications/editors/texworks { };
+
+  tex-match = callPackage ../tools/typesetting/tex/tex-match { };
 
   thc-hydra = callPackage ../tools/security/thc-hydra { };
 
···
   zsh-autopair = callPackage ../shells/zsh/zsh-autopair { };
 
   zsh-bd = callPackage ../shells/zsh/zsh-bd { };
+
+  zsh-clipboard = callPackage ../shells/zsh/zsh-clipboard { };
 
   zsh-git-prompt = callPackage ../shells/zsh/zsh-git-prompt { };
 
···
   });
 
   bison = callPackage ../development/tools/parsing/bison { };
-  yacc = bison; # TODO: move to aliases.nix
 
   # Ruby fails to build with current bison
   bison_3_5 = pkgs.bison.overrideAttrs (oldAttrs: rec {
···
     };
   }));
 
+  polar = callPackage ../tools/misc/polar { };
+
   inherit (nodePackages) postcss-cli;
 
   postiats-utilities = callPackage ../development/tools/postiats-utilities {};
···
   cypress = callPackage ../development/web/cypress { };
 
   cyrus_sasl = callPackage ../development/libraries/cyrus-sasl {
-    kerberos = if stdenv.isFreeBSD then libheimdal else kerberos;
+    libkrb5 = if stdenv.isFreeBSD then libheimdal else libkrb5;
   };
 
   # Make bdb5 the default as it is the last release under the custom
···
   iso-flags = callPackage ../data/icons/iso-flags { };
 
   ispc = callPackage ../development/compilers/ispc {
-    stdenv = llvmPackages_10.stdenv;
-    llvmPackages = llvmPackages_10;
+    stdenv = llvmPackages_11.stdenv;
+    llvmPackages = llvmPackages_11;
   };
 
   isso = callPackage ../servers/isso { };
···
   };
   krb5Full = krb5;
   libkrb5 = krb5.override { type = "lib"; };
-  kerberos = libkrb5; # TODO: move to aliases.nix
 
   l-smash = callPackage ../development/libraries/l-smash {
     stdenv = gccStdenv;
···
 
   libdmtx = callPackage ../development/libraries/libdmtx { };
 
+  libdmapsharing = callPackage ../development/libraries/libdmapsharing { };
+
   libdnet = callPackage ../development/libraries/libdnet { };
 
   libdnf = callPackage ../tools/package-management/libdnf { };
···
   libpcap = callPackage ../development/libraries/libpcap { };
 
   libpeas = callPackage ../development/libraries/libpeas { };
+
+  libpg_query = callPackage ../development/libraries/libpg_query { };
 
   libpipeline = callPackage ../development/libraries/libpipeline { };
 
···
   pkcs11helper = callPackage ../development/libraries/pkcs11helper { };
 
   pkgdiff = callPackage ../tools/misc/pkgdiff { };
+
+  place-cursor-at = haskell.lib.justStaticExecutables haskellPackages.place-cursor-at;
 
   plib = callPackage ../development/libraries/plib { };
 
···
 
   ### SERVERS
 
-  _389-ds-base = callPackage ../servers/ldap/389 {
-    kerberos = libkrb5;
-  };
+  _389-ds-base = callPackage ../servers/ldap/389 { };
 
   adguardhome = callPackage ../servers/adguardhome {};
 
···
     inherit (darwin) cctools;
     inherit (pkgs.darwin.apple_sdk.frameworks) CoreServices;
   };
-  mysql = mariadb; # TODO: move to aliases.nix
 
   mongodb = hiPrio mongodb-3_4;
 
···
   prometheus-aws-s3-exporter = callPackage ../servers/monitoring/prometheus/aws-s3-exporter.nix { };
   prometheus-bind-exporter = callPackage ../servers/monitoring/prometheus/bind-exporter.nix { };
   prometheus-bird-exporter = callPackage ../servers/monitoring/prometheus/bird-exporter.nix { };
+  prometheus-bitcoin-exporter = callPackage ../servers/monitoring/prometheus/bitcoin-exporter.nix { };
   prometheus-blackbox-exporter = callPackage ../servers/monitoring/prometheus/blackbox-exporter.nix { };
   prometheus-collectd-exporter = callPackage ../servers/monitoring/prometheus/collectd-exporter.nix { };
   prometheus-consul-exporter = callPackage ../servers/monitoring/prometheus/consul-exporter.nix { };
···
 
   alsaPluginWrapper = callPackage ../os-specific/linux/alsa-plugins/wrapper.nix { };
 
-  alsaUtils = callPackage ../os-specific/linux/alsa-utils { };
+  alsaUtils = callPackage ../os-specific/linux/alsa-utils {
+    fftw = fftwFloat;
+  };
   alsaOss = callPackage ../os-specific/linux/alsa-oss { };
   alsaTools = callPackage ../os-specific/linux/alsa-tools { };
 
···
   iotop = callPackage ../os-specific/linux/iotop { };
 
   iproute2 = callPackage ../os-specific/linux/iproute { };
-  iproute = iproute2; # Alias added 2020-11-15 (TODO: deprecate and move to pkgs/top-level/aliases.nix)
 
   iproute_mptcp = callPackage ../os-specific/linux/iproute/mptcp.nix { };
 
···
 
   shades-of-gray-theme = callPackage ../data/themes/shades-of-gray { };
 
+  sjasmplus = callPackage ../development/compilers/sjasmplus { };
+
   skeu = callPackage ../data/themes/skeu { };
 
   sweet = callPackage ../data/themes/sweet { };
···
     jdk = callPackage ../development/compilers/jetbrains-jdk {  };
   });
 
+  jmusicbot = callPackage ../applications/audio/jmusicbot { };
+
   libquvi = callPackage ../applications/video/quvi/library.nix { };
 
   librespot = callPackage ../applications/audio/librespot {
···
   swaybg = callPackage ../applications/window-managers/sway/bg.nix { };
   swayidle = callPackage ../applications/window-managers/sway/idle.nix { };
   swaylock = callPackage ../applications/window-managers/sway/lock.nix { };
+  swaywsr = callPackage ../applications/window-managers/sway/wsr.nix { };
   sway-contrib = recurseIntoAttrs (callPackages ../applications/window-managers/sway/contrib.nix { });
 
   swaylock-fancy = callPackage ../applications/window-managers/sway/lock-fancy.nix { };
···
 
   i3status-rust = callPackage ../applications/window-managers/i3/status-rust.nix { };
 
+  i3wsr = callPackage ../applications/window-managers/i3/wsr.nix { };
+
   i3-wk-switch = callPackage ../applications/window-managers/i3/wk-switch.nix { };
 
   waybox = callPackage ../applications/window-managers/waybox { };
···
   melonDS = libsForQt5.callPackage ../misc/emulators/melonDS { };
 
   meme = callPackage ../applications/graphics/meme { };
+
+  meme-suite = callPackage ../applications/science/biology/meme-suite { };
 
   # Needs qtwebkit which is broken on qt5.15
   mendeley = libsForQt514.callPackage ../applications/office/mendeley {
···
 
   zscroll = callPackage ../applications/misc/zscroll {};
 
+  zsteg = callPackage ../tools/security/zsteg { };
+
   zynaddsubfx = zyn-fusion;
 
   zynaddsubfx-fltk = callPackage ../applications/audio/zynaddsubfx {
···
 
   warsow = callPackage ../games/warsow { };
 
-  warzone2100 = libsForQt5.callPackage ../games/warzone2100 { };
+  warzone2100 = callPackage ../games/warzone2100 { };
 
   wesnoth = callPackage ../games/wesnoth {
     inherit (darwin.apple_sdk.frameworks) Cocoa Foundation;
···
   molden = callPackage ../applications/science/chemistry/molden { };
 
   octopus = callPackage ../applications/science/chemistry/octopus { };
+
+  openlp = libsForQt5.callPackage ../applications/misc/openlp { };
+  openlpFull = appendToName "full" (openlp.override {
+    pdfSupport = true;
+    presentationSupport = true;
+    vlcSupport = true;
+    gstreamerSupport = true;
+  });
 
   openmolcas = callPackage ../applications/science/chemistry/openmolcas { };
 
···
     inherit (darwin.apple_sdk.frameworks) AudioUnit CoreAudio Accelerate;
     inherit (darwin) libobjc;
   };
+
   libjack2 = jack2.override { prefix = "lib"; };
-  jack2Full = jack2; # TODO: move to aliases.nix
 
   j2cli = with python3Packages; toPythonApplication j2cli;
 
···
   mnemonicode = callPackage ../misc/mnemonicode { };
 
   mysql-workbench = callPackage ../applications/misc/mysql-workbench (let mysql = mysql57; in {
-    gdal = gdal.override {libmysqlclient = mysql // {lib = {dev = mysql;};};};
+    gdal = gdal.override {
+      libmysqlclient = mysql // {
+        lib = { dev = mysql; }
+      ;}
+    ;};
     mysql = mysql;
     pcre = pcre-cpp;
     jre = jre8; # TODO: remove override https://github.com/NixOS/nixpkgs/pull/89731
···
   openfst = callPackage ../development/libraries/openfst {};
 
   opengrm-ngram = callPackage ../development/libraries/opengrm-ngram {};
+
+  openring = callPackage ../applications/misc/openring { };
 
   phonetisaurus = callPackage ../development/libraries/phonetisaurus {};
 

pkgs/top-level/lua-packages.nix

···
 { fetchurl, stdenv, lua, unzip, pkg-config
 , pcre, oniguruma, gnulib, tre, glibc, sqlite, openssl, expat
 , autoreconfHook, gnum4
-, mysql, postgresql, cyrus_sasl
+, postgresql, cyrus_sasl
 , fetchFromGitHub, which, writeText
 , pkgs
 , lib

pkgs/top-level/ocaml-packages.nix

···
 
     parse-argv = callPackage ../development/ocaml-modules/parse-argv { };
 
+    pbkdf = callPackage ../development/ocaml-modules/pbkdf { };
+
     pcap-format = callPackage ../development/ocaml-modules/pcap-format { };
 
     pecu = callPackage ../development/ocaml-modules/pecu { };

pkgs/top-level/perl-packages.nix

···
 
   NetCIDRLite = buildPerlPackage {
     pname = "Net-CIDR-Lite";
-    version = "0.21";
+    version = "0.22";
     src = fetchurl {
-      url = "mirror://cpan/authors/id/D/DO/DOUGW/Net-CIDR-Lite-0.21.tar.gz";
-      sha256 = "cfa125e8a2aef9259bc3a44e07cbdfb7894b64d22e7c0cee92aee2f5c7915093";
+      url = "mirror://cpan/authors/id/S/ST/STIGTSP/Net-CIDR-Lite-0.22.tar.gz";
+      sha256 = "05w57db2lx4djb4vixzdr6qgrzyzkk047nl812g7nq8s6k5xh5s3";
     };
-    patches = [
-      # Fix for security issue: prevent leading zeroes in ipv4 octets
-      # https://blog.urth.org/2021/03/29/security-issues-in-perl-ip-address-distros/
-      ../development/perl-modules/Net-CIDR-Lite-prevent-leading-zeroes-ipv4.patch
-    ];
     meta = {
       description = "Perl extension for merging IPv4 or IPv6 CIDR addresses";
+      license = with lib.licenses; [ artistic1 gpl1Plus ];
+      maintainers = [ maintainers.sgo ];
     };
   };
 

pkgs/top-level/python-packages.nix

···
 
   conda = callPackage ../development/python-modules/conda { };
 
-  ConfigArgParse = callPackage ../development/python-modules/configargparse { };
+  ConfigArgParse = self.configargparse; # added 2021-03-18
+  configargparse = callPackage ../development/python-modules/configargparse { };
 
   configobj = callPackage ../development/python-modules/configobj { };
 
···
   doctest-ignore-unicode = callPackage ../development/python-modules/doctest-ignore-unicode { };
 
   docutils = callPackage ../development/python-modules/docutils { };
+
+  docx2python = callPackage ../development/python-modules/docx2python { };
 
   dodgy = callPackage ../development/python-modules/dodgy { };
 
···
 
   keras-preprocessing = callPackage ../development/python-modules/keras-preprocessing { };
 
-  kerberos = callPackage ../development/python-modules/kerberos {
-    inherit (pkgs) kerberos;
-  };
+  kerberos = callPackage ../development/python-modules/kerberos { };
 
   keyring = if isPy3k then
     callPackage ../development/python-modules/keyring { }
···
   rig = callPackage ../development/python-modules/rig { };
 
   ring-doorbell = callPackage ../development/python-modules/ring-doorbell { };
+
+  riprova = callPackage ../development/python-modules/riprova { };
 
   ripser = callPackage ../development/python-modules/ripser { };
 

pkgs/top-level/release-small.nix

···
   ltrace = linux;
   lvm2 = linux;
   lynx = linux;
-  lzma = linux;
+  xz = linux;
   man = linux;
   man-pages = linux;
   mc = all;