Merge branch 'master' into staging-next

Choose binwalk 2.3.1, 27 is legacy version for Python 2.

.github/CODEOWNERS

···
 /.github/CODEOWNERS @edolstra
 
 # GitHub actions
-/.github/workflows @Mic92 @zowoq
+/.github/workflows @NixOS/Security @Mic92 @zowoq
 /.github/workflows/merge-staging @FRidh
 
 # EditorConfig

.github/workflows/labels.yml

···
   pull_request_target:
     types: [edited, opened, synchronize, reopened]
 
+permissions:
+  contents: read
+  pull-requests: write
+
 jobs:
   labels:
     runs-on: ubuntu-latest

.github/workflows/manual-nixos.yml

···
 name: "Build NixOS manual"
 
+permissions: read-all
+
 on:
   pull_request_target:
     branches:

.github/workflows/manual-nixpkgs.yml

···
 name: "Build Nixpkgs manual"
 
+permissions: read-all
+
 on:
   pull_request_target:
     branches:

doc/builders/images.xml

···
  <para>
   This chapter describes tools for creating various types of images.
  </para>
- <xi:include href="images/appimagetools.xml" />
+ <xi:include href="images/appimagetools.section.xml" />
  <xi:include href="images/dockertools.section.xml" />
  <xi:include href="images/ocitools.section.xml" />
- <xi:include href="images/snaptools.xml" />
+ <xi:include href="images/snaptools.section.xml" />
 </chapter>

doc/builders/images/appimagetools.section.md

···
+# pkgs.appimageTools {#sec-pkgs-appimageTools}
+
+`pkgs.appimageTools` is a set of functions for extracting and wrapping [AppImage](https://appimage.org/) files. They are meant to be used if traditional packaging from source is infeasible, or it would take too long. To quickly run an AppImage file, `pkgs.appimage-run` can be used as well.
+
+::: warning
+The `appimageTools` API is unstable and may be subject to backwards-incompatible changes in the future.
+:::
+
+## AppImage formats {#ssec-pkgs-appimageTools-formats}
+
+There are different formats for AppImages, see [the specification](https://github.com/AppImage/AppImageSpec/blob/74ad9ca2f94bf864a4a0dac1f369dd4f00bd1c28/draft.md#image-format) for details.
+
+- Type 1 images are ISO 9660 files that are also ELF executables.
+- Type 2 images are ELF executables with an appended filesystem.
+
+They can be told apart with `file -k`:
+
+```ShellSession
+$ file -k type1.AppImage
+type1.AppImage: ELF 64-bit LSB executable, x86-64, version 1 (SYSV) ISO 9660 CD-ROM filesystem data 'AppImage' (Lepton 3.x), scale 0-0,
+spot sensor temperature 0.000000, unit celsius, color scheme 0, calibration: offset 0.000000, slope 0.000000, dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.18, BuildID[sha1]=d629f6099d2344ad82818172add1d38c5e11bc6d, stripped\012- data
+
+$ file -k type2.AppImage
+type2.AppImage: ELF 64-bit LSB executable, x86-64, version 1 (SYSV) (Lepton 3.x), scale 232-60668, spot sensor temperature -4.187500, color scheme 15, show scale bar, calibration: offset -0.000000, slope 0.000000 (Lepton 2.x), scale 4111-45000, spot sensor temperature 412442.250000, color scheme 3, minimum point enabled, calibration: offset -75402534979642766821519867692934234112.000000, slope 5815371847733706829839455140374904832.000000, dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.18, BuildID[sha1]=79dcc4e55a61c293c5e19edbd8d65b202842579f, stripped\012- data
+```
+
+Note how the type 1 AppImage is described as an `ISO 9660 CD-ROM filesystem`, and the type 2 AppImage is not.
+
+## Wrapping {#ssec-pkgs-appimageTools-wrapping}
+
+Depending on the type of AppImage you're wrapping, you'll have to use `wrapType1` or `wrapType2`.
+
+```nix
+appimageTools.wrapType2 { # or wrapType1
+  name = "patchwork";
+  src = fetchurl {
+    url = "https://github.com/ssbc/patchwork/releases/download/v3.11.4/Patchwork-3.11.4-linux-x86_64.AppImage";
+    sha256 = "1blsprpkvm0ws9b96gb36f0rbf8f5jgmw4x6dsb1kswr4ysf591s";
+  };
+  extraPkgs = pkgs: with pkgs; [ ];
+}
+```
+
+- `name` specifies the name of the resulting image.
+- `src` specifies the AppImage file to extract.
+- `extraPkgs` allows you to pass a function to include additional packages inside the FHS environment your AppImage is going to run in. There are a few ways to learn which dependencies an application needs:
+  - Looking through the extracted AppImage files, reading its scripts and running `patchelf` and `ldd` on its executables. This can also be done in `appimage-run`, by setting `APPIMAGE_DEBUG_EXEC=bash`.
+  - Running `strace -vfefile` on the wrapped executable, looking for libraries that can't be found.

doc/builders/images/appimagetools.xml

···
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xmlns:xi="http://www.w3.org/2001/XInclude"
-         xml:id="sec-pkgs-appimageTools">
- <title>pkgs.appimageTools</title>
-
- <para>
-  <varname>pkgs.appimageTools</varname> is a set of functions for extracting and wrapping <link xlink:href="https://appimage.org/">AppImage</link> files. They are meant to be used if traditional packaging from source is infeasible, or it would take too long. To quickly run an AppImage file, <literal>pkgs.appimage-run</literal> can be used as well.
- </para>
-
- <warning>
-  <para>
-   The <varname>appimageTools</varname> API is unstable and may be subject to backwards-incompatible changes in the future.
-  </para>
- </warning>
-
- <section xml:id="ssec-pkgs-appimageTools-formats">
-  <title>AppImage formats</title>
-
-  <para>
-   There are different formats for AppImages, see <link xlink:href="https://github.com/AppImage/AppImageSpec/blob/74ad9ca2f94bf864a4a0dac1f369dd4f00bd1c28/draft.md#image-format">the specification</link> for details.
-  </para>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     Type 1 images are ISO 9660 files that are also ELF executables.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Type 2 images are ELF executables with an appended filesystem.
-    </para>
-   </listitem>
-  </itemizedlist>
-
-  <para>
-   They can be told apart with <command>file -k</command>:
-  </para>
-
-<screen>
-<prompt>$ </prompt>file -k type1.AppImage
-type1.AppImage: ELF 64-bit LSB executable, x86-64, version 1 (SYSV) ISO 9660 CD-ROM filesystem data 'AppImage' (Lepton 3.x), scale 0-0,
-spot sensor temperature 0.000000, unit celsius, color scheme 0, calibration: offset 0.000000, slope 0.000000, dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.18, BuildID[sha1]=d629f6099d2344ad82818172add1d38c5e11bc6d, stripped\012- data
-
-<prompt>$ </prompt>file -k type2.AppImage
-type2.AppImage: ELF 64-bit LSB executable, x86-64, version 1 (SYSV) (Lepton 3.x), scale 232-60668, spot sensor temperature -4.187500, color scheme 15, show scale bar, calibration: offset -0.000000, slope 0.000000 (Lepton 2.x), scale 4111-45000, spot sensor temperature 412442.250000, color scheme 3, minimum point enabled, calibration: offset -75402534979642766821519867692934234112.000000, slope 5815371847733706829839455140374904832.000000, dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.18, BuildID[sha1]=79dcc4e55a61c293c5e19edbd8d65b202842579f, stripped\012- data
-</screen>
-
-  <para>
-   Note how the type 1 AppImage is described as an <literal>ISO 9660 CD-ROM filesystem</literal>, and the type 2 AppImage is not.
-  </para>
- </section>
-
- <section xml:id="ssec-pkgs-appimageTools-wrapping">
-  <title>Wrapping</title>
-
-  <para>
-   Depending on the type of AppImage you're wrapping, you'll have to use <varname>wrapType1</varname> or <varname>wrapType2</varname>.
-  </para>
-
-<programlisting>
-appimageTools.wrapType2 { # or wrapType1
-  name = "patchwork"; <co xml:id='ex-appimageTools-wrapping-1' />
-  src = fetchurl { <co xml:id='ex-appimageTools-wrapping-2' />
-    url = "https://github.com/ssbc/patchwork/releases/download/v3.11.4/Patchwork-3.11.4-linux-x86_64.AppImage";
-    sha256 =  "1blsprpkvm0ws9b96gb36f0rbf8f5jgmw4x6dsb1kswr4ysf591s";
-  };
-  extraPkgs = pkgs: with pkgs; [ ]; <co xml:id='ex-appimageTools-wrapping-3' />
-}</programlisting>
-
-  <calloutlist>
-   <callout arearefs='ex-appimageTools-wrapping-1'>
-    <para>
-     <varname>name</varname> specifies the name of the resulting image.
-    </para>
-   </callout>
-   <callout arearefs='ex-appimageTools-wrapping-2'>
-    <para>
-     <varname>src</varname> specifies the AppImage file to extract.
-    </para>
-   </callout>
-   <callout arearefs='ex-appimageTools-wrapping-3'>
-    <para>
-     <varname>extraPkgs</varname> allows you to pass a function to include additional packages inside the FHS environment your AppImage is going to run in. There are a few ways to learn which dependencies an application needs:
-     <itemizedlist>
-      <listitem>
-       <para>
-        Looking through the extracted AppImage files, reading its scripts and running <command>patchelf</command> and <command>ldd</command> on its executables. This can also be done in <command>appimage-run</command>, by setting <command>APPIMAGE_DEBUG_EXEC=bash</command>.
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        Running <command>strace -vfefile</command> on the wrapped executable, looking for libraries that can't be found.
-       </para>
-      </listitem>
-     </itemizedlist>
-    </para>
-   </callout>
-  </calloutlist>
- </section>
-</section>

doc/builders/images/snap/example-firefox.nix

···
-let
-  inherit (import <nixpkgs> { }) snapTools firefox;
-in snapTools.makeSnap {
-  meta = {
-    name = "nix-example-firefox";
-    summary = firefox.meta.description;
-    architectures = [ "amd64" ];
-    apps.nix-example-firefox = {
-      command = "${firefox}/bin/firefox";
-      plugs = [
-        "pulseaudio"
-        "camera"
-        "browser-support"
-        "avahi-observe"
-        "cups-control"
-        "desktop"
-        "desktop-legacy"
-        "gsettings"
-        "home"
-        "network"
-        "mount-observe"
-        "removable-media"
-        "x11"
-      ];
-    };
-    confinement = "strict";
-  };
-}

doc/builders/images/snap/example-hello.nix

···
-let
-  inherit (import <nixpkgs> { }) snapTools hello;
-in snapTools.makeSnap {
-  meta = {
-    name = "hello";
-    summary = hello.meta.description;
-    description = hello.meta.longDescription;
-    architectures = [ "amd64" ];
-    confinement = "strict";
-    apps.hello.command = "${hello}/bin/hello";
-  };
-}

doc/builders/images/snaptools.section.md

···
+# pkgs.snapTools {#sec-pkgs-snapTools}
+
+`pkgs.snapTools` is a set of functions for creating Snapcraft images. Snap and Snapcraft is not used to perform these operations.
+
+## The makeSnap Function {#ssec-pkgs-snapTools-makeSnap-signature}
+
+`makeSnap` takes a single named argument, `meta`. This argument mirrors [the upstream `snap.yaml` format](https://docs.snapcraft.io/snap-format) exactly.
+
+The `base` should not be specified, as `makeSnap` will force set it.
+
+Currently, `makeSnap` does not support creating GUI stubs.
+
+## Build a Hello World Snap {#ssec-pkgs-snapTools-build-a-snap-hello}
+
+The following expression packages GNU Hello as a Snapcraft snap.
+
+```{#ex-snapTools-buildSnap-hello .nix}
+let
+  inherit (import <nixpkgs> { }) snapTools hello;
+in snapTools.makeSnap {
+  meta = {
+    name = "hello";
+    summary = hello.meta.description;
+    description = hello.meta.longDescription;
+    architectures = [ "amd64" ];
+    confinement = "strict";
+    apps.hello.command = "${hello}/bin/hello";
+  };
+}
+```
+
+`nix-build` this expression and install it with `snap install ./result --dangerous`. `hello` will now be the Snapcraft version of the package.
+
+## Build a Graphical Snap {#ssec-pkgs-snapTools-build-a-snap-firefox}
+
+Graphical programs require many more integrations with the host. This example uses Firefox as an example, because it is one of the most complicated programs we could package.
+
+```{#ex-snapTools-buildSnap-firefox .nix}
+let
+  inherit (import <nixpkgs> { }) snapTools firefox;
+in snapTools.makeSnap {
+  meta = {
+    name = "nix-example-firefox";
+    summary = firefox.meta.description;
+    architectures = [ "amd64" ];
+    apps.nix-example-firefox = {
+      command = "${firefox}/bin/firefox";
+      plugs = [
+        "pulseaudio"
+        "camera"
+        "browser-support"
+        "avahi-observe"
+        "cups-control"
+        "desktop"
+        "desktop-legacy"
+        "gsettings"
+        "home"
+        "network"
+        "mount-observe"
+        "removable-media"
+        "x11"
+      ];
+    };
+    confinement = "strict";
+  };
+}
+```
+
+`nix-build` this expression and install it with `snap install ./result --dangerous`. `nix-example-firefox` will now be the Snapcraft version of the Firefox package.
+
+The specific meaning behind plugs can be looked up in the [Snapcraft interface documentation](https://docs.snapcraft.io/supported-interfaces).

doc/builders/images/snaptools.xml

···
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xmlns:xi="http://www.w3.org/2001/XInclude"
-         xml:id="sec-pkgs-snapTools">
- <title>pkgs.snapTools</title>
-
- <para>
-  <varname>pkgs.snapTools</varname> is a set of functions for creating Snapcraft images. Snap and Snapcraft is not used to perform these operations.
- </para>
-
- <section xml:id="ssec-pkgs-snapTools-makeSnap-signature">
-  <title>The makeSnap Function</title>
-
-  <para>
-   <function>makeSnap</function> takes a single named argument, <parameter>meta</parameter>. This argument mirrors <link xlink:href="https://docs.snapcraft.io/snap-format">the upstream <filename>snap.yaml</filename> format</link> exactly.
-  </para>
-
-  <para>
-   The <parameter>base</parameter> should not be specified, as <function>makeSnap</function> will force set it.
-  </para>
-
-  <para>
-   Currently, <function>makeSnap</function> does not support creating GUI stubs.
-  </para>
- </section>
-
- <section xml:id="ssec-pkgs-snapTools-build-a-snap-hello">
-  <title>Build a Hello World Snap</title>
-
-  <example xml:id="ex-snapTools-buildSnap-hello">
-   <title>Making a Hello World Snap</title>
-   <para>
-    The following expression packages GNU Hello as a Snapcraft snap.
-   </para>
-<programlisting><xi:include href="./snap/example-hello.nix" parse="text" /></programlisting>
-   <para>
-    <command>nix-build</command> this expression and install it with <command>snap install ./result --dangerous</command>. <command>hello</command> will now be the Snapcraft version of the package.
-   </para>
-  </example>
- </section>
-
- <section xml:id="ssec-pkgs-snapTools-build-a-snap-firefox">
-  <title>Build a Hello World Snap</title>
-
-  <example xml:id="ex-snapTools-buildSnap-firefox">
-   <title>Making a Graphical Snap</title>
-   <para>
-    Graphical programs require many more integrations with the host. This example uses Firefox as an example, because it is one of the most complicated programs we could package.
-   </para>
-<programlisting><xi:include href="./snap/example-firefox.nix" parse="text" /></programlisting>
-   <para>
-    <command>nix-build</command> this expression and install it with <command>snap install ./result --dangerous</command>. <command>nix-example-firefox</command> will now be the Snapcraft version of the Firefox package.
-   </para>
-   <para>
-    The specific meaning behind plugs can be looked up in the <link xlink:href="https://docs.snapcraft.io/supported-interfaces">Snapcraft interface documentation</link>.
-   </para>
-  </example>
- </section>
-</section>

lib/systems/doubles.nix

···
     "mmix-mmixware"
 
     # NetBSD
-    "i686-netbsd" "x86_64-netbsd"
+    "aarch64-netbsd" "armv6l-netbsd" "armv7a-netbsd" "armv7l-netbsd"
+    "i686-netbsd" "mipsel-netbsd" "powerpc-netbsd" "riscv32-netbsd"
+    "riscv64-netbsd" "x86_64-netbsd"
 
     # none
     "aarch64-none" "arm-none" "armv6l-none" "avr-none" "i686-none" "msp430-none"

lib/tests/systems.nix

···
 with lib.systems.doubles; lib.runTests {
   testall = mseteq all (linux ++ darwin ++ freebsd ++ openbsd ++ netbsd ++ illumos ++ wasi ++ windows ++ embedded ++ mmix ++ js ++ genode ++ redox);
 
-  testarm = mseteq arm [ "armv5tel-linux" "armv6l-linux" "armv6l-none" "armv7a-linux" "armv7l-linux" "arm-none" "armv7a-darwin" ];
+  testarm = mseteq arm [ "armv5tel-linux" "armv6l-linux" "armv6l-netbsd" "armv6l-none" "armv7a-linux" "armv7a-netbsd" "armv7l-linux" "armv7l-netbsd" "arm-none" "armv7a-darwin" ];
   testi686 = mseteq i686 [ "i686-linux" "i686-freebsd" "i686-genode" "i686-netbsd" "i686-openbsd" "i686-cygwin" "i686-windows" "i686-none" "i686-darwin" ];
-  testmips = mseteq mips [ "mipsel-linux" ];
+  testmips = mseteq mips [ "mipsel-linux" "mipsel-netbsd" ];
   testmmix = mseteq mmix [ "mmix-mmixware" ];
   testx86_64 = mseteq x86_64 [ "x86_64-linux" "x86_64-darwin" "x86_64-freebsd" "x86_64-genode" "x86_64-redox" "x86_64-openbsd" "x86_64-netbsd" "x86_64-cygwin" "x86_64-solaris" "x86_64-windows" "x86_64-none" ];
 
···
   testgnu = mseteq gnu (linux /* ++ kfreebsd ++ ... */);
   testillumos = mseteq illumos [ "x86_64-solaris" ];
   testlinux = mseteq linux [ "aarch64-linux" "armv5tel-linux" "armv6l-linux" "armv7a-linux" "armv7l-linux" "i686-linux" "mipsel-linux" "riscv32-linux" "riscv64-linux" "x86_64-linux" "powerpc64-linux" "powerpc64le-linux" ];
-  testnetbsd = mseteq netbsd [ "i686-netbsd" "x86_64-netbsd" ];
+  testnetbsd = mseteq netbsd [ "aarch64-netbsd" "armv6l-netbsd" "armv7a-netbsd" "armv7l-netbsd" "i686-netbsd" "mipsel-netbsd" "powerpc-netbsd" "riscv32-netbsd" "riscv64-netbsd" "x86_64-netbsd" ];
   testopenbsd = mseteq openbsd [ "i686-openbsd" "x86_64-openbsd" ];
   testwindows = mseteq windows [ "i686-cygwin" "x86_64-cygwin" "i686-windows" "x86_64-windows" ];
   testunix = mseteq unix (linux ++ darwin ++ freebsd ++ openbsd ++ netbsd ++ illumos ++ cygwin ++ redox);

nixos/modules/module-list.nix

···
   ./programs/file-roller.nix
   ./programs/firejail.nix
   ./programs/fish.nix
+  ./programs/flexoptix-app.nix
   ./programs/freetds.nix
   ./programs/fuse.nix
   ./programs/geary.nix

nixos/modules/programs/flexoptix-app.nix

···
+{ config, pkgs, lib, ... }:
+
+with lib;
+
+let
+  cfg = config.programs.flexoptix-app;
+in {
+  options = {
+    programs.flexoptix-app = {
+      enable = mkEnableOption "FLEXOPTIX app + udev rules";
+
+      package = mkOption {
+        description = "FLEXOPTIX app package to use";
+        type = types.package;
+        default = pkgs.flexoptix-app;
+        defaultText = "\${pkgs.flexoptix-app}";
+      };
+    };
+  };
+
+  config = mkIf cfg.enable {
+    environment.systemPackages = [ cfg.package ];
+    services.udev.packages = [ cfg.package ];
+  };
+}

nixos/modules/services/monitoring/nagios.nix

···
       path     = [ pkgs.nagios ] ++ cfg.plugins;
       wantedBy = [ "multi-user.target" ];
       after    = [ "network.target" ];
+      restartTriggers = [ nagiosCfgFile ];
 
       serviceConfig = {
         User = "nagios";
···
         LogsDirectory = "nagios";
         StateDirectory = "nagios";
         ExecStart = "${pkgs.nagios}/bin/nagios /etc/nagios.cfg";
-        X-ReloadIfChanged = nagiosCfgFile;
       };
     };
 

nixos/modules/services/web-apps/mastodon.nix

···
   // (if cfg.smtp.authenticate then { SMTP_LOGIN  = cfg.smtp.user; } else {})
   // cfg.extraConfig;
 
+  systemCallsList = [ "@clock" "@cpu-emulation" "@debug" "@keyring" "@module" "@mount" "@obsolete" "@raw-io" "@reboot" "@resources" "@setuid" "@swap" ];
+
   cfgService = {
     # User and group
     User = cfg.user;
···
     PrivateMounts = true;
     # System Call Filtering
     SystemCallArchitectures = "native";
-    SystemCallFilter = "~@clock @cpu-emulation @debug @keyring @module @mount @obsolete @reboot @resources @setuid @swap";
   };
 
   envFile = pkgs.writeText "mastodon.env" (lib.concatMapStrings (s: s + "\n") (
···
       serviceConfig = {
         Type = "oneshot";
         WorkingDirectory = cfg.package;
+        # System Call Filtering
+        SystemCallFilter = "~" + lib.concatStringsSep " " systemCallsList;
       } // cfgService;
 
       after = [ "network.target" ];
···
         Type = "oneshot";
         EnvironmentFile = "/var/lib/mastodon/.secrets_env";
         WorkingDirectory = cfg.package;
+        # System Call Filtering
+        SystemCallFilter = "~" + lib.concatStringsSep " " systemCallsList;
       } // cfgService;
       after = [ "mastodon-init-dirs.service" "network.target" ] ++ (if databaseActuallyCreateLocally then [ "postgresql.service" ] else []);
       wantedBy = [ "multi-user.target" ];
···
         # Runtime directory and mode
         RuntimeDirectory = "mastodon-streaming";
         RuntimeDirectoryMode = "0750";
+        # System Call Filtering
+        SystemCallFilter = "~" + lib.concatStringsSep " " (systemCallsList ++ [ "@privileged" ]);
       } // cfgService;
     };
 
···
         # Runtime directory and mode
         RuntimeDirectory = "mastodon-web";
         RuntimeDirectoryMode = "0750";
+        # System Call Filtering
+        SystemCallFilter = "~" + lib.concatStringsSep " " (systemCallsList ++ [ "@privileged" ]);
       } // cfgService;
       path = with pkgs; [ file imagemagick ffmpeg ];
     };
···
         RestartSec = 20;
         EnvironmentFile = "/var/lib/mastodon/.secrets_env";
         WorkingDirectory = cfg.package;
+        # System Call Filtering
+        SystemCallFilter = "~" + lib.concatStringsSep " " (systemCallsList ++ [ "@privileged" ]);
       } // cfgService;
       path = with pkgs; [ file imagemagick ffmpeg ];
     };

nixos/modules/services/web-servers/nginx/default.nix

···
     users.users = optionalAttrs (cfg.user == "nginx") {
       nginx = {
         group = cfg.group;
+        isSystemUser = true;
         uid = config.ids.uids.nginx;
       };
     };

nixos/tests/prometheus-exporters.nix

···
       metricProvider = {
         services.bird2.enable = true;
         services.bird2.config = ''
+          router id 127.0.0.1;
+
           protocol kernel MyObviousTestString {
             ipv4 {
               import all;
···
       exporterTest = ''
         wait_for_unit("prometheus-bird-exporter.service")
         wait_for_open_port(9324)
-        succeed("curl -sSf http://localhost:9324/metrics | grep -q 'MyObviousTestString'")
+        wait_until_succeeds(
+            "curl -sSf http://localhost:9324/metrics | grep -q 'MyObviousTestString'"
+        )
       '';
     };
 

pkgs/applications/audio/pulseeffects/default.nix

···
   ];
 in stdenv.mkDerivation rec {
   pname = "pulseeffects";
-  # 5.0.3 crashes. Test carefully before updating.
-  # https://github.com/wwmm/pulseeffects/issues/927
-  version = "5.0.2";
+  version = "5.0.3";
 
   src = fetchFromGitHub {
     owner = "wwmm";
     repo = "pulseeffects";
     rev = "v${version}";
-    sha256 = "14ir25q6bws26im6qmj3k6hkfdh5pc6mbvln7wkdwy5dv0vix3cm";
+    sha256 = "1dicvq17vajk3vr4g1y80599ahkw0dp5ynlany1cfljfjz40s8sx";
   };
 
   nativeBuildInputs = [

pkgs/applications/graphics/pixelnuke/default.nix

···
+{ lib, stdenv, fetchFromGitHub, libevent, glew, glfw }:
+
+stdenv.mkDerivation {
+  pname = "pixelnuke";
+  version = "unstable-2019-05-19";
+
+  src = fetchFromGitHub {
+    owner = "defnull";
+    repo = "pixelflut";
+    rev = "3458157a242ba1789de7ce308480f4e1cbacc916";
+    sha256 = "03dp0p00chy00njl4w02ahxqiwqpjsrvwg8j4yi4dgckkc3gbh40";
+  };
+
+  sourceRoot = "source/pixelnuke";
+
+  buildInputs = [ libevent glew glfw ];
+
+  installPhase = ''
+    install -Dm755 ./pixelnuke $out/bin/pixelnuke
+  '';
+
+  meta = with lib; {
+    description = "Multiplayer canvas (C implementation)";
+    homepage = "https://cccgoe.de/wiki/Pixelflut";
+    license = licenses.unlicense;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ mrVanDalo ];
+  };
+}

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

···
   buildPath = "out/${buildType}";
   libExecPath = "$out/libexec/${packageName}";
 
+  warnObsoleteVersionConditional = min-version: result:
+    let ungoogled-version = (importJSON ./upstream-info.json).ungoogled-chromium.version;
+    in if versionAtLeast ungoogled-version min-version
+       then warn "chromium: ungoogled version ${ungoogled-version} is newer than a conditional bounded at ${min-version}. You can safely delete it."
+            result
+       else result;
   chromiumVersionAtLeast = min-version:
-    versionAtLeast upstream-info.version min-version;
+    let result = versionAtLeast upstream-info.version min-version;
+    in  warnObsoleteVersionConditional min-version result;
   versionRange = min-version: upto-version:
     let inherit (upstream-info) version;
         result = versionAtLeast version min-version && versionOlder version upto-version;
-        ungoogled-version = (importJSON ./upstream-info.json).ungoogled-chromium.version;
-    in if versionAtLeast ungoogled-version upto-version
-       then warn "chromium: ungoogled version ${ungoogled-version} is newer than a patchset bounded at ${upto-version}. You can safely delete it."
-            result
-       else result;
+    in warnObsoleteVersionConditional upto-version result;
 
   ungoogler = ungoogled-chromium {
     inherit (upstream-info.deps.ungoogled-patches) rev sha256;
···
     patches = [
       ./patches/no-build-timestamps.patch # Optional patch to use SOURCE_DATE_EPOCH in compute_build_timestamp.py (should be upstreamed)
       ./patches/widevine-79.patch # For bundling Widevine (DRM), might be replaceable via bundle_widevine_cdm=true in gnFlags
-      # ++ optional (versionRange "68" "72") (githubPatch "<patch>" "0000000000000000000000000000000000000000000000000000000000000000")
-    ] ++ optional (versionRange "89" "90.0.4402.0") (githubPatch
-      # To fix the build of chromiumBeta and chromiumDev:
-      "b5b80df7dafba8cafa4c6c0ba2153dfda467dfc9" # add dependency on opus in webcodecs
-      "1r4wmwaxz5xbffmj5wspv2xj8s32j9p6jnwimjmalqg3al2ba64x"
-    ) ++ optional (versionRange "89" "90.0.4422.0") (fetchpatch {
-      url = "https://raw.githubusercontent.com/archlinux/svntogit-packages/61b0ab526d2aa3c62fa20bb756461ca9a482f6c6/trunk/chromium-fix-libva-redef.patch";
-      sha256 = "1qj4sn1ngz0p1l1w3346kanr1sqlr3xdzk1f1i86lqa45mhv77ny";
-    }) ++ optional (chromiumVersionAtLeast "90")
+      # Fix the build by adding a missing dependency (s. https://crbug.com/1197837):
       ./patches/fix-missing-atspi2-dependency.patch
-    ++ optionals (chromiumVersionAtLeast "91") [
+    ] ++ optionals (chromiumVersionAtLeast "91") [
       ./patches/closure_compiler-Use-the-Java-binary-from-the-system.patch
     ];
 
···
     } // optionalAttrs pulseSupport {
       use_pulseaudio = true;
       link_pulseaudio = true;
-    } // optionalAttrs (chromiumVersionAtLeast "89") {
-      rtc_pipewire_version = "0.3"; # TODO: Can be removed once ungoogled-chromium is at M90
       # Disable PGO (defaults to 2 since M89) because it fails without additional changes:
       # error: Could not read profile ../../chrome/build/pgo_profiles/chrome-linux-master-1610647094-405a32bcf15e5a84949640f99f84a5b9f61e2f2e.profdata: Unsupported instrumentation profile format version
       chrome_pgo_phase = 0;
-    } // optionalAttrs (chromiumVersionAtLeast "90") {
       # Disable build with TFLite library because it fails without additional changes:
       # ninja: error: '../../chrome/test/data/simple_test.tflite', needed by 'test_data/simple_test.tflite', missing and no known rule to make it
       # Note: chrome/test/data/simple_test.tflite is in the Git repository but not in chromium-90.0.4400.8.tar.xz

pkgs/applications/networking/browsers/chromium/upstream-info.json

···
     }
   },
   "ungoogled-chromium": {
-    "version": "89.0.4389.114",
-    "sha256": "007df9p78bbmk3iyfi8qn57mmn68qqrdhx6z8n2hl8ksd7lspw7j",
-    "sha256bin64": "06wblyvyr93032fbzwm6qpzz4jjm6adziq4i4n6kmfdix2ajif8a",
+    "version": "90.0.4430.85",
+    "sha256": "08j9shrc6p0vpa3x7av7fj8wapnkr7h6m8ag1gh6gaky9d6mki81",
+    "sha256bin64": "0li9w6zfsmx5r90jm5v5gfv3l2a76jndg6z5jvb9yx9xvrp9gpir",
     "deps": {
       "gn": {
-        "version": "2021-01-07",
+        "version": "2021-02-09",
         "url": "https://gn.googlesource.com/gn",
-        "rev": "595e3be7c8381d4eeefce62a63ec12bae9ce5140",
-        "sha256": "08y7cjlgjdbzja5ij31wxc9i191845m01v1hc7y176svk9y0hj1d"
+        "rev": "dfcbc6fed0a8352696f92d67ccad54048ad182b3",
+        "sha256": "1941bzg37c4dpsk3sh6ga3696gpq6vjzpcw9rsnf6kdr9mcgdxvn"
       },
       "ungoogled-patches": {
-        "rev": "89.0.4389.114-1",
-        "sha256": "0cr2i51gxhgl55c8f9w0ra3m5q2dk03sf7p2qn4bqq1l1l72hw6s"
+        "rev": "90.0.4430.85-1",
+        "sha256": "04nrx6fgkizmza50xj236m4rb1j8yaw0cw5790df1vlmbsc81667"
       }
     }
   }

pkgs/applications/networking/cluster/terraform-providers/providers.json

···
     "version": "1.5.0"
   },
   "rancher2": {
-    "owner": "terraform-providers",
+    "owner": "rancher",
+    "provider-source-address": "registry.terraform.io/hashicorp/rancher2",
     "repo": "terraform-provider-rancher2",
-    "rev": "v1.8.3",
-    "sha256": "1k2d9j17b7sssliraww6as196ihdcra1ylhg1qbynklpr0asiwna",
-    "version": "1.8.3"
+    "rev": "v1.13.0",
+    "sha256": "0xczv9qsviryiw95yd6cl1nnb0daxs971fm733gfvwm36jvmyr89",
+    "vendorSha256": "0apy6qbmshfj4pzz9nqdhyk6h7l9qwrccz30q8ljl928pj49q04c",
+    "version": "1.13.0"
   },
   "random": {
     "owner": "hashicorp",

pkgs/applications/radio/airspy/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "airspy";
-  version = "1.0.9";
+  version = "1.0.10";
 
   src = fetchFromGitHub {
     owner = "airspy";
     repo = "airspyone_host";
     rev = "v${version}";
-    sha256 = "04kx2p461sqd4q354n1a99zcabg9h29dwcnyhakykq8bpg3mgf1x";
+    sha256 = "1v7sfkkxc6f8ny1p9xrax1agkl6q583mjx8k0lrrwdz31rf9qgw9";
   };
 
   postPatch = ''

pkgs/applications/version-management/git-and-tools/git-chglog/default.nix

···
-{ lib, buildGoPackage, fetchFromGitHub }:
+{ lib, fetchFromGitHub, buildGoModule }:
 
-buildGoPackage rec {
+buildGoModule rec {
   pname = "git-chglog";
-  version = "0.9.1";
-
-  goPackagePath = "github.com/git-chglog/git-chglog";
+  version = "0.14.2";
 
   src = fetchFromGitHub {
     owner = "git-chglog";
     repo = "git-chglog";
-    rev = version;
-    sha256 = "08x7w1jlvxxvwnz6pvkjmfd3nqayd8n15r9jbqi2amrp31z0gq0p";
+    rev = "v${version}";
+    sha256 = "124bqywkj37gv61fswgrg528bf3rjqms1664x22lkn0sqh22zyv1";
   };
 
+  vendorSha256 = "09zjypmcc3ra7sw81q1pbbrlpxxp4k00p1cfkrrih8wvb25z89h5";
+
+  buildFlagsArray = [ "-ldflags= -s -w -X=main.Version=v${version}" ];
+
+  subPackages = [ "cmd/git-chglog" ];
+
   meta = with lib; {
     description = "CHANGELOG generator implemented in Go (Golang)";
+    homepage = "https://github.com/git-chglog/git-chglog";
     license = licenses.mit;
     maintainers = with maintainers; [ ldenefle ];
   };

pkgs/applications/video/mkvtoolnix/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "mkvtoolnix";
-  version = "55.0.0";
+  version = "56.0.0";
 
   src = fetchFromGitLab {
     owner  = "mbunkus";
     repo   = "mkvtoolnix";
     rev    = "release-${version}";
-    sha256 = "129azp4cpdd05f6072gkxdjj811aqs29nbw6v6qm8vv47gfvjcf7";
+    sha256 = "0nhpp1zkggxqjj7lhj6as5mcjcz5yk3l1d1xcgs7i9153blam1yj";
   };
 
   nativeBuildInputs = [

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

···
+{ lib
+, rustPlatform
+, fetchFromGitHub
+}:
+
+rustPlatform.buildRustPackage rec {
+  pname = "workstyle";
+  version = "0.2.1";
+
+  src = fetchFromGitHub {
+    owner = "pierrechevalier83";
+    repo = pname;
+    rev = "43b0b5bc0a66d40289ff26b8317f50510df0c5f9";
+    sha256 = "0f4hwf236823qmqy31fczjb1hf3fvvac3x79jz2l7li55r6fd8hn";
+  };
+
+  cargoSha256 = "1hy68wvsxncsy4yx4biigfvwyq18c7yp1g543c6nca15cdzs1c54";
+
+  doCheck = false; # No tests
+
+  meta = with lib; {
+    description = "Sway workspaces with style";
+    homepage = "https://github.com/pierrechevalier83/workstyle";
+    license = licenses.mit;
+    maintainers = with maintainers; [ FlorianFranzen ];
+  };
+}

pkgs/desktops/mate/atril/default.nix

···
 , enablePostScript ? true, libspectre
 , enableXps ? true, libgxps
 , enableImages ? false
+, mateUpdateScript
 }:
 
 with lib;
 
 stdenv.mkDerivation rec {
   pname = "atril";
-  version = "1.24.0";
+  version = "1.24.1";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "0967gxw7h2qh2kpwl0jgv58hicz6aa92kr12mnykbpikad25s95y";
+    sha256 = "06nyicj96dqcv035yqnzmm6pk3m35glxj0ny6lk1vwqkk2l750xl";
   };
 
   nativeBuildInputs = [
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "A simple multi-page document viewer for the MATE desktop";
     homepage = "https://mate-desktop.org";
-    license = licenses.gpl2;
+    license = licenses.gpl2Plus;
     platforms = platforms.unix;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/caja-dropbox/default.nix

···
 { lib, stdenv, fetchurl, substituteAll
 , pkg-config, gobject-introspection, gdk-pixbuf
-, gtk3, mate, python3, dropbox }:
+, gtk3, mate, python3, dropbox, mateUpdateScript }:
 
 let
   dropboxd = "${dropbox}/bin/dropbox";
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "Dropbox extension for Caja file manager";
     homepage = "https://github.com/mate-desktop/caja-dropbox";
-    license = with licenses; [ gpl3 cc-by-nd-30 ];
+    license = with licenses; [ gpl3Plus cc-by-nd-30 ];
     platforms = platforms.unix;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/caja-extensions/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, gupnp, mate, imagemagick, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, gupnp, mate, imagemagick, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "caja-extensions";
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "Set of extensions for Caja file manager";
     homepage = "https://mate-desktop.org";
-    license = licenses.gpl2;
+    license = licenses.gpl2Plus;
     platforms = platforms.unix;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/caja-with-extensions/default.nix

···
-{ stdenv, lib, makeWrapper, caja-extensions, caja, extensions ? [ caja-extensions ] }:
+{ stdenv, lib, makeWrapper, caja-extensions, caja, extensions ? [ caja-extensions ], mateUpdateScript }:
 
 stdenv.mkDerivation {
   pname = "${caja.pname}-with-extensions";

pkgs/desktops/mate/caja/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, libnotify, libxml2, libexif, exempi, mate, hicolor-icon-theme, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, libnotify, libxml2, libexif, exempi, mate, hicolor-icon-theme, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "caja";
-  version = "1.24.0";
+  version = "1.24.1";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "1cnfy481hcwjv3ia3kw0d4h7ga8cng0pqm3z349v4qcmfdapmqc0";
+    sha256 = "0ylgb4b31vwgqmmknrhm4m9gfa1rzb9azpdd9myi0hscrr3h22z5";
   };
 
   nativeBuildInputs = [
···
 
   enableParallelBuilding = true;
 
-  meta = {
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
+  meta = with lib; {
     description = "File manager for the MATE desktop";
     homepage = "https://mate-desktop.org";
-    license = with lib.licenses; [ gpl2 lgpl2 ];
-    platforms = lib.platforms.unix;
-    maintainers = [ lib.maintainers.romildo ];
+    license = with licenses; [ gpl2Plus lgpl2Plus ];
+    platforms = platforms.unix;
+    maintainers = [ maintainers.romildo ];
   };
 }

pkgs/desktops/mate/default.nix

···
-{ newScope }:
+{ pkgs, newScope }:
 
 let
   callPackage = newScope self;
 
   self = rec {
+
+    # Update script tailored to mate packages from git repository
+    mateUpdateScript = { pname, version, odd-unstable ? true, url ? "https://pub.mate-desktop.org/releases" }:
+      pkgs.genericUpdater {
+        inherit pname version odd-unstable;
+        attrPath = "mate.${pname}";
+        versionLister = "${pkgs.common-updater-scripts}/bin/list-archive-two-level-versions ${url}";
+      };
 
     atril = callPackage ./atril { };
     caja = callPackage ./caja { };

pkgs/desktops/mate/engrampa/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, libxml2, gtk3, file, mate, hicolor-icon-theme, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, libxml2, gtk3, file, mate, hicolor-icon-theme, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "engrampa";
-  version = "1.24.1";
+  version = "1.24.2";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "0akjnz85qkpiqgj1ccn41rzbfid4l3r3nsm4s9s779ilzd7f097y";
+    sha256 = "0x26djz73g3fjwzcpr7k60xb6qx5izhw7lf2ggn34iwpihl0sa7f";
   };
 
   nativeBuildInputs = [
···
 
   enableParallelBuilding = true;
 
-  meta = {
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
+  meta = with lib; {
     description = "Archive Manager for MATE";
     homepage = "https://mate-desktop.org";
-    license = lib.licenses.gpl2;
-    platforms = lib.platforms.unix;
-    maintainers = [ lib.maintainers.romildo ];
+    license = with licenses; [ gpl2Plus lgpl2Plus fdl11Plus ];
+    platforms = platforms.unix;
+    maintainers = [ maintainers.romildo ];
   };
 }

pkgs/desktops/mate/eom/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, exempi, lcms2, libexif, libjpeg, librsvg, libxml2, libpeas, shared-mime-info, gtk3, mate, hicolor-icon-theme, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, exempi, lcms2, libexif, libjpeg, librsvg, libxml2, libpeas, shared-mime-info, gtk3, mate, hicolor-icon-theme, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "eom";
-  version = "1.24.1";
+  version = "1.24.2";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "0dralsc0dvs0l38cysdhx6kiaiqlb8qi6g9xz2cm6mjqyq3d3f9f";
+    sha256 = "08rjckr1hdw7c31f2hzz3vq0rn0c5z3hmvl409y6k6ns583k1bgf";
   };
 
   nativeBuildInputs = [
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = {
     description = "An image viewing and cataloging program for the MATE desktop";
     homepage = "https://mate-desktop.org";
-    license = lib.licenses.gpl2;
+    license = lib.licenses.gpl2Plus;
     platforms = lib.platforms.unix;
     maintainers = [ lib.maintainers.romildo ];
   };

pkgs/desktops/mate/libmatekbd/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, libxklavier }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, libxklavier, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "libmatekbd";
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "Keyboard management library for MATE";
     homepage = "https://github.com/mate-desktop/libmatekbd";
-    license = licenses.gpl2;
+    license = licenses.gpl2Plus;
     platforms = platforms.unix;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/libmatemixer/default.nix

···
 , alsaSupport ? stdenv.isLinux, alsaLib
 , pulseaudioSupport ? config.pulseaudio or true, libpulseaudio
 , ossSupport ? false
- }:
+, mateUpdateScript
+}:
 
 stdenv.mkDerivation rec {
   pname = "libmatemixer";
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "Mixer library for MATE";
     homepage = "https://github.com/mate-desktop/libmatemixer";
-    license = with licenses; [ gpl2 lgpl2 ];
+    license = licenses.lgpl2Plus;
     platforms = platforms.linux;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/libmateweather/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, libsoup, tzdata }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, libsoup, tzdata, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "libmateweather";
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "Library to access weather information from online services for MATE";
     homepage = "https://github.com/mate-desktop/libmateweather";
-    license = licenses.gpl2;
+    license = licenses.gpl2Plus;
     platforms = platforms.unix;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/marco/default.nix

···
 { lib, stdenv, fetchurl, pkg-config, gettext, itstool, libxml2, libcanberra-gtk3, libgtop
-, libXdamage, libXpresent, libstartup_notification, gnome3, gtk3, mate-settings-daemon, wrapGAppsHook }:
+, libXdamage, libXpresent, libstartup_notification, gnome3, gtk3, mate-settings-daemon, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "marco";
-  version = "1.24.1";
+  version = "1.24.2";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "109b41pjrc1b4slw6sx1lakdhrc46x829vczzk4bz3j15kcszg54";
+    sha256 = "19s2y2s9immp86ni3395mgxl605m2wn10m8399y9qkgw2b5m10s9";
   };
 
   nativeBuildInputs = [
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "MATE default window manager";
     homepage = "https://github.com/mate-desktop/marco";
-    license = [ licenses.gpl2 ];
+    license = [ licenses.gpl2Plus ];
     platforms = platforms.unix;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/mate-applets/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, gnome3, glib, gtk3, gtksourceview3, libwnck3, libgtop, libxml2, libnotify, polkit, upower, wirelesstools, mate, hicolor-icon-theme, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, gnome3, glib, gtk3, gtksourceview3, libwnck3
+, libgtop, libxml2, libnotify, polkit, upower, wirelesstools, mate, hicolor-icon-theme, wrapGAppsHook
+, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-applets";
···
   NIX_CFLAGS_COMPILE = "-I${glib.dev}/include/gio-unix-2.0";
 
   enableParallelBuilding = true;
+
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
 
   meta = with lib; {
     description = "Applets for use with the MATE panel";

pkgs/desktops/mate/mate-backgrounds/default.nix

···
-{ lib, stdenv, fetchurl, meson, ninja, gettext }:
+{ lib, stdenv, fetchurl, meson, ninja, gettext, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-backgrounds";
···
     ninja
   ];
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "Background images and data for MATE";
     homepage = "https://mate-desktop.org";
-    license = licenses.gpl2;
+    license = with licenses; [ gpl2Plus cc-by-sa-40 ];
     platforms = platforms.unix;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/mate-calc/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, gtk3, libxml2, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, gtk3, libxml2, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-calc";
-  version = "1.24.1";
+  version = "1.24.2";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "0imdimq5d5rjq8mkjcrsd683a2bn9acmhc0lmvyw71y0040inbaw";
+    sha256 = "1yg8j0dqy37fljd20pwxdgna3f1v7k9wmdr9l4r1nqf4a7zwi96l";
   };
 
   nativeBuildInputs = [
···
   ];
 
   enableParallelBuilding = true;
+
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
 
   meta = with lib; {
     description = "Calculator for the MATE desktop";

pkgs/desktops/mate/mate-common/default.nix

···
-{ lib, stdenv, fetchurl }:
+{ lib, stdenv, fetchurl, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-common";
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = {
     description = "Common files for development of MATE packages";
     homepage = "https://mate-desktop.org";
-    license = lib.licenses.gpl3;
+    license = lib.licenses.gpl3Plus;
     platforms = lib.platforms.unix;
     maintainers = [ lib.maintainers.romildo ];
   };

pkgs/desktops/mate/mate-control-center/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, libxml2, dbus-glib,
-  libxklavier, libcanberra-gtk3, librsvg, libappindicator-gtk3,
-  desktop-file-utils, dconf, gtk3, polkit, mate, hicolor-icon-theme, wrapGAppsHook
+{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, libxml2, dbus-glib
+, libxklavier, libcanberra-gtk3, librsvg, libappindicator-gtk3
+, desktop-file-utils, dconf, gtk3, polkit, mate, hicolor-icon-theme, wrapGAppsHook
+, mateUpdateScript
 }:
 
 stdenv.mkDerivation rec {
   pname = "mate-control-center";
-  version = "1.24.1";
+  version = "1.24.2";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "08bai47fsmbxlw2lhig9n6c8sxr24ixkd1spq3j0635yzcqighb0";
+    sha256 = "18vsqkcl4n3k5aa05fqha61jc3133zw07gd604sm0krslwrwdn39";
   };
 
   nativeBuildInputs = [
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "Utilities to configure the MATE desktop";
     homepage = "https://github.com/mate-desktop/mate-control-center";
-    license = licenses.gpl2;
+    license = licenses.gpl2Plus;
     platforms = platforms.unix;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/mate-desktop/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, isocodes, gnome3, gtk3, dconf, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, isocodes, gnome3, gtk3, dconf, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-desktop";
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "Library with common API for various MATE modules";
     homepage = "https://mate-desktop.org";
-    license = licenses.gpl2;
+    license = licenses.gpl2Plus;
     platforms = platforms.linux;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/mate-icon-theme-faenza/default.nix

···
-{ lib, stdenv, fetchurl, autoreconfHook, gtk3, mate, hicolor-icon-theme }:
+{ lib, stdenv, fetchurl, autoreconfHook, gtk3, mate, hicolor-icon-theme, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-icon-theme-faenza";
···
 
   enableParallelBuilding = true;
 
-  meta = {
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
+  meta = with lib; {
     description = "Faenza icon theme from MATE";
     homepage = "https://mate-desktop.org";
-    license = lib.licenses.gpl2;
-    platforms = lib.platforms.unix;
-    maintainers = [ lib.maintainers.romildo ];
+    license = licenses.gpl2Plus;
+    platforms = platforms.unix;
+    maintainers = [ maintainers.romildo ];
   };
 }

pkgs/desktops/mate/mate-icon-theme/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, iconnamingutils, librsvg, gtk3, hicolor-icon-theme }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, iconnamingutils, librsvg, gtk3, hicolor-icon-theme, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-icon-theme";
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = {
     description = "Icon themes from MATE";
     homepage = "https://mate-desktop.org";
-    license = lib.licenses.lgpl3;
+    license = lib.licenses.lgpl3Plus;
     platforms = lib.platforms.linux;
     maintainers = [ lib.maintainers.romildo ];
   };

pkgs/desktops/mate/mate-indicator-applet/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, libindicator-gtk3, mate, hicolor-icon-theme, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, libindicator-gtk3, mate, hicolor-icon-theme, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-indicator-applet";
···
   ];
 
   enableParallelBuilding = true;
+
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
 
   meta = with lib; {
     homepage = "https://github.com/mate-desktop/mate-indicator-applet";

pkgs/desktops/mate/mate-media/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, libtool, libxml2, libcanberra-gtk3, gtk3, mate, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, libtool, libxml2, libcanberra-gtk3, gtk3, mate, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-media";
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "Media tools for MATE";
     homepage = "https://mate-desktop.org";
-    license = licenses.gpl3;
+    license = licenses.gpl2Plus;
     platforms = platforms.unix;
     maintainers = [ maintainers.romildo maintainers.chpatrick ];
   };

pkgs/desktops/mate/mate-menus/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, glib, gobject-introspection, python3 }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, glib, gobject-introspection, python3, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-menus";
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "Menu system for MATE";
     homepage = "https://github.com/mate-desktop/mate-menus";
-    license = with licenses; [ gpl2 lgpl2 ];
+    license = with licenses; [ gpl2Plus lgpl2Plus ];
     platforms = platforms.unix;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/mate-netbook/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, libwnck3, libfakekey, libXtst, mate, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, libwnck3, libfakekey, libXtst, mate, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-netbook";
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "MATE utilities for netbooks";
     longDescription = ''
···
       devices with low resolution displays.
     '';
     homepage = "https://mate-desktop.org";
-    license = with licenses; [ gpl3 lgpl2Plus ];
+    license = with licenses; [ gpl3Only lgpl2Plus ];
     platforms = platforms.unix;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/mate-notification-daemon/default.nix

···
 { lib, stdenv, fetchurl, pkg-config, gettext, glib, libcanberra-gtk3,
-  libnotify, libwnck3, gtk3, libxml2, wrapGAppsHook }:
+  libnotify, libwnck3, gtk3, libxml2, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-notification-daemon";
-  version = "1.24.1";
+  version = "1.24.2";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "1ybzr8mni5pgrspf8hqnisd0r0hwdlgk7n5mzsh7xisbkgivpw2b";
+    sha256 = "02mf9186cbziyvz7ycb0j9b7rn085a7f9hrm03n28q5kz0z1k92q";
   };
 
   nativeBuildInputs = [
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "Notification daemon for MATE Desktop";
     homepage = "https://github.com/mate-desktop/mate-notification-daemon";
-    license = licenses.gpl2;
+    license = with licenses; [ gpl2Plus gpl3Plus ];
     platforms = platforms.unix;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/mate-panel/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, glib, libwnck3, librsvg, libxml2, dconf, gtk3, mate, hicolor-icon-theme, gobject-introspection, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, glib, libwnck3, librsvg, libxml2, dconf, gtk3, mate, hicolor-icon-theme, gobject-introspection, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-panel";
-  version = "1.24.1";
+  version = "1.24.2";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "0xblqrhfazd01h0jdmx4hvavkb7f9anbd4rjsk5r6wxhp027l64l";
+    sha256 = "1sj851h71nq4ssrsd4k5b0vayxmspl5x3rhf488b2xpcj81vmi9h";
   };
 
   nativeBuildInputs = [
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "The MATE panel";
     homepage = "https://github.com/mate-desktop/mate-panel";
-    license = with licenses; [ gpl2 lgpl2 ];
+    license = with licenses; [ gpl2Plus lgpl2Plus fdl11Plus ];
     platforms = platforms.unix;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/mate-polkit/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, gobject-introspection, libappindicator-gtk3, libindicator-gtk3, polkit }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, gobject-introspection, libappindicator-gtk3, libindicator-gtk3, polkit, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-polkit";
···
   ];
 
   enableParallelBuilding = true;
+
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
 
   meta = with lib; {
     description = "Integrates polkit authentication for MATE desktop";

pkgs/desktops/mate/mate-power-manager/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, glib, itstool, libxml2, mate-panel, libnotify, libcanberra-gtk3, dbus-glib, upower, gnome3, gtk3, libtool, polkit, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, glib, itstool, libxml2, mate-panel, libnotify, libcanberra-gtk3, dbus-glib, upower, gnome3, gtk3, libtool, polkit, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-power-manager";
-  version = "1.24.2";
+  version = "1.24.3";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "0fni41p3kraxwjnx9l5mdspng0zib1gfdxwlaiyq31mh4g79yjyj";
+    sha256 = "1rmcrpii3hl35qjznk6h5cq72n60cs12n294hjyakxr9kvgns7l6";
   };
 
   nativeBuildInputs = [
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "The MATE Power Manager";
     homepage = "https://mate-desktop.org";
-    license = licenses.gpl3;
+    license = with licenses; [ gpl2Plus fdl11Plus ];
     platforms = platforms.unix;
     maintainers = with maintainers; [ romildo chpatrick ];
   };

pkgs/desktops/mate/mate-screensaver/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, dbus-glib, libXScrnSaver, libnotify, libxml2, pam, systemd, mate, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, dbus-glib, libXScrnSaver, libnotify, libxml2, pam, systemd, mate, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-screensaver";
-  version = "1.24.1";
+  version = "1.24.2";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "0imb1z2yvz1h95dzq396c569kkxys9mb2dyc6qxxxcnc5w02a2dw";
+    sha256 = "18hxhglryfcbpbns9izigiws7lvdv5dnsaaz226ih3aar5db1ysy";
   };
 
   nativeBuildInputs = [
···
   makeFlags = [ "DBUS_SESSION_SERVICE_DIR=$(out)/etc" ];
 
   enableParallelBuilding = true;
+
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
 
   meta = with lib; {
     description = "Screen saver and locker for the MATE desktop";

pkgs/desktops/mate/mate-sensors-applet/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, gtk3, libxml2, libxslt, libatasmart, libnotify, lm_sensors, mate, hicolor-icon-theme, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, gtk3, libxml2, libxslt, libatasmart, libnotify
+, lm_sensors, mate, hicolor-icon-theme, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-sensors-applet";
···
   ];
 
   enableParallelBuilding = true;
+
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
 
   meta = with lib; {
     homepage = "https://github.com/mate-desktop/mate-sensors-applet";

pkgs/desktops/mate/mate-session-manager/default.nix

···
 { lib, stdenv, fetchurl, pkg-config, gettext, xtrans, dbus-glib, systemd,
   libSM, libXtst, gtk3, epoxy, polkit, hicolor-icon-theme, mate,
-  wrapGAppsHook, fetchpatch
+  wrapGAppsHook, fetchpatch, mateUpdateScript
 }:
 
 stdenv.mkDerivation rec {
   pname = "mate-session-manager";
-  version = "1.24.1";
+  version = "1.24.2";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "1zwq8symyp3ijs28pyrknsdi9byf4dpp9wp93ndwdhi0vaip5i51";
+    sha256 = "1jcb5k2fx2rwwbrslgv1xlzaiwiwjnxjwnp503qf8cg89w69q2vb";
   };
 
   patches = [
···
 
   postFixup = ''
     substituteInPlace $out/share/xsessions/mate.desktop \
-      --replace "Exec=mate-session" "Exec=$out/bin/mate-session" \
-      --replace "TryExec=mate-session" "TryExec=$out/bin/mate-session"
+      --replace "Exec=mate-session" "Exec=$out/bin/mate-session"
   '';
 
   passthru.providedSessions = [ "mate" ];
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "MATE Desktop session manager";
     homepage = "https://github.com/mate-desktop/mate-session-manager";
-    license = with licenses; [ gpl2 lgpl2 ];
+    license = with licenses; [ gpl2Plus lgpl2Plus ];
     platforms = platforms.unix;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/mate-settings-daemon/default.nix

···
 { lib, stdenv, fetchurl, pkg-config, gettext, glib, dbus-glib, libxklavier,
   libcanberra-gtk3, libnotify, nss, polkit, dconf, gtk3, mate,
   pulseaudioSupport ? stdenv.config.pulseaudio or true, libpulseaudio,
-  wrapGAppsHook }:
+  wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-settings-daemon";
-  version = "1.24.1";
+  version = "1.24.2";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "0n1ywr3ir5p536s7azdbw2mh40ylqlpx3a74mjrivbms1rpjxyab";
+    sha256 = "051r7xrx1byllsszbwsk646sq4izyag9yxg8jw2rm6x6mgwb89cc";
   };
 
   nativeBuildInputs = [
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "MATE settings daemon";
     homepage = "https://github.com/mate-desktop/mate-settings-daemon";
-    license = with licenses; [ gpl2 lgpl21 ];
+    license = with licenses; [ gpl2Plus gpl3Plus lgpl2Plus mit ];
     platforms = platforms.unix;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/mate-system-monitor/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, gtkmm3, libxml2, libgtop, libwnck3, librsvg, polkit, systemd, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, gtkmm3, libxml2, libgtop, libwnck3, librsvg, polkit, systemd, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-system-monitor";
-  version = "1.24.1";
+  version = "1.24.2";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "1i2r4lw6xsk972yp15g5hm8p8xx9pp6jmcvvzbdq80xyx3x898qz";
+    sha256 = "1mbny5hs5805398krvcsvi1jfhyq9a9dfciyrnis67n2yisr1hzp";
   };
 
   nativeBuildInputs = [
···
   configureFlags = [ "--enable-systemd" ];
 
   enableParallelBuilding = true;
+
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
 
   meta = with lib; {
     description = "System monitor for the MATE desktop";

pkgs/desktops/mate/mate-terminal/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, glib, itstool, libxml2, mate, dconf, gtk3, vte, pcre2, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, glib, itstool, libxml2, mate, dconf, gtk3, vte, pcre2, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-terminal";
···
 
   enableParallelBuilding = true;
 
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
   meta = with lib; {
     description = "The MATE Terminal Emulator";
     homepage = "https://mate-desktop.org";
-    license = licenses.gpl3;
+    license = licenses.gpl3Plus;
     platforms = platforms.unix;
     maintainers = [ maintainers.romildo ];
   };

pkgs/desktops/mate/mate-themes/default.nix

···
 { lib, stdenv, fetchurl, pkg-config, gettext, mate-icon-theme, gtk2, gtk3,
-  gtk_engines, gtk-engine-murrine, gdk-pixbuf, librsvg }:
+  gtk_engines, gtk-engine-murrine, gdk-pixbuf, librsvg, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-themes";
-  version = "3.22.21";
+  version = "3.22.22";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/themes/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "051g2vq817g84yrqzf7hjcqr4xrghnw1rprjd6jf5mhhzmwcas6n";
+    sha256 = "18crdwfpfm3br4pv94wy7rpmzzb69im4j8dgq1b7c8gcbbzay05x";
   };
 
   nativeBuildInputs = [ pkg-config gettext gtk3 ];
···
 
   enableParallelBuilding = true;
 
-  meta = {
+  passthru.updateScript = mateUpdateScript {
+    inherit pname version;
+    url = "https://pub.mate-desktop.org/releases/themes";
+  };
+
+  meta = with lib; {
     description = "A set of themes from MATE";
     homepage = "https://mate-desktop.org";
-    license = lib.licenses.lgpl21;
-    platforms = lib.platforms.unix;
-    maintainers = [ lib.maintainers.romildo ];
+    license = with licenses; [ lgpl21Plus lgpl3Only gpl3Plus ];
+    platforms = platforms.unix;
+    maintainers = [ maintainers.romildo ];
   };
 }

pkgs/desktops/mate/mate-tweak/default.nix

···
 , gobject-introspection
 , wrapGAppsHook
 , glib
+, genericUpdater
+, common-updater-scripts
 }:
 
 python3Packages.buildPythonApplication rec {
   pname = "mate-tweak";
-  version = "20.10.0";
+  version = "21.04.3";
 
   src = fetchFromGitHub {
     owner = "ubuntu-mate";
     repo = pname;
     rev = version;
-    sha256 = "08gw5i5wjxmzn92h9fv6g7q9i00n8shv1wlpy6cb31xy9wbmjph6";
+    sha256 = "0vpzy7awhb1xfsdjsrchy5b9dygj4ixdcvgx5v5w8hllmi4yxpc1";
   };
 
   nativeBuildInputs = [
···
       sed -i "s,usr,run/current-system/sw,g" $out/$i
     done
   '';
+
+  passthru.updateScript = genericUpdater {
+    inherit pname version;
+    attrPath = "mate.${pname}";
+    versionLister = "${common-updater-scripts}/bin/list-git-tags ${src.meta.homepage}";
+  };
 
   meta = with lib; {
     description = "Tweak tool for the MATE Desktop";

pkgs/desktops/mate/mate-user-guide/default.nix

···
-{ lib, stdenv, fetchurl, gettext, itstool, libxml2, yelp }:
+{ lib, stdenv, fetchurl, gettext, itstool, libxml2, yelp, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-user-guide";
···
   '';
 
   enableParallelBuilding = true;
+
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
 
   meta = with lib; {
     description = "MATE User Guide";

pkgs/desktops/mate/mate-user-share/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, gtk3, dbus-glib, libnotify, libxml2, libcanberra-gtk3, mod_dnssd, apacheHttpd, hicolor-icon-theme, mate, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, gtk3, dbus-glib, libnotify, libxml2
+, libcanberra-gtk3, mod_dnssd, apacheHttpd, hicolor-icon-theme, mate, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-user-share";
···
   ];
 
   enableParallelBuilding = true;
+
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
 
   meta = with lib; {
     description = "User level public file sharing for the MATE desktop";

pkgs/desktops/mate/mate-utils/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, glib, gtk3, libxml2, libgtop, libcanberra-gtk3, inkscape, udisks2, mate, hicolor-icon-theme, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, itstool, glib, gtk3, libxml2, libgtop, libcanberra-gtk3
+, inkscape, udisks2, mate, hicolor-icon-theme, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "mate-utils";
···
   NIX_CFLAGS_COMPILE = "-I${glib.dev}/include/gio-unix-2.0";
 
   enableParallelBuilding = true;
+
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
 
   meta = with lib; {
     description = "Utilities for the MATE desktop";

pkgs/desktops/mate/mozo/default.nix

···
-{ lib, python3, fetchurl, pkg-config, gettext, mate, gtk3, glib, wrapGAppsHook, gobject-introspection }:
+{ lib, python3, fetchurl, pkg-config, gettext, mate, gtk3, glib, wrapGAppsHook, gobject-introspection, mateUpdateScript }:
 
 python3.pkgs.buildPythonApplication rec {
   pname = "mozo";
-  version = "1.24.0";
+  version = "1.24.1";
 
   format = "other";
   doCheck = false;
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "01lyi47a04xk0by5bvnfmqgv5sysk2wdlri6a4ssmy1qhgwh9zr3";
+    sha256 = "14ps43gdh1sfvq49yhl58gxq3rc0d25i2d7r4ghlzf07ssxl53b0";
   };
 
   nativeBuildInputs = [ pkg-config gettext gobject-introspection wrapGAppsHook ];
···
   buildInputs = [ gtk3 glib ];
 
   enableParallelBuilding = true;
+
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
 
   meta = with lib; {
     description = "MATE Desktop menu editor";

pkgs/desktops/mate/pluma/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, perl, itstool, isocodes, enchant, libxml2, python3, gnome3, gtksourceview3, libpeas, mate, wrapGAppsHook }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, perl, itstool, isocodes, enchant, libxml2, python3
+, gnome3, gtksourceview3, libpeas, mate, wrapGAppsHook, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "pluma";
-  version = "1.24.1";
+  version = "1.24.2";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "1sgc5f480icr2ans6gd3akvcax58mr4jp3zjk3xn7bx1mw9i299f";
+    sha256 = "183frfhll3sb4r12p24160j1c1cfd102nlp5rrwvyv5qqm7i2fg4";
   };
 
   nativeBuildInputs = [
···
 
   enableParallelBuilding = true;
 
-  meta = {
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
+
+  meta = with lib; {
     description = "Powerful text editor for the MATE desktop";
     homepage = "https://mate-desktop.org";
-    license = lib.licenses.gpl2;
-    platforms = lib.platforms.unix;
-    maintainers = [ lib.maintainers.romildo ];
+    license = with licenses; [ gpl2Plus lgpl2Plus fdl11Plus ];
+    platforms = platforms.unix;
+    maintainers = [ maintainers.romildo ];
   };
 }

pkgs/desktops/mate/python-caja/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, mate, python3Packages }:
+{ lib, stdenv, fetchurl, pkg-config, gettext, gtk3, mate, python3Packages, mateUpdateScript }:
 
 stdenv.mkDerivation rec {
   pname = "python-caja";
···
   configureFlags = [ "--with-cajadir=$$out/lib/caja/extensions-2.0" ];
 
   enableParallelBuilding = true;
+
+  passthru.updateScript = mateUpdateScript { inherit pname version; };
 
   meta = with lib; {
     description = "Python binding for Caja components";

pkgs/desktops/mate/update.sh

···
-#!/usr/bin/env nix-shell
-#!nix-shell -i bash -p libarchive curl common-updater-scripts
-
-set -eu -o pipefail
-
-cd "$(dirname "${BASH_SOURCE[0]}")"
-root=../../..
-export NIXPKGS_ALLOW_UNFREE=1
-
-mate_version=1.24
-theme_version=3.22
-materepo=https://pub.mate-desktop.org/releases/${mate_version}
-themerepo=https://pub.mate-desktop.org/releases/themes/${theme_version}
-
-version() {
-    (cd "$root" && nix-instantiate --eval --strict -A "$1.version" | tr -d '"')
-}
-
-update_package() {
-    local p=$1
-    echo $p
-    echo "# $p" >> git-commits.txt
-
-    local repo
-    if [ "$p" = "mate-themes" ]; then
-        repo=$themerepo
-    else
-        repo=$materepo
-    fi
-  
-    local p_version_old=$(version mate.$p)
-    local p_versions=$(curl -sS ${repo}/ | sed -rne "s/.*\"$p-([0-9]+\\.[0-9]+\\.[0-9]+)\\.tar\\.xz.*/\\1/p")
-    local p_version=$(echo $p_versions | sed -e 's/ /\n/g' | sort -t. -k 1,1n -k 2,2n -k 3,3n | tail -n1)
-
-    if [[ -z "$p_version" ]]; then
-        echo "unavailable $p"
-        echo "# $p not found" >> git-commits.txt
-        echo
-        return
-    fi
-
-    if [[ "$p_version" = "$p_version_old" ]]; then
-        echo "nothing to do, $p $p_version is current"
-        echo
-        return
-    fi
-
-    # Download package and save hash and file path.
-    local url="$repo/$p-${p_version}.tar.xz"
-    mapfile -t prefetch < <(nix-prefetch-url --print-path "$url")
-    local hash=${prefetch[0]}
-    local path=${prefetch[1]}
-    echo "$p: $p_version_old -> $p_version"
-    (cd "$root" && update-source-version mate.$p "$p_version" "$hash")
-    echo "   git add pkgs/desktops/mate/$p" >> git-commits.txt
-    echo "   git commit -m \"mate.$p: $p_version_old -> $p_version\"" >> git-commits.txt
-    echo
-}
-
-for d in $(ls -A --indicator-style=none); do
-    if [ -d $d ]; then
-        update_package $d
-    fi
-done

pkgs/development/compilers/llvm/12/default.nix

···
     # doesn’t support like LLVM. Probably we should move to some other
     # file.
 
-    bintools = callPackage ./bintools.nix {};
+    bintools = callPackage ./bintools {};
 
     lldClang = wrapCCWith rec {
       cc = tools.clang-unwrapped;
···
 
     libcxxStdenv = overrideCC stdenv buildLlvmTools.libcxxClang;
 
-    libcxx = callPackage ./libc++ ({ inherit llvm_meta; } //
+    libcxx = callPackage ./libcxx ({ inherit llvm_meta; } //
       (lib.optionalAttrs (stdenv.hostPlatform.useLLVM or false) {
         stdenv = overrideCC stdenv buildLlvmTools.lldClangNoLibcxx;
       }));
 
-    libcxxabi = callPackage ./libc++abi ({ inherit llvm_meta; } //
+    libcxxabi = callPackage ./libcxxabi ({ inherit llvm_meta; } //
       (lib.optionalAttrs (stdenv.hostPlatform.useLLVM or false) {
         stdenv = overrideCC stdenv buildLlvmTools.lldClangNoLibcxx;
         libunwind = libraries.libunwind;
       }));
 
-    openmp = callPackage ./openmp.nix { inherit llvm_meta; };
+    openmp = callPackage ./openmp { inherit llvm_meta; };
 
     libunwind = callPackage ./libunwind ({ inherit llvm_meta; } //
       (lib.optionalAttrs (stdenv.hostPlatform.useLLVM or false) {

pkgs/development/compilers/llvm/12/libc++/default.nix pkgs/development/compilers/llvm/12/libcxx/default.nix

···
 }:
 
 stdenv.mkDerivation {
-  pname = "libc++";
+  pname = "libcxx";
   inherit version;
 
   src = fetch "libcxx" "1wf3ww29xkx7prs7pdwicy5qqfapib26110jgmkjrbka9z57bjvx";

pkgs/development/compilers/llvm/12/libc++abi/default.nix pkgs/development/compilers/llvm/12/libcxxabi/default.nix

···
 }:
 
 stdenv.mkDerivation {
-  pname = "libc++abi";
+  pname = "libcxxabi";
   inherit version;
 
   src = fetch "libcxxabi" "1cbmzspwjlr8f6sp73pw6ivf4dpg6rpc61by0q1m2zca2k6yif3a";

pkgs/development/libraries/sqlcipher/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "sqlcipher";
-  version = "4.4.2";
+  version = "4.4.3";
 
   src = fetchFromGitHub {
     owner = "sqlcipher";
     repo = "sqlcipher";
     rev = "v${version}";
-    sha256 = "0zhww6fpnfflnzp6091npz38ab6cpq75v3ghqvcj5kqg09vqm5na";
+    sha256 = "sha256-E23PTNnVZbBQtHL0YjUwHNVUA76XS8rlARBOVvX6zZw=";
   };
 
   nativeBuildInputs = [ installShellFiles ];

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

···
-{ lib, fetchurl, buildDunePackage, ounit, cstruct, dune-configurator, eqaf, pkg-config
+{ lib, fetchurl, buildDunePackage, ounit, cstruct, dune-configurator, eqaf, bigarray-compat, pkg-config
 , withFreestanding ? false
 , ocaml-freestanding
 }:
···
   minimumOCamlVersion = "4.08";
 
   pname = "mirage-crypto";
-  version = "0.9.2";
+  version = "0.10.0";
 
   src = fetchurl {
     url = "https://github.com/mirage/mirage-crypto/releases/download/v${version}/mirage-crypto-v${version}.tbz";
-    sha256 = "da200c0afdbe63474ab19f2bc616e26c10b0e4fbb53fb97fefb2794212f5d442";
+    sha256 = "20915c53ddb658c53f588c414f13676bc8ad3cd734d9ed909225ea080dd8144d";
   };
 
   useDune2 = true;
···
 
   nativeBuildInputs = [ dune-configurator pkg-config ];
   propagatedBuildInputs = [
-    cstruct eqaf
+    cstruct eqaf bigarray-compat
   ] ++ lib.optionals withFreestanding [
     ocaml-freestanding
   ];

pkgs/development/ocaml-modules/sedlex/2.nix

···
 , buildDunePackage
 , ocaml
 , gen
-, ppx_tools_versioned
-, ocaml-migrate-parsetree
+, ppxlib
 , uchar
 }:
 
-if lib.versionOlder ocaml.version "4.02.3"
+if lib.versionOlder ocaml.version "4.08"
 then throw "sedlex is not available for OCaml ${ocaml.version}"
 else
 
···
 in
 buildDunePackage rec {
   pname = "sedlex";
-  version = "2.2";
+  version = "2.3";
 
   useDune2 = true;
 
···
     owner = "ocaml-community";
     repo = "sedlex";
     rev = "v${version}";
-    sha256 = "18dwl2is5j26z6b1c47b81wvcpxw44fasppdadsrs9vsw63rwcm3";
+    sha256 = "0iw3phlaqr27jdf857hmj5v5hdl0vngbb2h37p2ll18sw991fxar";
   };
 
   propagatedBuildInputs = [
-    gen uchar ocaml-migrate-parsetree ppx_tools_versioned
+    gen uchar ppxlib
   ];
 
   preBuild = ''
···
 
   meta = {
     homepage = "https://github.com/ocaml-community/sedlex";
+    changelog = "https://github.com/ocaml-community/sedlex/raw/v${version}/CHANGES";
     description = "An OCaml lexer generator for Unicode";
     license = lib.licenses.mit;
     maintainers = [ lib.maintainers.marsam ];

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

···
 
 buildPythonPackage rec {
   pname = "ailment";
-  version = "9.0.6790";
+  version = "9.0.6852";
   disabled = pythonOlder "3.6";
 
   src = fetchFromGitHub {
     owner = "angr";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-RcLa18JqQ7c8u+fhyNHmJEXt/Lg73JDAImtUtiaZbTw=";
+    sha256 = "sha256-yIYZubZ8073voe4C78QITP3Pau/mrpNTyhPpU/QftXo=";
   };
 
   propagatedBuildInputs = [ pyvex ];

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

···
 
 buildPythonPackage rec {
   pname = "angr";
-  version = "9.0.6790";
+  version = "9.0.6852";
   disabled = pythonOlder "3.6";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-PRghK/BdgxGpPuinkGr+rREza1pQXz2gxnXiSmxBSTc=";
+    sha256 = "sha256-8BN706jqflhKmHVLQ1Y0k3GMScB1Hs5E/zndgq0sXB8=";
   };
 
   propagatedBuildInputs = [
···
   # Tests have additional requirements, e.g., pypcode and angr binaries
   # cle is executing the tests with the angr binaries
   doCheck = false;
-  pythonImportsCheck = [ "angr" ];
+
+  # See http://angr.io/api-doc/
+  pythonImportsCheck = [ "angr" "claripy" "cle" "pyvex" "archinfo" ];
 
   meta = with lib; {
     description = "Powerful and user-friendly binary analysis platform";

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

···
 
 buildPythonPackage rec {
   pname = "angrop";
-  version = "9.0.6790";
+  version = "9.0.6852";
   disabled = pythonOlder "3.6";
 
   src = fetchFromGitHub {
     owner = "angr";
     repo = pname;
     rev = "v${version}";
-    sha256 = "16r22ajkj8sxbgsym0i85xdjvphgf1566p5s7d915kkj37qdrrpy";
+    sha256 = "sha256-uOf2d3TbTdLobqfdOUSVQ/mqyD3TaYPlPCNFsqcPrXo=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "archinfo";
-  version = "9.0.6790";
+  version = "9.0.6852";
 
   src = fetchFromGitHub {
     owner = "angr";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-A4WvRElahRv/XmlmS4WexMqm8FIZ1SSUnbdoAWWECMk=";
+    sha256 = "sha256-NlL/uRI568HYkt8T2kuzyHNXpWybOLbFduE+1dzm4Qo=";
   };
 
   checkInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "binwalk";
-  version = "27";
+  version = "2.3.1";
 
   src = fetchFromGitHub {
     owner = "ReFirmLabs";
     repo = "binwalk";
-    rev = "python${version}";
-    sha256 = "03kqhs3j9czdc2pnr1v8iszwx254ljpvrmmj0j5ls0ssjrfxacyx";
+    rev = "v${version}";
+    sha256 = "108mj4jjffdmaz6wjvglbv44j7fkhspaxz1rj2bi1fcnwsri5wsm";
   };
 
   propagatedBuildInputs = [ zlib xz ncompress gzip bzip2 gnutar p7zip cabextract squashfsTools xz pycrypto ]
···
     homepage = "https://github.com/ReFirmLabs/binwalk";
     description = "A tool for searching a given binary image for embedded files";
     maintainers = [ maintainers.koral ];
+    license = licenses.mit;
   };
 }

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

···
 
 buildPythonPackage rec {
   pname = "claripy";
-  version = "9.0.6790";
+  version = "9.0.6852";
   disabled = pythonOlder "3.6";
 
   src = fetchFromGitHub {
     owner = "angr";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-GpWHj3bNgr7nQoIKM4VQtVkbObxqw6QkuEmfmPEiJmE=";
+    sha256 = "sha256-31zaL3PJDXyLvVD3Xdc2qoLSrXipwTawHoj+I+Y6fng=";
   };
 
   # Use upstream z3 implementation

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

···
 
 let
   # The binaries are following the argr projects release cycle
-  version = "9.0.6790";
+  version = "9.0.6852";
 
   # Binary files from https://github.com/angr/binaries (only used for testing and only here)
   binaries = fetchFromGitHub {
···
     owner = "angr";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-zQggVRdc8fV1ulFnOlzYLvSOSOP3+dY8j+6lo+pXSkM=";
+    sha256 = "sha256-IRyRio3M7YZtdBqb7PGoWs2Lyt8hjBLYM1zQYbhjYEs=";
   };
 
   propagatedBuildInputs = [

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

···
+{ lib
+, buildPythonPackage
+, fetchPypi
+, requests
+, requests_oauthlib
+}:
+
+buildPythonPackage rec {
+  pname = "homeconnect";
+  version = "0.6.3";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0n4h4mi23zw3v6fbkz17fa6kkl5v9bfmj0p57jvfzcfww511y9mn";
+  };
+
+  propagatedBuildInputs = [
+    requests
+    requests_oauthlib
+  ];
+
+  # Project has no tests
+  doCheck = false;
+  pythonImportsCheck = [ "homeconnect" ];
+
+  meta = with lib; {
+    description = "Python client for the BSH Home Connect REST API";
+    homepage = "https://github.com/DavidMStraub/homeconnect";
+    changelog = "https://github.com/DavidMStraub/homeconnect/releases/tag/v${version}";
+    license = with licenses; [ mit ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

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

···
+{ lib
+, buildPythonPackage
+, fetchPypi
+, cython
+, matplotlib
+}:
+
+buildPythonPackage rec {
+  pname = "pycocotools";
+  version = "2.0.2";
+  format = "setuptools";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "06hz0iz4kqxhqby4j7bah8l41kg68bb118jawp172i4vg497lw94";
+  };
+
+  propagatedBuildInputs = [
+    cython
+    matplotlib
+  ];
+
+  pythonImportsCheck = [
+    "pycocotools.coco"
+    "pycocotools.cocoeval"
+  ];
+
+  # has no tests
+  doCheck = false;
+
+  meta = with lib; {
+    description = "Official APIs for the MS-COCO dataset";
+    homepage = "https://github.com/cocodataset/cocoapi/tree/master/PythonAPI";
+    license = licenses.bsd2;
+    maintainers = with maintainers; [ hexa piegames ];
+  };
+}

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

···
 }:
 
 buildPythonPackage rec {
-  pname = "PyMetno";
-  version = "0.8.2";
+  pname = "pymetno";
+  version = "0.8.3";
   format = "setuptools";
 
   src = fetchFromGitHub {
-    repo = pname;
     owner = "Danielhiversen";
+    repo = "PyMetno";
     rev = version;
-    sha256 = "0b1zm60yqj1mivc3zqw2qm9rqh8cbmx0r58jyyvm3pxzq5cafdg5";
+    sha256 = "sha256-dvZz+wv9B07yKM4E4fQ9VQOgeil9KxZxcGk6D0kWY4g=";
   };
 
   propagatedBuildInputs = [
···
   doCheck = false;
 
   meta = with lib; {
-    description = "A library to communicate with the met.no api";
+    description = "A library to communicate with the met.no API";
     homepage = "https://github.com/Danielhiversen/pyMetno/";
     license = licenses.mit;
     maintainers = with maintainers; [ flyfloh ];

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

···
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, httpsig
+, pytest-asyncio
+, pytestCheckHook
+}:
+
+buildPythonPackage rec {
+  pname = "pysmartapp";
+  version = "0.3.3";
+
+  src = fetchFromGitHub {
+    owner = "andrewsayre";
+    repo = pname;
+    rev = version;
+    sha256 = "03wk44siqxl15pa46x5vkg4q0mnga34ir7qn897576z2ivbx7awh";
+  };
+
+  propagatedBuildInputs = [
+    httpsig
+  ];
+
+  checkInputs = [
+    pytest-asyncio
+    pytestCheckHook
+  ];
+
+  pythonImportsCheck = [ "pysmartapp" ];
+
+  meta = with lib; {
+    description = "Python implementation to work with SmartApp lifecycle events";
+    homepage = "https://github.com/andrewsayre/pysmartapp";
+    changelog = "https://github.com/andrewsayre/pysmartapp/releases/tag/${version}";
+    license = with licenses; [ mit ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

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

···
+{ lib
+, aiohttp
+, buildPythonPackage
+, fetchFromGitHub
+, pytest-asyncio
+, pytestCheckHook
+}:
+
+buildPythonPackage rec {
+  pname = "pysmartthings";
+  version = "0.7.6";
+
+  src = fetchFromGitHub {
+    owner = "andrewsayre";
+    repo = pname;
+    rev = version;
+    sha256 = "0m91lfzdbmq6qv6bihd278psi9ghldxpa1d0dsbii2zf338188qj";
+  };
+
+  propagatedBuildInputs = [
+    aiohttp
+  ];
+
+  checkInputs = [
+    pytest-asyncio
+    pytestCheckHook
+  ];
+
+  pythonImportsCheck = [ "pysmartthings" ];
+
+  meta = with lib; {
+    description = "Python library for interacting with the SmartThings cloud API";
+    homepage = "https://github.com/andrewsayre/pysmartthings";
+    changelog = "https://github.com/andrewsayre/pysmartthings/releases/tag/${version}";
+    license = with licenses; [ mit ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

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

···
 
 buildPythonPackage rec {
   pname = "pyturbojpeg";
-  version = "1.4.2";
+  version = "1.4.3";
 
   src = fetchPypi {
     pname = "PyTurboJPEG";
     inherit version;
-    sha256 = "sha256-dWmj/huCkborcShf2BT+L3ybEfgdKVIGiJnkz755xwo=";
+    sha256 = "sha256-Q7KVfR9kA32QPQFWgSSCVB5sNOmSF8y5J4dmBc14jvg=";
   };
 
   patches = [

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

···
 
 buildPythonPackage rec {
   pname = "pyvex";
-  version = "9.0.6790";
+  version = "9.0.6852";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-bqOLHGlLQ12nYzbv9H9nJ0/Q5APJb/9B82YtHk3IvYQ=";
+    sha256 = "sha256-O84QErqHIRYQZh9mR71opm+j7kb9a4s5f1yj0WNiJAM=";
   };
 
   propagatedBuildInputs = [

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

···
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, numpy
+, scikitlearn
+, perl
+, pytestCheckHook
+}:
+
+buildPythonPackage rec {
+  pname = "seqeval";
+  version = "1.2.2";
+  format = "setuptools";
+
+  src = fetchFromGitHub {
+    owner = "chakki-works";
+    repo = "seqeval";
+    rev = "v${version}";
+    sha256 = "0qv05gn54kc4wpmwnflmfqw4gwwb8lxqhkiihl0pvl7s2i7qzx2j";
+  };
+
+  postPatch = ''
+    substituteInPlace setup.py \
+      --replace "use_scm_version=True," "version='${version}'," \
+      --replace "setup_requires=['setuptools_scm']," "setup_requires=[],"
+  '';
+
+  propagatedBuildInputs = [
+    numpy
+    scikitlearn
+  ];
+
+  checkInputs = [
+    pytestCheckHook
+  ];
+
+  disabledTests = [
+    # tests call perl script and get stuck in there
+    "test_statistical_tests"
+    "test_by_ground_truth"
+  ];
+
+  meta = with lib; {
+    description = "A Python framework for sequence labeling evaluation";
+    homepage = "https://github.com/chakki-works/seqeval";
+    license = licenses.mit;
+    maintainers = with maintainers; [ hexa ];
+  };
+}

pkgs/development/python-modules/smhi-pkg/default.nix

···
+{ lib
+, aiohttp
+, buildPythonPackage
+, fetchFromGitHub
+, pytest-asyncio
+, pytestCheckHook
+}:
+
+buildPythonPackage rec {
+  pname = "smhi-pkg";
+  version = "1.0.14";
+
+  src = fetchFromGitHub {
+    owner = "joysoftware";
+    repo = "pypi_smhi";
+    rev = version;
+    sha256 = "186xwrg3hvr0hszq2kxvygd241q2sp11gfk6mwj9z4zqywwfcbn3";
+  };
+
+  propagatedBuildInputs = [
+    aiohttp
+  ];
+
+  checkInputs = [
+    pytest-asyncio
+    pytestCheckHook
+  ];
+
+  disabledTests = [
+    # Disable tests that needs network access
+    "test_smhi_integration_test"
+    "test_smhi_async_integration_test"
+    "test_smhi_async_integration_test_use_session"
+    "test_smhi_async_get_forecast_integration2"
+    "test_async_error_from_api"
+  ];
+
+  pythonImportsCheck = [ "smhi" ];
+
+  meta = with lib; {
+    description = "Python library for accessing SMHI open forecast data";
+    homepage = "https://github.com/joysoftware/pypi_smhi";
+    changelog = "https://github.com/joysoftware/pypi_smhi/releases/tag/${version}";
+    license = with licenses; [ mit ];
+    maintainers = with maintainers; [ fab ];
+  };
+}

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

···
 { lib
 , buildPythonPackage
+, pythonOlder
 , fetchPypi
 , wrapio
 }:
 
 buildPythonPackage rec {
   pname = "survey";
-  version = "3.4.2";
+  version = "3.4.3";
+
+  disabled = pythonOlder "3.5";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-aF7ZS5oxeIOb7mJsrusdc3HefcPE+3OTXcJB/pjJxFY=";
+    sha256 = "sha256-TK89quY3bpNIEz1n3Ecew4FnTH6QgeSLdDNV86gq7+I=";
   };
 
   propagatedBuildInputs = [

pkgs/development/tools/just/default.nix

···
-{ lib, fetchFromGitHub, rustPlatform, coreutils, bash, installShellFiles }:
+{ lib, fetchFromGitHub, stdenv, rustPlatform, coreutils, bash, installShellFiles, libiconv }:
 
 rustPlatform.buildRustPackage rec {
   pname = "just";
···
   cargoSha256 = "sha256-YDIGZRbszhgWM7iAc2i89jyndZvZZsg63ADQfqFxfXw=";
 
   nativeBuildInputs = [ installShellFiles ];
+  buildInputs = lib.optionals stdenv.isDarwin [ libiconv ];
 
   postInstall = ''
     installManPage man/just.1

pkgs/games/mar1d/default.nix

···
-{ lib, stdenv
-, fetchFromGitHub
-, cmake
+{ stdenv
+, lib
+, SDL2
+, SDL2_mixer
 , libGLU
-, xlibsWrapper
-, xorg
-, xinput_calibrator
-, doxygen
-, libpthreadstubs
-, alsaLib
-, alsaOss
-, libao
-, width ? 30
-, mute ? false
-, effects ? false
-, sensitivity ? 5
-, reverseY ? false
+, libconfig
+, meson
+, ninja
+, pkg-config
+, fetchFromGitHub
 }:
 
 stdenv.mkDerivation rec {
   pname = "MAR1D";
-  version = "0.2.0";
-  options = "-w${toString width}"
-          + " -s${toString sensitivity}"
-          + (if mute then " -m" else "")
-          + (if effects then " -f" else "")
-          + (if reverseY then " -r" else "");
+  version = "0.3.0";
 
   src = fetchFromGitHub {
-    sha256 = "152w5dnlxzv60cl24r5cmrj2q5ar0jiimrmxnp87kf4d2dpbnaq7";
+    sha256 = "sha256-/QZH2H0PFCLeweXUE11vimLnJTt86PjnTnHC9vWkKsk=";
     rev = "v${version}";
-    repo = "fp_mario";
-    owner = "olynch";
+    repo = "MAR1D";
+    owner = "Radvendii";
   };
 
-  buildInputs =
-    [
-      alsaLib
-      alsaOss
-      cmake
-      doxygen
-      libao
-      libpthreadstubs
-      libGLU
-      xlibsWrapper
-      xinput_calibrator
-      xorg.libXrandr
-      xorg.libXi
-      xorg.xinput
-      xorg.libXxf86vm
-    ];
+  nativeBuildInputs = [ meson ninja pkg-config ];
 
-  preConfigure = ''
-    cd src
-  '';
+  buildInputs = [
+    SDL2
+    SDL2_mixer
+    libconfig
+    libGLU
+  ];
 
   meta = with lib; {
     description = "First person Super Mario Bros";
···
       original, however, the game still takes place in a two dimensional world.
       You must view the world as mario does, as a one dimensional line.
     '';
-    homepage = "https://github.com/olynch/fp_mario";
+    homepage = "https://mar1d.com";
     license = licenses.agpl3;
     maintainers = with maintainers; [ taeer ];
-    platforms = platforms.linux;
+    platforms = platforms.unix;
   };
 }

pkgs/games/steam/steam.nix

···
 
 let
   traceLog = "/tmp/steam-trace-dependencies.log";
-  version = "1.0.0.69";
+  version = "1.0.0.70";
 
 in stdenv.mkDerivation {
   pname = "steam-original";
   inherit version;
 
   src = fetchurl {
-    url = "https://repo.steampowered.com/steam/pool/steam/s/steam/steam_${version}.tar.gz";
-    sha256 = "sha256-b5g4AUprE/lTunJs59IDlGu5O/1dB0kBvCFq0Eqyx2c=";
+    url = "https://repo.steampowered.com/steam/archive/stable/steam_${version}.tar.gz";
+    sha256 = "sha256-n/iKV3jHsA77GPMk1M0MKC1fQ42tEgG8Ppgi4/9qLf8=";
   };
 
   makeFlags = [ "DESTDIR=$(out)" "PREFIX=" ];

pkgs/misc/emulators/wine/sources.nix

···
 
   unstable = fetchurl rec {
     # NOTE: Don't forget to change the SHA256 for staging as well.
-    version = "6.5";
+    version = "6.7";
     url = "https://dl.winehq.org/wine/source/6.x/wine-${version}.tar.xz";
-    sha256 = "sha256-BgD9IIwGkl1mNNKfVDu6CmQ2HDTpvXYJwvDiCWEK00c=";
-    inherit (stable) mono gecko32 gecko64;
+    sha256 = "sha256-wwUUt3YdRhFRSuAhyx41QSjXfv9UooPxQB7nAid7vqQ=";
+    inherit (stable) gecko32 gecko64;
+
+    ## see http://wiki.winehq.org/Mono
+    mono = fetchurl rec {
+      version = "6.1.1";
+      url = "https://dl.winehq.org/wine/wine-mono/${version}/wine-mono-${version}-x86.msi";
+      sha256 = "sha256-rDsUvq/eNLhIIofllwABE9wGqRXzLJ/QbHfrgZB544s=";
+    };
 
     patches = [
       # Also look for root certificates at $NIX_SSL_CERT_FILE
···
   staging = fetchFromGitHub rec {
     # https://github.com/wine-staging/wine-staging/releases
     inherit (unstable) version;
-    sha256 = "sha256-u6wDavrFirN1e0fFra4ui3i4PnJF0gcENYoIyNwhIYc=";
+    sha256 = "sha256-fWriizSk2+U7Mpn6w/Dlrevd4vc5MnlSWSGxQDf2p+M=";
     owner = "wine-staging";
     repo = "wine-staging";
     rev = "v${version}";

pkgs/servers/dns/pdns-recursor/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "pdns-recursor";
-  version = "4.4.2";
+  version = "4.4.3";
 
   src = fetchurl {
     url = "https://downloads.powerdns.com/releases/pdns-recursor-${version}.tar.bz2";
-    sha256 = "1kzmliim2pwh04y3y6bpai9fm0qmdicrmff09fv5h5wahi4pzfdh";
+    sha256 = "01dypbqq6ynrdr3dqwbz8dzpkd2ykgaz9mqhaz3i1hqc21c14hgq";
   };
 
   nativeBuildInputs = [ pkg-config ];

pkgs/servers/home-assistant/component-packages.nix

···
     "hitron_coda" = ps: with ps; [ ];
     "hive" = ps: with ps; [ ]; # missing inputs: pyhiveapi
     "hlk_sw16" = ps: with ps; [ ]; # missing inputs: hlk-sw16
-    "home_connect" = ps: with ps; [ aiohttp-cors ]; # missing inputs: homeconnect
+    "home_connect" = ps: with ps; [ aiohttp-cors homeconnect ];
     "home_plus_control" = ps: with ps; [ aiohttp-cors homepluscontrol ];
     "homeassistant" = ps: with ps; [ ];
     "homekit" = ps: with ps; [ HAP-python pyqrcode pyturbojpeg aiohttp-cors base36 fnvhash ha-ffmpeg zeroconf ];
···
     "smappee" = ps: with ps; [ aiohttp-cors pysmappee ];
     "smart_meter_texas" = ps: with ps; [ ]; # missing inputs: smart-meter-texas
     "smarthab" = ps: with ps; [ ]; # missing inputs: smarthab
-    "smartthings" = ps: with ps; [ aiohttp-cors hass-nabucasa ]; # missing inputs: pysmartapp pysmartthings
+    "smartthings" = ps: with ps; [ aiohttp-cors hass-nabucasa pysmartapp pysmartthings ];
     "smarttub" = ps: with ps; [ python-smarttub ];
     "smarty" = ps: with ps; [ ]; # missing inputs: pysmarty
-    "smhi" = ps: with ps; [ ]; # missing inputs: smhi-pkg
+    "smhi" = ps: with ps; [ smhi-pkg ];
     "sms" = ps: with ps; [ python-gammu ];
     "smtp" = ps: with ps; [ ];
     "snapcast" = ps: with ps; [ snapcast ];

pkgs/servers/home-assistant/default.nix

···
     "hddtemp"
     "history"
     "history_stats"
+    "home_connect"
     "home_plus_control"
     "homekit"
     "homekit_controller"
···
     "simulated"
     "sleepiq"
     "sma"
+    "smhi"
     "sensor"
     "slack"
+    "smartthings"
     "smarttub"
     "smtp"
     "smappee"

pkgs/servers/minio/default.nix

···
 
 buildGoModule rec {
   pname = "minio";
-  version = "2021-04-06T23-11-00Z";
+  version = "2021-04-22T15-44-28Z";
 
   src = fetchFromGitHub {
     owner = "minio";
     repo = "minio";
     rev = "RELEASE.${version}";
-    sha256 = "sha256-gwf6qA63EFxGQxk8DiAiqLpIYVhVQDQYPffLNP5JfVw=";
+    sha256 = "147a4vgf2hdpbndska443axzvxx56bmc0011m3cq4ca1vm783k8q";
   };
 
-  vendorSha256 = "sha256-VeYc+UtocpeNSV+0MocZj/83X/SMMv5PX2cPIPBV/sk=";
+  vendorSha256 = "0qj1zab97q8s5gy7a304wqi832y8m083cnk8hllz8lz9yjcw6q92";
 
   doCheck = false;
 

pkgs/servers/monitoring/nagios/plugins/check_systemd.nix

···
 
 python3Packages.buildPythonApplication rec {
   pname = "check_systemd";
-  version = "2.2.1";
+  version = "2.3.1";
 
   src = fetchFromGitHub {
     owner = "Josef-Friedrich";
     repo = pname;
     rev = "v${version}";
-    sha256 = "04r14dhqzrdndn235dvr6afy4s4g4asynsgvj99cmyq55nah4asn";
+    sha256 = "11sc0gycxzq1vfvin501jnwnky2ky6ns64yjiw8vq9vmkbf8nni6";
   };
 
   propagatedBuildInputs = with python3Packages; [ nagiosplugin ];
···
   meta = with lib; {
     description = "Nagios / Icinga monitoring plugin to check systemd for failed units";
     inherit (src.meta) homepage;
+    changelog = "https://github.com/Josef-Friedrich/check_systemd/releases";
     maintainers = with maintainers; [ symphorien ];
     license = licenses.lgpl2Only;
     platforms = platforms.linux;

pkgs/servers/web-apps/wordpress/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "wordpress";
-  version = "5.6.2";
+  version = "5.7.1";
 
   src = fetchurl {
     url = "https://wordpress.org/${pname}-${version}.tar.gz";
-    sha256 = "sha256-W9/U3i6jALXolDFraiI/a+PNPoNHim0rZHzaqSy4gkI=";
+    sha256 = "08c9g80lhs4h2psf3ykn0l4k1yyy0x21kxjqy8ckjpjvw3281nd4";
   };
 
   installPhase = ''

pkgs/tools/filesystems/cryfs/default.nix

···
     "-DBUILD_TESTING:BOOL=${if doCheck then "TRUE" else "FALSE"}"
   ] ++ lib.optional doCheck "-DCMAKE_PREFIX_PATH=${gtest.dev}/lib/cmake";
 
-  doCheck = true;
+  # macFUSE needs to be installed for the test to succeed on Darwin
+  doCheck = !stdenv.isDarwin;
 
   checkPhase = ''
     # Skip CMakeFiles directory and tests depending on fuse (does not work well with sandboxing)

pkgs/tools/games/ajour/default.nix

···
 
 in rustPlatform.buildRustPackage rec {
   pname = "Ajour";
-  version = "1.0.0";
+  version = "1.1.0";
 
   src = fetchFromGitHub {
     owner = "casperstorm";
     repo = "ajour";
     rev = version;
-    sha256 = "sha256-u48U4WGlrSl8T3YF7cjApyjNaUI4YyyHEy0TgJw7r/Y=";
+    sha256 = "1xzsgxkdwdqcr8xs9ajr1ykfjjz95z9k7b7l644yijg31xf1lbq6";
   };
 
-  cargoSha256 = "sha256-Hdid70AB4AKtSsQBsr6K/de4nvI3rvghEWIwM7mpRIA=";
+  cargoSha256 = "02g25wr0f2bjr7zmpll3iicc6i8wk1j9iavagg1vhbpynp6z013x";
 
   nativeBuildInputs = [
     autoPatchelfHook

pkgs/tools/misc/ddcutil/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "ddcutil";
-  version = "1.0.1";
+  version = "1.1.0";
 
   src = fetchFromGitHub {
     owner  = "rockowitz";
     repo   = "ddcutil";
     rev    = "v${version}";
-    sha256 = "sha256-F/tKW81bAyYtwpxhl5XC8YyMB+6S0XmqqigwJY2WFDU=";
+    sha256 = "0wv8a8zjahzmi4qx0lc24mwyi3jklj1yxqq26fwklmfh5dv1y8yc";
   };
 
   patches = [

pkgs/tools/misc/ddcutil/nixos-paths.diff

···
-diff --git a/src/app_sysenv/query_sysenv_modules.c b/src/app_sysenv/query_sysenv_modules.c
-index 59df64f1..fb244dd0 100644
---- a/src/app_sysenv/query_sysenv_modules.c
-+++ b/src/app_sysenv/query_sysenv_modules.c
-@@ -50,7 +50,9 @@ bool is_module_loadable(char * module_name, int depth) {
-    g_snprintf(module_name_ko, 100, "%s.ko", module_name);
- 
-    char dirname[PATH_MAX];
--   g_snprintf(dirname, PATH_MAX, "/lib/modules/%s/kernel/drivers/i2c", utsbuf.release);
-+   g_snprintf(dirname, PATH_MAX,
-+      "/run/booted-system/kernel-modules/lib/modules/%s/kernel/drivers/i2c",
-+      utsbuf.release);
- 
-    struct dirent *dent;
-      DIR           *d;
-diff --git a/src/util/linux_util.c b/src/util/linux_util.c
-index 5eb8491c..3a129ccf 100644
 --- a/src/util/linux_util.c
 +++ b/src/util/linux_util.c
-@@ -29,8 +29,10 @@ bool is_module_builtin(char * module_name)
-    int rc = uname(&utsbuf);
-    assert(rc == 0);
+@@ -125,6 +125,7 @@
+                   "lib64",
+                   "lib32",
+                   "usr/lib",  // needed for arch?
++                  "run/booted-system/kernel-modules/lib",  // NixOS
+                   NULL};
+    int result = -1;
+    int ndx = 0;
+@@ -204,14 +205,15 @@
+    if (debug)
+       printf("(%s) machine: %s", __func__, utsbuf.machine);
  
--   char modules_builtin_fn[100];
--   snprintf(modules_builtin_fn, 100, "/lib/modules/%s/modules.builtin", utsbuf.release);
-+   char modules_builtin_fn[PATH_MAX];
-+   snprintf(modules_builtin_fn, PATH_MAX,
-+      "/run/booted-system/kernel-modules/lib/modules/%s/modules.builtin",
-+      utsbuf.release);
+-   char * libdirs[3];
++   char * libdirs[4];
+    libdirs[0] = "lib";
++   libdirs[1] = "run/booted-system/kernel-modules/lib";
+    if (streq(utsbuf.machine, "amd_64")){
+-      libdirs[1] = "lib64";
+-      libdirs[2] = NULL;
++      libdirs[2] = "lib64";
++      libdirs[3] = NULL;
+    }
+    else
+-      libdirs[1] = NULL;
++      libdirs[2] = NULL;
  
-    char ko_name[40];
-    snprintf(ko_name, 40, "%s.ko", module_name);
+    int libsndx = 0;
+    bool found = false;

pkgs/tools/misc/flexoptix-app/default.nix

···
+{ lib, appimageTools, fetchurl }: let
+  pname = "flexoptix-app";
+  version = "5.9.0";
+  name = "${pname}-${version}";
+
+  src = fetchurl {
+    name = "${name}.AppImage";
+    url = "https://flexbox.reconfigure.me/download/electron/linux/x64/FLEXOPTIX%20App.${version}.AppImage";
+    sha256 = "0gbqaj9b11mxx0knmmh2d5863kaslbb3r6c4h8rjhg8qy4cws7hj";
+  };
+
+  udevRules = fetchurl {
+    url = "https://www.flexoptix.net/skin/udev_rules/99-tprogrammer.rules";
+    sha256 = "0mr1bhgvavq1ax4206z1vr2y64s3r676w9jjl9ysziklbrsvk5rr";
+  };
+
+  appimageContents = appimageTools.extractType2 {
+    inherit name src;
+  };
+
+in appimageTools.wrapType2 {
+  inherit name src;
+
+  multiPkgs = null; # no 32bit needed
+  extraPkgs = { pkgs, ... }@args: [
+    pkgs.hidapi
+  ] ++ appimageTools.defaultFhsEnvArgs.multiPkgs args;
+
+  extraInstallCommands = ''
+    mv $out/bin/{${name},${pname}}
+    install -Dm444 ${appimageContents}/flexoptix-app.desktop -t $out/share/applications
+    install -Dm444 ${appimageContents}/flexoptix-app.png -t $out/share/pixmaps
+    substituteInPlace $out/share/applications/flexoptix-app.desktop \
+      --replace 'Exec=AppRun' "Exec=$out/bin/${pname}"
+    mkdir -p $out/lib/udev/rules.d
+    ln -s ${udevRules} $out/lib/udev/rules.d/99-tprogrammer.rules
+  '';
+
+  meta = {
+    description = "Configure FLEXOPTIX Universal Transcievers in seconds";
+    homepage = "https://www.flexoptix.net";
+    changelog = "https://www.flexoptix.net/en/flexoptix-app/?os=linux#flexapp__modal__changelog";
+    license = lib.licenses.unfree;
+    maintainers = with lib.maintainers; [ das_j ];
+    platforms = [ "x86_64-linux" ];
+  };
+}

pkgs/tools/misc/handlr/default.nix

···
-{ lib, rustPlatform, fetchFromGitHub }:
+{ lib, rustPlatform, fetchFromGitHub, shared-mime-info }:
 
 rustPlatform.buildRustPackage rec {
   pname = "handlr";
-  version = "0.5.0";
+  version = "0.6.1";
 
   src = fetchFromGitHub {
     owner = "chmln";
     repo = pname;
     rev = "v${version}";
-    sha256 = "1f4gmlqzgw1r8n0w9dr9lpsn94f2hlnak9bbq5xgf6jwgc9mwqzg";
+    sha256 = "0mxkirsicagvfyihcb06g2bsz5h0zp7xc87vldp4amgddzaxhpbg";
   };
 
-  cargoSha256 = "16d4dywwkgvvxw6ninrx87rqhx0whdq3yy01m27qjy4gz6z6ad8p";
+  cargoSha256 = "11glh6f0cjrq76212h80na2rgwpzjmk0j78y3i98nv203rkrczid";
+
+  nativeBuildInputs = [ shared-mime-info ];
 
-  # Most tests fail (at least some due to directory permissions)
-  doCheck = false;
+  preCheck = ''
+    export HOME=$TEMPDIR
+  '';
 
   meta = with lib; {
     description = "Alternative to xdg-open to manage default applications with ease";

pkgs/tools/security/prs/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "prs";
-  version = "0.2.8";
+  version = "0.2.9";
 
   src = fetchFromGitLab {
     owner = "timvisee";
     repo = "prs";
     rev = "v${version}";
-    sha256 = "sha256-TPgS3gtSfCAtQyQCZ0HadxvmX6+dP/3SE/WumzzYUAw=";
+    sha256 = "sha256-9qaRhTfdppU72w8jDwD1e8ABuGG+9GyrRIUVsry4Vos=";
   };
 
-  cargoSha256 = "sha256-djKtmQHBVXEfn91avJCsVJwEJIE3xL1umvoLAIyXSrw=";
+  cargoSha256 = "sha256-j+kyllMcYj7/Ig5ho548L1wW+TtuQOc/zkxT6SNNN6w=";
 
   postPatch = ''
     # The GPGME backend is recommended

pkgs/tools/security/trousers/allow-non-tss-config-file-owner.patch

···
  
 +#ifndef ALLOW_NON_TSS_CONFIG_FILE
  	/* make sure user/group TSS owns the conf file */
- 	if (pw->pw_uid != stat_buf.st_uid || grp->gr_gid != stat_buf.st_gid) {
+ 	if (stat_buf.st_uid != 0 || grp->gr_gid != stat_buf.st_gid) {
  		LogError("TCSD config file (%s) must be user/group %s/%s", tcsd_config_file,
 @@ -775,6 +776,7 @@
- 		LogError("TCSD config file (%s) must be mode 0600", tcsd_config_file);
+ 		LogError("TCSD config file (%s) must be mode 0640", tcsd_config_file);
  		return TCSERR(TSS_E_INTERNAL_ERROR);
  	}
 +#endif

pkgs/tools/security/trousers/default.nix

···
-{ lib, stdenv, fetchurl, openssl, pkg-config }:
+{ lib, stdenv, fetchurl, openssl, pkg-config, autoreconfHook }:
 
 stdenv.mkDerivation rec {
   pname = "trousers";
-  version = "0.3.14";
+  version = "0.3.15";
 
   src = fetchurl {
     url = "mirror://sourceforge/trousers/trousers/${version}/${pname}-${version}.tar.gz";
-    sha256 = "0iwgsbrbb7nfqgl61x8aailwxm8akxh9gkcwxhsvf50x4qx72l6f";
+    sha256 = "0zy7r9cnr2gvwr2fb1q4fc5xnvx405ymcbrdv7qsqwl3a4zfjnqy";
   };
 
-  sourceRoot = ".";
-
-  nativeBuildInputs = [ pkg-config ];
+  nativeBuildInputs = [ pkg-config autoreconfHook ];
   buildInputs = [ openssl ];
 
   patches = [ ./allow-non-tss-config-file-owner.patch ];

pkgs/tools/security/vault/default.nix

···
 
 buildGoPackage rec {
   pname = "vault";
-  version = "1.7.0";
+  version = "1.7.1";
 
   src = fetchFromGitHub {
     owner = "hashicorp";
     repo = "vault";
     rev = "v${version}";
-    sha256 = "1lsz8fyjcxamvs9n3m974q2jxhv828fb5p6qx8wlqdaahqgrc8qg";
+    sha256 = "0ncy99gw2pp5v2qbbgvri7qlirjj8qsvgjmjqyx3gddlpzpyiz3q";
   };
 
   goPackagePath = "github.com/hashicorp/vault";

pkgs/tools/security/vault/vault-bin.nix

···
 { lib, stdenv, fetchurl, unzip }:
 
 let
-  version = "1.7.0";
+  version = "1.7.1";
 
   sources = let
     base = "https://releases.hashicorp.com/vault/${version}";
   in {
     x86_64-linux = fetchurl {
       url = "${base}/vault_${version}_linux_amd64.zip";
-      sha256 = "0d8wqxqilv1jdf4dl7w2jp3lfh0w0rawidmhjlj3ykpg6l3gblma";
+      sha256 = "021qa8jcqwy27q83lvamvv5zqnkwk5y0jsb8al5yxpgzxqnmsyb1";
     };
     i686-linux = fetchurl {
       url = "${base}/vault_${version}_linux_386.zip";
-      sha256 = "128r0phm5i1cpayz0ia8qsmnk1ia3qylidy9f8iwk3l8r834s4yd";
+      sha256 = "02hhxpa8craa91nfgvwziswisfdnqw4gbwrxyxr753v1y00y1sz8";
     };
     x86_64-darwin = fetchurl {
       url = "${base}/vault_${version}_darwin_amd64.zip";
-      sha256 = "01vxjv95his8jqin2cwcw691wdwn6p876rp021bmvr6diw6clkrp";
+      sha256 = "141zzfwrjdjv8ymrdc4mxs2f4cphdir4xjaa40s571ri38in33zh";
     };
     aarch64-linux = fetchurl {
       url = "${base}/vault_${version}_linux_arm64.zip";
-      sha256 = "0ahdv14fz7ybl11b61z7j13nbjd6hp6fcpc5bk6y8lh4qj8x0pzg";
+      sha256 = "1plrmmy86zb2ij49dk2mwn364i2n83ch4gjz5pln2d4wjx21gpaq";
     };
   };
 

pkgs/tools/system/gdu/default.nix

···
 { lib
-, stdenv
 , buildGoModule
 , fetchFromGitHub
 , installShellFiles
···
     installManPage gdu.1
   '';
 
-  doCheck = !(stdenv.isAarch64 || stdenv.isDarwin);
+  # tests fail with:
+  #  dir_test.go:76:
+  #              Error Trace:    dir_test.go:76
+  #              Error:          Not equal:
+  #                              expected: 0
+  #                              actual  : 512
+  #              Test:           TestFlags
+  doCheck = false;
 
   meta = with lib; {
     description = "Disk usage analyzer with console interface";

pkgs/top-level/all-packages.nix

···
 
   flent = python3Packages.callPackage ../applications/networking/flent { };
 
+  flexoptix-app = callPackage ../tools/misc/flexoptix-app { };
+
   flpsed = callPackage ../applications/editors/flpsed { };
 
   fluentd = callPackage ../tools/misc/fluentd { };
···
       '' + (drv.postInstall or "");
     });
 
+  pixelnuke = callPackage ../applications/graphics/pixelnuke { };
+
   slack = callPackage ../applications/networking/instant-messengers/slack { };
 
   slack-cli = callPackage ../tools/networking/slack-cli { };
···
   waybox = callPackage ../applications/window-managers/waybox {
     wlroots = wlroots_0_12;
   };
+
+  workstyle = callPackage ../applications/window-managers/i3/workstyle.nix { };
 
   windowchef = callPackage ../applications/window-managers/windowchef/default.nix { };
 

pkgs/top-level/python-packages.nix

···
 
   homeassistant-pyozw = callPackage ../development/python-modules/homeassistant-pyozw { };
 
+  homeconnect = callPackage ../development/python-modules/homeconnect { };
+
   homematicip = callPackage ../development/python-modules/homematicip { };
 
   homepluscontrol = callPackage ../development/python-modules/homepluscontrol { };
···
 
   pycmarkgfm = callPackage ../development/python-modules/pycmarkgfm { };
 
+  pycocotools = callPackage ../development/python-modules/pycocotools { };
+
   pycodestyle = callPackage ../development/python-modules/pycodestyle { };
 
   pycognito = callPackage ../development/python-modules/pycognito { };
···
 
   pysmappee = callPackage ../development/python-modules/pysmappee { };
 
-  pysmb = callPackage ../development/python-modules/pysmb { };
-
   pysmart-smartx = callPackage ../development/python-modules/pysmart-smartx { };
+
+  pysmartapp = callPackage ../development/python-modules/pysmartapp { };
+
+  pysmartthings = callPackage ../development/python-modules/pysmartthings { };
+
+  pysmb = callPackage ../development/python-modules/pysmb { };
 
   pysmbc = callPackage ../development/python-modules/pysmbc { };
 
···
 
   seqdiag = callPackage ../development/python-modules/seqdiag { };
 
+  seqeval = callPackage ../development/python-modules/seqeval { };
+
   sequoia = disabledIf isPyPy (toPythonModule (pkgs.sequoia.override {
     pythonPackages = self;
     pythonSupport = true;
···
   smbus-cffi = callPackage ../development/python-modules/smbus-cffi { };
 
   smdebug-rulesconfig = callPackage ../development/python-modules/smdebug-rulesconfig { };
+
+  smhi-pkg = callPackage ../development/python-modules/smhi-pkg { };
 
   smmap2 = throw "smmap2 has been deprecated, use smmap instead."; # added 2020-03-14