Merge branch 'master' into staging

README.md

···
 [<img src="http://nixos.org/logo/nixos-hires.png" width="500px" alt="logo" />](https://nixos.org/nixos)
 
 [![Build Status](https://travis-ci.org/NixOS/nixpkgs.svg?branch=master)](https://travis-ci.org/NixOS/nixpkgs)
-[![Issue Stats](http://www.issuestats.com/github/nixos/nixpkgs/badge/pr)](http://www.issuestats.com/github/nixos/nixpkgs)
-[![Issue Stats](http://www.issuestats.com/github/nixos/nixpkgs/badge/issue)](http://www.issuestats.com/github/nixos/nixpkgs)
+[![Issue Stats](http://www.issuestats.com/github/nixos/nixpkgs/badge/pr?style=flat)](http://www.issuestats.com/github/nixos/nixpkgs)
+[![Issue Stats](http://www.issuestats.com/github/nixos/nixpkgs/badge/issue?style=flat)](http://www.issuestats.com/github/nixos/nixpkgs)
 
 Nixpkgs is a collection of packages for the [Nix](https://nixos.org/nix/) package
 manager. It is periodically built and tested by the [hydra](http://hydra.nixos.org/)

lib/maintainers.nix

···
   palo = "Ingolf Wanger <[e-mail]>";
   pashev = "Igor Pashev <[e-mail]>";
   pesterhazy = "Paulus Esterhazy <[e-mail]>";
-  phausmann = "Philipp Hausmann <[e-mail]>";
+  phile314 = "Philipp Hausmann <[e-mail]>";
   philandstuff = "Philip Potter <[e-mail]>";
   phreedom = "Evgeny Egorochkin <[e-mail]>";
   phunehehe = "Hoang Xuan Phu <[e-mail]>";
···
   steveej = "Stefan Junker <[e-mail]>";
   szczyp = "Szczyp <[e-mail]>";
   sztupi = "Attila Sztupak <[e-mail]>";
+  taeer = "Taeer Bar-Yam <[e-mail]>";
   tailhook = "Paul Colomiets <[e-mail]>";
   taktoa = "Remy Goldschmidt <[e-mail]>";
   telotortium = "Robert Irelan <[e-mail]>";

nixos/doc/manual/man-nixos-rebuild.xml

···
     </listitem>
   </varlistentry>
 
+  <varlistentry>
+    <term><option>--build-host</option></term>
+    <listitem>
+      <para>Instead of building the new configuration locally, use the
+      specified host to perform the build. The host needs to be accessible
+      with ssh, and must be able to perform Nix builds. If the option
+      <option>--target-host</option> is not set, the build will be copied back
+      to the local machine when done.</para>
+
+      <para>Note that, if <option>--no-build-nix</option> is not specified,
+      Nix will be built both locally and remotely. This is because the
+      configuration will always be evaluated locally even though the building
+      might be performed remotely.</para>
+
+      <para>You can include a remote user name in
+      the host name (<replaceable>user@host</replaceable>). You can also set
+      ssh options by defining the <envar>NIX_SSHOPTS</envar> environment
+      variable.</para>
+    </listitem>
+  </varlistentry>
+
+  <varlistentry>
+    <term><option>--target-host</option></term>
+    <listitem>
+      <para>Specifies the NixOS target host. By setting this to something other
+      than <replaceable>localhost</replaceable>, the system activation will
+      happen on the remote host instead of the local machine. The remote host
+      needs to be accessible over ssh, and for the commands
+      <option>switch</option>, <option>boot</option> and <option>test</option>
+      you need root access.</para>
+
+      <para>If <option>--build-host</option> is not explicitly
+      specified, <option>--build-host</option> will implicitly be set to the
+      same value as <option>--target-host</option>. So, if you only specify
+      <option>--target-host</option> both building and activation will take
+      place remotely (and no build artifacts will be copied to the local
+      machine).</para>
+
+      <para>You can include a remote user name in
+      the host name (<replaceable>user@host</replaceable>). You can also set
+      ssh options by defining the <envar>NIX_SSHOPTS</envar> environment
+      variable.</para>
+    </listitem>
+  </varlistentry>
+
 </variablelist>
 
 <para>In addition, <command>nixos-rebuild</command> accepts various
···
       <para>Path to the main NixOS configuration module.  Defaults to
       <filename>/etc/nixos/configuration.nix</filename>.</para>
     </listitem>
+  </varlistentry>
+
+  <varlistentry><term><envar>NIX_SSHOPTS</envar></term>
+
+    <listitem><para>Additional options to be passed to
+    <command>ssh</command> on the command line.</para></listitem>
+
   </varlistentry>
 
 </variablelist>

nixos/modules/config/users-groups.nix

···
   '';
 
   hashedPasswordDescription = ''
-    To generate hashed password install <literal>mkpassword</literal>
+    To generate hashed password install <literal>mkpasswd</literal>
     package and run <literal>mkpasswd -m sha-512</literal>.
   '';
 

nixos/modules/installer/cd-dvd/system-tarball-fuloong2f.nix

···
 
       # Tools to create / manipulate filesystems.
       pkgs.ntfsprogs # for resizing NTFS partitions
-      pkgs.btrfsProgs
+      pkgs.btrfs-progs
       pkgs.jfsutils
 
       # Some compression/archiver tools.

nixos/modules/installer/cd-dvd/system-tarball-sheevaplug.nix

···
       pkgs.dmraid
 
       # Tools to create / manipulate filesystems.
-      pkgs.btrfsProgs
+      pkgs.btrfs-progs
 
       # Some compression/archiver tools.
       pkgs.unzip

nixos/modules/installer/tools/nixos-rebuild.sh

···
 upgrade=
 repair=
 profile=/nix/var/nix/profiles/system
+buildHost=
+targetHost=
 
 while [ "$#" -gt 0 ]; do
     i="$1"; shift 1
···
         fi
         shift 1
         ;;
+      --build-host|h)
+        buildHost="$1"
+        shift 1
+        ;;
+      --target-host|t)
+        targetHost="$1"
+        shift 1
+        ;;
       *)
         echo "$0: unknown option \`$i'"
         exit 1
         ;;
     esac
 done
+
+
+if [ -z "$buildHost" -a -n "$targetHost" ]; then
+    buildHost="$targetHost"
+fi
+if [ "$targetHost" = localhost ]; then
+    targetHost=
+fi
+if [ "$buildHost" = localhost ]; then
+    buildHost=
+fi
+
+buildHostCmd() {
+    if [ -z "$buildHost" ]; then
+        "$@"
+    elif [ -n "$remoteNix" ]; then
+        ssh $SSHOPTS "$buildHost" PATH="$remoteNix:$PATH" "$@"
+    else
+        ssh $SSHOPTS "$buildHost" "$@"
+    fi
+}
+
+targetHostCmd() {
+    if [ -z "$targetHost" ]; then
+        "$@"
+    else
+        ssh $SSHOPTS "$targetHost" "$@"
+    fi
+}
+
+copyToTarget() {
+    if ! [ "$targetHost" = "$buildHost" ]; then
+        if [ -z "$targetHost" ]; then
+            NIX_SSHOPTS=$SSH_OPTS nix-copy-closure --from "$buildHost" "$1"
+        elif [ -z "$buildHost" ]; then
+            NIX_SSHOPTS=$SSH_OPTS nix-copy-closure --to "$targetHost" "$1"
+        else
+            buildHostCmd nix-copy-closure --to "$targetHost" "$1"
+        fi
+    fi
+}
+
+nixBuild() {
+    if [ -z "$buildHost" ]; then
+        nix-build "$@"
+    else
+        local instArgs=()
+        local buildArgs=()
+
+        while [ "$#" -gt 0 ]; do
+            local i="$1"; shift 1
+            case "$i" in
+              -o)
+                local out="$1"; shift 1
+                buildArgs+=("--add-root" "$out" "--indirect")
+                ;;
+              -A)
+                local j="$1"; shift 1
+                instArgs+=("$i" "$j")
+                ;;
+              -I)
+                # We don't want this in buildArgs
+                shift 1
+                ;;
+              "<"*) # nix paths
+                instArgs+=("$i")
+                ;;
+              *)
+                buildArgs+=("$i")
+                ;;
+            esac
+        done
+
+        local drv="$(nix-instantiate "${instArgs[@]}" "${extraBuildFlags[@]}")"
+        if [ -a "$drv" ]; then
+            NIX_SSHOPTS=$SSH_OPTS nix-copy-closure --to "$buildHost" "$drv"
+            buildHostCmd nix-store -r "$drv" "${buildArgs[@]}"
+        else
+            echo "nix-instantiate failed"
+            exit 1
+        fi
+  fi
+}
+
 
 if [ -z "$action" ]; then showSyntax; fi
 
···
 
 
 tmpDir=$(mktemp -t -d nixos-rebuild.XXXXXX)
-trap 'rm -rf "$tmpDir"' EXIT
+SSHOPTS="$NIX_SSHOPTS -o ControlMaster=auto -o ControlPath=$tmpDir/ssh-%n -o ControlPersist=60"
+
+cleanup() {
+    for ctrl in "$tmpDir"/ssh-*; do
+        ssh -o ControlPath="$ctrl" -O exit dummyhost 2>/dev/null || true
+    done
+    rm -rf "$tmpDir"
+}
+trap cleanup EXIT
+
 
 
 # If the Nix daemon is running, then use it.  This allows us to use
···
     buildNix=
 fi
 
+prebuiltNix() {
+    machine="$1"
+    if [ "$machine" = x86_64 ]; then
+        return /nix/store/xryr9g56h8yjddp89d6dw12anyb4ch7c-nix-1.10
+    elif [[ "$machine" =~ i.86 ]]; then
+        return /nix/store/2w92k5wlpspf0q2k9mnf2z42prx3bwmv-nix-1.10
+    else
+        echo "$0: unsupported platform"
+        exit 1
+    fi
+}
+
+remotePATH=
+
 if [ -n "$buildNix" ]; then
     echo "building Nix..." >&2
-    if ! nix-build '<nixpkgs/nixos>' -A config.nix.package -o $tmpDir/nix "${extraBuildFlags[@]}" > /dev/null; then
-        if ! nix-build '<nixpkgs/nixos>' -A nixFallback -o $tmpDir/nix "${extraBuildFlags[@]}" > /dev/null; then
-            if ! nix-build '<nixpkgs>' -A nix -o $tmpDir/nix "${extraBuildFlags[@]}" > /dev/null; then
-                machine="$(uname -m)"
-                if [ "$machine" = x86_64 ]; then
-                    nixStorePath=/nix/store/xryr9g56h8yjddp89d6dw12anyb4ch7c-nix-1.10
-                elif [[ "$machine" =~ i.86 ]]; then
-                    nixStorePath=/nix/store/2w92k5wlpspf0q2k9mnf2z42prx3bwmv-nix-1.10
-                else
-                    echo "$0: unsupported platform"
-                    exit 1
-                fi
+    nixDrv=
+    if ! nixDrv="$(nix-instantiate '<nixpkgs/nixos>' --add-root $tmpDir/nixdrv --indirect -A config.nix.package "${extraBuildFlags[@]}")"; then
+        if ! nixDrv="$(nix-instantiate '<nixpkgs/nixos>' --add-root $tmpDir/nixdrv --indirect -A nixFallback "${extraBuildFlags[@]}")"; then
+            if ! nixDrv="$(nix-instantiate '<nixpkgs>' --add-root $tmpDir/nixdrv --indirect -A nix "${extraBuildFlags[@]}")"; then
+                nixStorePath="$(prebuiltNix "$(uname -m)")"
                 if ! nix-store -r $nixStorePath --add-root $tmpDir/nix --indirect \
                     --option extra-binary-caches https://cache.nixos.org/; then
                     echo "warning: don't know how to get latest Nix" >&2
                 fi
                 # Older version of nix-store -r don't support --add-root.
                 [ -e $tmpDir/nix ] || ln -sf $nixStorePath $tmpDir/nix
+                if [ -n "$buildHost" ]; then
+                    remoteNixStorePath="$(prebuiltNix "$(buildHostCmd uname -m)")"
+                    remoteNix="$remoteNixStorePath/bin"
+                    if ! buildHostCmd nix-store -r $remoteNixStorePath \
+                      --option extra-binary-caches https://cache.nixos.org/ >/dev/null; then
+                        remoteNix=
+                        echo "warning: don't know how to get latest Nix" >&2
+                    fi
+                fi
             fi
         fi
     fi
-    PATH=$tmpDir/nix/bin:$PATH
+    if [ -a "$nixDrv" ]; then
+        nix-store -r "$nixDrv" --add-root $tmpDir/nix --indirect >/dev/null
+        if [ -n "$buildHost" ]; then
+            nix-copy-closure --to "$buildHost" "$nixDrv"
+            # The nix build produces multiple outputs, we add them all to the remote path
+            for p in $(buildHostCmd nix-store -r "$(readlink "$nixDrv")" "${buildArgs[@]}"); do
+                remoteNix="$remoteNix${remoteNix:+:}$p/bin"
+            done
+        fi
+    fi
+    PATH="$tmpDir/nix/bin:$PATH"
 fi
 
 
···
 if [ -z "$rollback" ]; then
     echo "building the system configuration..." >&2
     if [ "$action" = switch -o "$action" = boot ]; then
-        nix-env "${extraBuildFlags[@]}" -p "$profile" -f '<nixpkgs/nixos>' --set -A system
-        pathToConfig="$profile"
+        pathToConfig="$(nixBuild '<nixpkgs/nixos>' -A system "${extraBuildFlags[@]}")"
+        copyToTarget "$pathToConfig"
+        targetHostCmd nix-env -p "$profile" --set "$pathToConfig"
     elif [ "$action" = test -o "$action" = build -o "$action" = dry-build -o "$action" = dry-activate ]; then
-        nix-build '<nixpkgs/nixos>' -A system -k "${extraBuildFlags[@]}" > /dev/null
-        pathToConfig=./result
+        pathToConfig="$(nixBuild '<nixpkgs/nixos>' -A system -k "${extraBuildFlags[@]}")"
     elif [ "$action" = build-vm ]; then
-        nix-build '<nixpkgs/nixos>' -A vm -k "${extraBuildFlags[@]}" > /dev/null
-        pathToConfig=./result
+        pathToConfig="$(nixBuild '<nixpkgs/nixos>' -A vm -k "${extraBuildFlags[@]}")"
     elif [ "$action" = build-vm-with-bootloader ]; then
-        nix-build '<nixpkgs/nixos>' -A vmWithBootLoader -k "${extraBuildFlags[@]}" > /dev/null
-        pathToConfig=./result
+        pathToConfig="$(nixBuild '<nixpkgs/nixos>' -A vmWithBootLoader -k "${extraBuildFlags[@]}")"
     else
         showSyntax
     fi
+    # Copy build to target host if we haven't already done it
+    if ! [ "$action" = switch -o "$action" = boot ]; then
+        copyToTarget "$pathToConfig"
+    fi
 else # [ -n "$rollback" ]
     if [ "$action" = switch -o "$action" = boot ]; then
-        nix-env --rollback -p "$profile"
+        targetHostCmd nix-env --rollback -p "$profile"
         pathToConfig="$profile"
     elif [ "$action" = test -o "$action" = build ]; then
         systemNumber=$(
-            nix-env -p "$profile" --list-generations |
+            targetHostCmd nix-env -p "$profile" --list-generations |
             sed -n '/current/ {g; p;}; s/ *\([0-9]*\).*/\1/; h'
         )
-        ln -sT "$profile"-${systemNumber}-link ./result
-        pathToConfig=./result
+        pathToConfig="$profile"-${systemNumber}-link
+        if [ -z "$targetHost" ]; then
+            ln -sT "$pathToConfig" ./result
+        fi
     else
         showSyntax
     fi
···
 # If we're not just building, then make the new configuration the boot
 # default and/or activate it now.
 if [ "$action" = switch -o "$action" = boot -o "$action" = test -o "$action" = dry-activate ]; then
-    if ! $pathToConfig/bin/switch-to-configuration "$action"; then
+    if ! targetHostCmd $pathToConfig/bin/switch-to-configuration "$action"; then
         echo "warning: error(s) occurred while switching to the new configuration" >&2
         exit 1
     fi

nixos/modules/installer/tools/tools.nix

···
   nixos-generate-config = makeProg {
     name = "nixos-generate-config";
     src = ./nixos-generate-config.pl;
-    path = [ pkgs.btrfsProgs ];
+    path = [ pkgs.btrfs-progs ];
     perl = "${pkgs.perl}/bin/perl -I${pkgs.perlPackages.FileSlurp}/lib/perl5/site_perl";
     inherit (config.system) nixosRelease;
   };

nixos/modules/misc/ids.nix

···
       bepasty = 215;
       pumpio = 216;
       nm-openvpn = 217;
+      mathics = 218;
 
       # When adding a uid, make sure it doesn't match an existing gid. And don't use uids above 399!
 
···
       bepasty = 215;
       pumpio = 216;
       nm-openvpn = 217;
+      mathics = 218;
 
       # When adding a gid, make sure it doesn't match an existing
       # uid. Users and groups with the same name should have equal

nixos/modules/module-list.nix

···
   ./services/misc/gitolite.nix
   ./services/misc/gpsd.nix
   ./services/misc/ihaskell.nix
+  ./services/misc/mathics.nix
   ./services/misc/mbpfan.nix
   ./services/misc/mediatomb.nix
   ./services/misc/mesos-master.nix

nixos/modules/profiles/graphical.nix

···
     enable = true;
     displayManager.kdm.enable = true;
     desktopManager.kde4.enable = true;
+    synaptics.enable = true; # for touchpad support on many laptops
   };
 
   environment.systemPackages = [ pkgs.glxinfo ];

nixos/modules/programs/command-not-found/command-not-found.nix

···
     isExecutable = true;
     inherit (pkgs) perl;
     perlFlags = concatStrings (map (path: "-I ${path}/lib/perl5/site_perl ")
-      [ pkgs.perlPackages.DBI pkgs.perlPackages.DBDSQLite ]);
+      [ pkgs.perlPackages.DBI pkgs.perlPackages.DBDSQLite pkgs.perlPackages.StringShellQuote ]);
   };
 
 in
···
         local p=/run/current-system/sw/bin/command-not-found
         if [ -x $p -a -f /nix/var/nix/profiles/per-user/root/channels/nixos/programs.sqlite ]; then
           # Run the helper program.
-          $p "$1"
+          $p "$@"
           # Retry the command if we just installed it.
           if [ $? = 126 ]; then
             "$@"
···
         local p=/run/current-system/sw/bin/command-not-found
         if [ -x $p -a -f /nix/var/nix/profiles/per-user/root/channels/nixos/programs.sqlite ]; then
           # Run the helper program.
-          $p "$1"
+          $p "$@"
 
           # Retry the command if we just installed it.
           if [ $? = 126 ]; then

nixos/modules/programs/command-not-found/command-not-found.pl

···
 use strict;
 use DBI;
 use DBD::SQLite;
+use String::ShellQuote;
 use Config;
 
 my $program = $ARGV[0];
···
 EOF
         ;
         exit 126 if system("nix-env", "-iA", "nixos.$package") == 0;
+    } elsif ($ENV{"NIX_AUTO_RUN"} // "") {
+        exec("nix-shell", "-p", $package, "--run", shell_quote("exec", @ARGV));
     } else {
         print STDERR <<EOF;
 The program ‘$program’ is currently not installed. You can install it by typing:

nixos/modules/services/hardware/sane.nix

···
 
 let
 
-  pkg = if config.hardware.sane.snapshot then pkgs.saneBackendsGit else pkgs.saneBackends;
+  pkg = if config.hardware.sane.snapshot
+    then pkgs.sane-backends-git
+    else pkgs.sane-backends;
   backends = [ pkg ] ++ config.hardware.sane.extraBackends;
   saneConfig = pkgs.mkSaneConfig { paths = backends; };
 

nixos/modules/services/hardware/thinkfan.nix

···
 
     sensor ${cfg.sensor} (0, 10, 15, 2, 10, 5, 0, 3, 0, 3)
     
-    (0,     0,      55)
-    (1,     48,     60)
-    (2,     50,     61)
-    (3,     52,     63)
-    (6,     56,     65)
-    (7,     60,     85)
-    (127,   80,     32767)
+    ${cfg.levels}
   '';
 
 in {
···
           Sensor used by thinkfan
         '';
       };
+
+      levels = mkOption {
+        default = ''
+          (0,     0,      55)
+          (1,     48,     60)
+          (2,     50,     61)
+          (3,     52,     63)
+          (6,     56,     65)
+          (7,     60,     85)
+          (127,   80,     32767)
+        '';
+        description =''
+          Sensor used by thinkfan
+        '';
+      };
+
 
     };
 

nixos/modules/services/misc/mathics.nix

···
+{ pkgs, lib, config, ... }:
+
+with lib;
+
+let
+  cfg = config.services.mathics;
+
+in {
+  options = {
+    services.mathics = {
+      enable = mkEnableOption "Mathics notebook service";
+
+      external = mkOption {
+        type = types.bool;
+        default = false;
+        description = "Listen on all interfaces, rather than just localhost?";
+      };
+
+      port = mkOption {
+        type = types.int;
+        default = 8000;
+        description = "TCP port to listen on.";
+      };
+    };
+  };
+
+  config = mkIf cfg.enable {
+
+    users.extraUsers.mathics = {
+      group = config.users.extraGroups.mathics.name;
+      description = "Mathics user";
+      home = "/var/lib/mathics";
+      createHome = true;
+      uid = config.ids.uids.mathics;
+    };
+
+    users.extraGroups.mathics.gid = config.ids.gids.mathics;
+
+    systemd.services.mathics = {
+      description = "Mathics notebook server";
+      wantedBy = [ "multi-user.target" ];
+      after = [ "network.target" ];
+      serviceConfig = {
+        User = config.users.extraUsers.mathics.name;
+        Group = config.users.extraGroups.mathics.name;
+        ExecStart = concatStringsSep " " [
+          "${pkgs.mathics}/bin/mathicsserver"
+          "--port" (toString cfg.port)
+          (if cfg.external then "--external" else "")
+        ];
+      };
+    };
+  };
+}

nixos/modules/services/monitoring/graphite.nix

···
       };
 
       enableAggregator = mkOption {
-        description = "Whether to enable carbon agregator, the carbon buffering service.";
+        description = "Whether to enable carbon aggregator, the carbon buffering service.";
         default = false;
         type = types.bool;
       };
 
       aggregationRules = mkOption {
-        description = "Defines if and how received metrics will be agregated.";
+        description = "Defines if and how received metrics will be aggregated.";
         default = null;
         type = types.uniq (types.nullOr types.string);
         example = ''

nixos/modules/services/security/fail2ban.nix

···
         findtime = 600
         maxretry = 3
         backend  = systemd
+        enabled  = true
        '';
 
     # Block SSH if there are too many failing connection attempts.

nixos/modules/services/ttys/kmscon.nix

···
         default = "";
         example = "font-size=14";
       };
+
+      extraOptions = mkOption {
+        description = "Extra flags to pass to kmscon.";
+        type = types.separatedString " ";
+        default = "";
+        example = "--term xterm-256color";
+      };
     };
   };
 
···
       ConditionPathExists=/dev/tty0
 
       [Service]
-      ExecStart=${pkgs.kmscon}/bin/kmscon "--vt=%I" --seats=seat0 --no-switchvt --configdir ${configDir} --login -- ${pkgs.shadow}/bin/login -p
+      ExecStart=${pkgs.kmscon}/bin/kmscon "--vt=%I" ${cfg.extraOptions} --seats=seat0 --no-switchvt --configdir ${configDir} --login -- ${pkgs.shadow}/bin/login -p
       UtmpIdentifier=%I
       TTYPath=/dev/%I
       TTYReset=yes

nixos/modules/system/boot/kernel.nix

···
 
     boot.kernel.sysctl."kernel.printk" = config.boot.consoleLogLevel;
 
-    boot.kernelModules = [ "loop" "configs" "atkbd" ];
+    boot.kernelModules = [ "loop" "atkbd" ];
 
     boot.initrd.availableKernelModules =
       [ # Note: most of these (especially the SATA/PATA modules)

nixos/modules/system/boot/loader/grub/grub.nix

···
         extraEntriesBeforeNixOS extraPrepareConfig configurationLimit copyKernels timeout
         default fsIdentifier efiSupport gfxmodeEfi gfxmodeBios;
       path = (makeSearchPath "bin" ([
-        pkgs.coreutils pkgs.gnused pkgs.gnugrep pkgs.findutils pkgs.diffutils pkgs.btrfsProgs
+        pkgs.coreutils pkgs.gnused pkgs.gnugrep pkgs.findutils pkgs.diffutils pkgs.btrfs-progs
         pkgs.utillinux ] ++ (if cfg.efiSupport && (cfg.version == 2) then [pkgs.efibootmgr ] else [])
       )) + ":" + (makeSearchPath "sbin" [
         pkgs.mdadm pkgs.utillinux

nixos/modules/system/boot/stage-1-init.sh

···
 
 
 # Create device nodes in /dev.
+@preDeviceCommands@
 echo "running udev..."
 mkdir -p /etc/udev
 ln -sfn @udevRules@ /etc/udev/rules.d

nixos/modules/system/boot/stage-1.nix

···
     inherit (config.boot) resumeDevice devSize runSize;
 
     inherit (config.boot.initrd) checkJournalingFS
-      postEarlyDeviceCommands preLVMCommands postDeviceCommands postMountCommands kernelModules;
+      preLVMCommands preDeviceCommands postEarlyDeviceCommands postDeviceCommands postMountCommands kernelModules;
 
     resumeDevices = map (sd: if sd ? device then sd.device else "/dev/disk/by-label/${sd.label}")
                     (filter (sd: (sd ? label || hasPrefix "/dev/" sd.device) && !sd.randomEncryption) config.swapDevices);
···
       type = types.lines;
       description = ''
         Shell commands to be executed immediately before LVM discovery.
+      '';
+    };
+
+    boot.initrd.preDeviceCommands = mkOption {
+      default = "";
+      type = types.lines;
+      description = ''
+        Shell commands to be executed before udev is started to create
+        device nodes.
       '';
     };
 

nixos/modules/tasks/filesystems/btrfs.nix

···
 {
   config = mkIf (any (fs: fs == "btrfs") config.boot.supportedFilesystems) {
 
-    system.fsPackages = [ pkgs.btrfsProgs ];
+    system.fsPackages = [ pkgs.btrfs-progs ];
 
     boot.initrd.kernelModules = mkIf inInitrd [ "btrfs" "crc32c" ];
 
     boot.initrd.extraUtilsCommands = mkIf inInitrd
       ''
-        copy_bin_and_libs ${pkgs.btrfsProgs}/bin/btrfs
+        copy_bin_and_libs ${pkgs.btrfs-progs}/bin/btrfs
         ln -sv btrfs $out/bin/btrfsck
         ln -sv btrfsck $out/bin/fsck.btrfs
       '';
···
     # new devices are discovered.
     jobs.udev.postStart =
       ''
-        ${pkgs.btrfsProgs}/bin/btrfs device scan
+        ${pkgs.btrfs-progs}/bin/btrfs device scan
       '';
 
   };

nixos/modules/testing/test-instrumentation.nix

···
     # into thinking they're running interactively.
     environment.variables.PAGER = "";
 
+    boot.initrd.preDeviceCommands =
+      ''
+        echo 600 > /proc/sys/kernel/hung_task_timeout_secs
+      '';
+
     boot.initrd.postDeviceCommands =
       ''
         # Using acpi_pm as a clock source causes the guest clock to

nixos/modules/virtualisation/lxd.nix

···
         after = [ "systemd-udev-settle.service" ];
 
         # TODO(wkennington): Add lvm2 and thin-provisioning-tools
-        path = with pkgs; [ acl rsync gnutar xz btrfsProgs ];
+        path = with pkgs; [ acl rsync gnutar xz btrfs-progs ];
 
         serviceConfig.ExecStart = "@${pkgs.lxd}/bin/lxd lxd --syslog --group lxd";
         serviceConfig.Type = "simple";

nixos/release.nix

···
   #tests.lightdm = callTest tests/lightdm.nix {};
   tests.login = callTest tests/login.nix {};
   #tests.logstash = callTest tests/logstash.nix {};
+  tests.mathics = callTest tests/mathics.nix {};
   tests.misc = callTest tests/misc.nix {};
   tests.mumble = callTest tests/mumble.nix {};
   tests.munin = callTest tests/munin.nix {};

nixos/tests/mathics.nix

···
+import ./make-test.nix ({ pkgs, ... }: {
+  name = "mathics";
+  meta = with pkgs.stdenv.lib.maintainers; {
+    maintainers = [ benley ];
+  };
+
+  nodes = {
+    machine = { config, pkgs, ... }: {
+      services.mathics.enable = true;
+      services.mathics.port = 8888;
+    };
+  };
+
+  testScript = ''
+    startAll;
+    $machine->waitForUnit("mathics.service");
+    $machine->waitForOpenPort(8888);
+    $machine->succeed("curl http://localhost:8888/");
+  '';
+})

nixos/tests/partition.nix

···
   machine = { config, pkgs, ... }: {
     environment.systemPackages = [
       pkgs.pythonPackages.nixpart0
-      pkgs.file pkgs.btrfsProgs pkgs.xfsprogs pkgs.lvm2
+      pkgs.file pkgs.btrfs-progs pkgs.xfsprogs pkgs.lvm2
     ];
     virtualisation.emptyDiskImages = [ 4096 4096 ];
   };

pkgs/applications/audio/snd/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "snd-15.4";
+  name = "snd-15.9";
 
   src = fetchurl {
     url = "mirror://sourceforge/snd/${name}.tar.gz";
-    sha256 = "1dari02ind445h5hpb6dhi0kix1vmlk64lyxwv1zrqagw3ajmpwh";
+    sha256 = "0hs9ailgaphgyi3smnrpwksvdww85aa7szqgi6l6d2jwfx9g4bhd";
   };
 
   nativeBuildInputs = [ pkgconfig ];

pkgs/applications/editors/flpsed/default.nix

···
 {stdenv, fetchurl, fltk13, ghostscript}:
 
 stdenv.mkDerivation {
-  name = "flpsed-0.7.2";
+  name = "flpsed-0.7.3";
 
   src = fetchurl {
-    url = "http://www.ecademix.com/JohannesHofmann/flpsed-0.7.2.tar.gz";
-    sha256 = "1132nlganr6x4f4lzcp9l0xihg2ky1l7xk8vq7r2l2qxs97vbif8";
+    url = "http://www.ecademix.com/JohannesHofmann/flpsed-0.7.3.tar.gz";
+    sha256 = "0vngqxanykicabhfdznisv82k5ypkxwg0s93ms9ribvhpm8vf2xp";
   };
 
   buildInputs = [ fltk13 ghostscript ];

pkgs/applications/graphics/fbida/default.nix

···
 { stdenv, fetchurl, libjpeg, libexif, libungif, libtiff, libpng, libwebp
-, pkgconfig, freetype, fontconfig, which, imagemagick, curl, saneBackends
+, pkgconfig, freetype, fontconfig, which, imagemagick, curl, sane-backends
 }:
 
 stdenv.mkDerivation rec {
···
   nativeBuildInputs = [ pkgconfig which ];
   buildInputs =
     [ libexif libjpeg libpng libungif freetype fontconfig libtiff libwebp
-      imagemagick curl saneBackends
+      imagemagick curl sane-backends
     ];
   
   makeFlags = [ "prefix=$(out)" "verbose=yes" ];

pkgs/applications/graphics/sane/backends/git.nix

···
 { callPackage, fetchgit, ... } @ args:
 
 callPackage ./generic.nix (args // {
-  version = "2015-12-27";
+  version = "2016-01-01";
   src = fetchgit {
-    sha256 = "4bf6e8815d2edbbc75255928d0fb030639a9fea9a5aa953dcf1f00e167eff527";
-    rev = "cadb4b0fff00540159625320416e5601c4704627";
+    sha256 = "412c88b2b2b699b5a2ab28c7696c715e46b600398391ae038840c6b8674aea7c";
+    rev = "3f0c3df2fcde8d0cf30ab68c70cb5cad984dda6f";
     url = "git://alioth.debian.org/git/sane/sane-backends.git";
   };
 })

pkgs/applications/graphics/sane/frontends.nix

···
-{ stdenv, fetchurl, saneBackends, libX11, gtk, pkgconfig, libusb ? null}:
+{ stdenv, fetchurl, sane-backends, libX11, gtk, pkgconfig, libusb ? null}:
 
 stdenv.mkDerivation rec {
   name = "sane-frontends-1.0.14";
···
     sed -e '/SANE_CAP_ALWAYS_SETTABLE/d' -i src/gtkglue.c
   '';
 
-  buildInputs = [saneBackends libX11 gtk pkgconfig] ++
+  buildInputs = [sane-backends libX11 gtk pkgconfig] ++
 	(if libusb != null then [libusb] else []);
 
   meta = {

pkgs/applications/graphics/sane/xsane.nix

···
-{ stdenv, fetchurl, saneBackends, saneFrontends, libX11, gtk, pkgconfig, libpng
+{ stdenv, fetchurl, sane-backends, saneFrontends, libX11, gtk, pkgconfig, libpng
 , libusb ? null
 , gimpSupport ? false, gimp_2_8 ? null
 }:
···
     chmod a+rX -R .
   '';
 
-  buildInputs = [libpng saneBackends saneFrontends libX11 gtk pkgconfig ]
+  buildInputs = [libpng sane-backends saneFrontends libX11 gtk pkgconfig ]
     ++ (if libusb != null then [libusb] else [])
     ++ stdenv.lib.optional gimpSupport gimp_2_8;
 

pkgs/applications/graphics/simple-scan/default.nix

···
 { stdenv, fetchurl, cairo, colord, glib, gtk3, gusb, intltool, itstool
-, libusb1, libxml2, pkgconfig, saneBackends, vala, wrapGAppsHook }:
+, libusb1, libxml2, pkgconfig, sane-backends, vala, wrapGAppsHook }:
 
 let version = "3.19.3"; in
 stdenv.mkDerivation rec {
···
     url = "https://launchpad.net/simple-scan/3.19/${version}/+download/${name}.tar.xz";
   };
 
-  buildInputs = [ cairo colord glib gusb gtk3 libusb1 libxml2 saneBackends
+  buildInputs = [ cairo colord glib gusb gtk3 libusb1 libxml2 sane-backends
     vala ];
   nativeBuildInputs = [ intltool itstool pkgconfig wrapGAppsHook ];
 

pkgs/applications/graphics/sxiv/default.nix

···
-{ stdenv, fetchgit, libX11, imlib2, giflib, libexif }:
-
-stdenv.mkDerivation {
-  name = "sxiv-2015.03.25";
+{ stdenv, fetchFromGitHub, libX11, imlib2, giflib, libexif }:
 
-  src = fetchgit {
-    url = "https://github.com/muennich/sxiv.git";
-    rev = "01ed483b50f506fcba928af43e2ca017897e7c77";
-    sha256 = "18s64l3dvibqg9biznzy4mdkkn9qmmpqxpdx7ljx7c0832aqy94k";
+stdenv.mkDerivation rec {
+  name = "sxiv-${version}";
+  version = "v1.3.2";
+  #https://github.com/muennich/sxiv/archive/v1.3.2.zip
+  src = fetchFromGitHub {
+    owner = "muennich";
+    repo = "sxiv";
+    rev = version;
+    sha256 = "1f4gz1qjhb44bbb3q5fqk439zyipkwnr19zhg89yq2pgmzzzqr2h";
   };
 
   postUnpack = ''

pkgs/applications/graphics/xzgv/default.nix

···
+{ stdenv, fetchurl, gtk, pkgconfig, texinfo }:
+
+stdenv.mkDerivation rec {
+  name = "xzgv-${version}";
+  version = "0.9.1";
+  src = fetchurl {
+    url = "mirror://sourceforge/xzgv/xzgv-${version}.tar.gz";
+    sha256 = "1rh432wnvzs434knzbda0fslhfx0gngryrrnqkfm6gwd2g5mxcph";
+  };
+  buildInputs = [ gtk pkgconfig texinfo ];
+  patches = [ ./fix-linker-paths.patch ];
+  postPatch = ''
+    substituteInPlace config.mk \
+      --replace /usr/local $out
+    substituteInPlace config.mk \
+      --replace "CFLAGS=-O2 -Wall" "CFLAGS=-Wall"
+    substituteInPlace Makefile \
+      --replace "all: src man" "all: src man info"
+  '';
+  meta = with stdenv.lib; {
+    homepage = http://sourceforge.net/projects/xzgv/;
+    description = "Picture viewer for X with a thumbnail-based selector";
+    license = licenses.gpl2;
+    maintainers = [ maintainers.womfoo ];
+    platforms = platforms.linux;
+  };
+}

pkgs/applications/graphics/xzgv/fix-linker-paths.patch

···
+taken from http://sourceforge.net/p/xzgv/code/53/tree//trunk/xzgv/src/Makefile?diff=514dada434309d2ec11f5eff:52
+--- a/src/Makefile
++++ b/src/Makefile
+@@ -9,8 +9,10 @@
+ # This gets definitions for CC, CFLAGS, BINDIR etc.
+ include ../config.mk
+ 
+-CFLAGS+=`pkg-config --cflags gtk+-2.0` `pkg-config --cflags gdk-pixbuf-2.0`
+-LDFLAGS+=`pkg-config --libs gtk+-2.0` `pkg-config --libs gdk-pixbuf-2.0`
++CFLAGS+=`pkg-config --cflags gtk+-2.0` `pkg-config --cflags gdk-pixbuf-2.0` \
++	`pkg-config --cflags x11`
++LDFLAGS+=`pkg-config --libs gtk+-2.0` `pkg-config --libs gdk-pixbuf-2.0` \
++	`pkg-config --libs x11` -lm
+ 
+ all: xzgv
+ 
+@@ -23,7 +25,7 @@
+ 	backend.o
+ 
+ xzgv: $(OBJS)
+-	$(CC) $(LDFLAGS) -o xzgv $(OBJS)
++	$(CC) -o xzgv $(OBJS) $(LDFLAGS)
+ 
+ installdirs:
+ 	/bin/sh ../mkinstalldirs $(BINDIR)

pkgs/applications/misc/calibre/default.nix

···
 { stdenv, fetchurl, python, pyqt5, sip_4_16, poppler_utils, pkgconfig, libpng
 , imagemagick, libjpeg, fontconfig, podofo, qtbase, icu, sqlite
-, makeWrapper, unrar, chmlib, pythonPackages, xz, libusb1, libmtp
+, makeWrapper, unrarSupport ? false, chmlib, pythonPackages, xz, libusb1, libmtp
 , xdg_utils
 }:
 
 stdenv.mkDerivation rec {
-  version = "2.46.0";
+  version = "2.48.0";
   name = "calibre-${version}";
 
   src = fetchurl {
     url = "http://download.calibre-ebook.com/${version}/${name}.tar.xz";
-    sha256 = "0ig1pb62w57l6nhwg391mkjhw9dyicix6xigpdyw0320jdw9nlkb";
+    sha256 = "0bjzw806czqxkhq9qqkhff8bhfc428pijkidb1h6gr47jqdp4hpg";
   };
 
   inherit python;
 
-  patchPhase = ''
+  patches = stdenv.lib.optional (!unrarSupport) ./dont_build_unrar_plugin.patch;
+
+  prePatch = ''
     sed -i "/pyqt_sip_dir/ s:=.*:= '${pyqt5}/share/sip':"  \
       setup/build_environment.py
   '';
···
 
     for a in $out/bin/*; do
       wrapProgram $a --prefix PYTHONPATH : $PYTHONPATH \
-                     --prefix LD_LIBRARY_PATH : ${unrar}/lib \
                      --prefix PATH : ${poppler_utils}/bin
     done
   '';
···
   meta = with stdenv.lib; {
     description = "Comprehensive e-book software";
     homepage = http://calibre-ebook.com;
-    license = licenses.gpl3;
+    license = with licenses; if unrarSupport then unfreeRedistributable else gpl3;
     maintainers = with maintainers; [ viric iElectric pSub AndersonTorres ];
     platforms = platforms.linux;
     inherit version;

pkgs/applications/misc/calibre/dont_build_unrar_plugin.patch

···
+Author: Dmitry Shachnev <[e-mail]>
+Description: do not build unrar extension as we strip unrar from the tarball
+Forwarded: not-needed
+Last-Update: 2013-04-04
+
+Index: calibre/setup/extensions.py
+===================================================================
+--- calibre.orig/setup/extensions.py	2014-02-02 10:42:14.510954007 +0100
++++ calibre/setup/extensions.py	2014-02-02 10:42:14.502954007 +0100
+@@ -209,24 +209,6 @@
+                 sip_files=['calibre/ebooks/pdf/render/qt_hack.sip']
+                 ),
+ 
+-    Extension('unrar',
+-              ['unrar/%s.cpp'%(x.partition('.')[0]) for x in '''
+-               rar.o strlist.o strfn.o pathfn.o savepos.o smallfn.o global.o file.o
+-               filefn.o filcreat.o archive.o arcread.o unicode.o system.o
+-               isnt.o crypt.o crc.o rawread.o encname.o resource.o match.o
+-               timefn.o rdwrfn.o consio.o options.o ulinks.o errhnd.o rarvm.o
+-               secpassword.o rijndael.o getbits.o sha1.o extinfo.o extract.o
+-               volume.o list.o find.o unpack.o cmddata.o filestr.o scantree.o
+-               '''.split()] + ['calibre/utils/unrar.cpp'],
+-              inc_dirs=['unrar'],
+-              cflags=[('/' if iswindows else '-') + x for x in (
+-                  'DSILENT', 'DRARDLL', 'DUNRAR')] + (
+-                  [] if iswindows else ['-D_FILE_OFFSET_BITS=64',
+-                                        '-D_LARGEFILE_SOURCE']),
+-              optimize_level=2,
+-              libraries=['User32', 'Advapi32', 'kernel32', 'Shell32'] if iswindows else []
+-              ),
+-
+     ]
+ 
+ 
+Index: calibre/src/calibre/ebooks/metadata/archive.py
+===================================================================
+--- calibre.orig/src/calibre/ebooks/metadata/archive.py	2014-02-02 10:42:14.510954007 +0100
++++ calibre/src/calibre/ebooks/metadata/archive.py	2014-02-02 10:42:14.502954007 +0100
+@@ -42,7 +42,7 @@
+     description = _('Extract common e-book formats from archives '
+         '(zip/rar) files. Also try to autodetect if they are actually '
+         'cbz/cbr files.')
+-    file_types = set(['zip', 'rar'])
++    file_types = set(['zip'])
+     supported_platforms = ['windows', 'osx', 'linux']
+     on_import = True
+ 

pkgs/applications/misc/cool-retro-term/default.nix

···
-{ stdenv, fetchgit, makeQtWrapper, qtbase, qtquick1, qmltermwidget }:
+{ stdenv, fetchgit, makeQtWrapper, qtbase, qtquick1, qmltermwidget,
+qtquickcontrols, qtgraphicaleffects }:
 
 stdenv.mkDerivation rec {
   version = "1.0.0";
···
     sed -i -e '/qmltermwidget/d' cool-retro-term.pro
   '';
 
-  buildInputs = [ qtbase qtquick1 qmltermwidget ];
+  buildInputs = [ qtbase qtquick1 qmltermwidget qtquickcontrols qtgraphicaleffects ];
   nativeBuildInputs = [ makeQtWrapper ];
 
   configurePhase = "qmake PREFIX=$out";

pkgs/applications/misc/ding/default.nix

···
 
     sed -i "s@/usr/bin/fortune@fortune@g" ding
 
+    sed -i "s@/usr/bin/ding@$out/bin/ding@g" ding.desktop
+
     cp ding $out/bin/
     cp de-en.txt $out/share/dict/
     cp ding.1 $out/share/man/man1/

pkgs/applications/misc/redshift/default.nix

···
 }:
 
 let
-  version = "1.10";
-  mkFlag = flag: name: if flag then "--enable-${name}" else "--disable-${name}";
+  version = "1.11";
+  mkFlag = flag: name: if flag
+    then "--enable-${name}"
+    else "--disable-${name}";
 in
 stdenv.mkDerivation {
   name = "redshift-${version}";
   src = fetchurl {
-    sha256 = "19pfk9il5x2g2ivqix4a555psz8mj3m0cvjwnjpjvx0llh5fghjv";
+    sha256 = "0ngkwj7rg8nfk806w0sg443w6wjr91xdc0zisqfm5h2i77wm1qqh";
     url = "https://github.com/jonls/redshift/releases/download/v${version}/redshift-${version}.tar.xz";
   };
 
   buildInputs = [ geoclue2 ]
-    ++ stdenv.lib.optionals guiSupport [ hicolor_icon_theme gtk3 python pygobject3 pyxdg ]
+    ++ stdenv.lib.optionals guiSupport [ hicolor_icon_theme gtk3 python
+      pygobject3 pyxdg ]
     ++ stdenv.lib.optionals drmSupport [ libdrm ]
     ++ stdenv.lib.optionals randrSupport [ libxcb ]
     ++ stdenv.lib.optionals vidModeSupport [ libX11 libXxf86vm ];
···
     (mkFlag vidModeSupport "vidmode")
   ];
 
+  enableParallelBuilding = true;
+
   preInstall = stdenv.lib.optionalString guiSupport ''
     substituteInPlace src/redshift-gtk/redshift-gtk \
       --replace "/usr/bin/env python3" "${python}/bin/${python.executable}"
···
       --prefix PYTHONPATH : "$PYTHONPATH" \
       --prefix GI_TYPELIB_PATH : "$GI_TYPELIB_PATH" \
       --prefix XDG_DATA_DIRS : "$out/share:${hicolor_icon_theme}/share"
+
+    install -Dm644 {.,$out/share/doc/redshift}/redshift.conf.sample
   '';
 
   meta = with stdenv.lib; {

pkgs/applications/misc/surf/default.nix pkgs/applications/networking/browsers/surf/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "surf-${version}";
-  version="0.6";
+  version="0.7";
 
   src = fetchurl {
     url = "http://dl.suckless.org/surf/surf-${version}.tar.gz";
-    sha256 = "01b8hq8z2wd7ssym5bypx2b15mrs1lhgkrcgxf700kswxvxcrhgx";
+    sha256 = "0jj93izd8fizxfa6ln9w1h9bwki81sz5dhskh5x1rl34zd38aq4m";
   };
 
   buildInputs = [ gtk makeWrapper webkit gsettings_desktop_schemas pkgconfig glib libsoup ];
···
 
   buildPhase = " make ";
 
-# `-lX11' to make sure libX11's store path is in the RPATH
+  # `-lX11' to make sure libX11's store path is in the RPATH
   NIX_LDFLAGS = "-lX11";
-  preConfigure = [ ''sed -i "s@PREFIX = /usr/local@PREFIX = $out@g" config.mk'' ];
-  installPhase = ''
-    make PREFIX=/ DESTDIR=$out install
-  '';
+  preConfigure = ''sed -i "s@PREFIX = /usr/local@PREFIX = $out@g" config.mk'';
+  installFlags = [ "PREFIX=/" "DESTDIR=$(out)" ];
 
   preFixup = ''
     wrapProgram "$out/bin/surf" \

pkgs/applications/misc/viking/default.nix

···
 { fetchurl, stdenv, makeWrapper, pkgconfig, intltool, gettext, gtk, expat, curl
 , gpsd, bc, file, gnome_doc_utils, libexif, libxml2, libxslt, scrollkeeper
-, docbook_xml_dtd_412, gexiv2, sqlite, gpsbabel }:
+, docbook_xml_dtd_412, gexiv2, sqlite, gpsbabel, expect }:
 
 stdenv.mkDerivation rec {
   name = "viking-${version}";
-  version = "1.6.1";
+  version = "1.6.2";
 
   src = fetchurl {
     url = "mirror://sourceforge/viking/viking/viking-${version}.tar.bz2";
-    sha256 = "0ic445f85z1sdx1ifgcijn379m7amr5mcjpg10343972sam4rz1s";
+    sha256 = "09kq0sxs2czps0d6xzgkkp41746v44ip63m72qvfs7rsrnqj7qnz";
   };
 
   buildInputs = [ makeWrapper pkgconfig intltool gettext gtk expat curl gpsd bc file gnome_doc_utils
···
 
   postInstall = ''
     wrapProgram $out/bin/viking \
-      --prefix PATH : "${gpsbabel}/bin"
+      --prefix PATH : "${gpsbabel}/bin" \
+      --prefix PATH : "${expect}/bin"
   '';
 
   meta = with stdenv.lib; {

pkgs/applications/misc/xxkb/default.nix

···
+{ stdenv, fetchurl, libX11, libXt, libXext, libXpm, imake
+, svgSupport ? true, librsvg, glib, gdk_pixbuf, pkgconfig
+}:
+
+assert svgSupport ->
+  librsvg != null && glib != null && gdk_pixbuf != null && pkgconfig != null;
+
+stdenv.mkDerivation rec {
+  name = "xxkb-1.11.1";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/xxkb/${name}-src.tar.gz";
+    sha256 = "0hl1i38z9xnbgfjkaz04vv1n8xbgfg88g5z8fyzyb2hxv2z37anf";
+  };
+
+  buildInputs = [
+    imake
+    libX11 libXt libXext libXpm
+  ] ++ stdenv.lib.optional svgSupport [ librsvg glib gdk_pixbuf pkgconfig ];
+
+  configurePhase = ''
+    xmkmf ${stdenv.lib.optionalString svgSupport "-DWITH_SVG_SUPPORT"}
+  '';
+
+  preBuild = ''
+    makeFlagsArray=( BINDIR=$out/bin PIXMAPDIR=$out/share/xxkb XAPPLOADDIR=$out/etc/X11/app-defaults MANDIR=$out/man )
+  '';
+
+  installTargets = "install install.man";
+
+  meta = {
+    description = "A keyboard layout indicator and switcher";
+    homepage = "http://xxkb.sourceforge.net/";
+    license = stdenv.lib.licenses.artistic2;
+    platforms = stdenv.lib.platforms.linux;
+  };
+}

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

···
 # ruby generate_sources.rb > sources.nix
 
 {
-  version = "43.0.2";
+  version = "43.0.3";
   sources = [
-    { locale = "ach"; arch = "linux-i686"; sha256 = "da9307cb24c75665adc6a5e02d3045eac9babd33c6da778167644d13cc685de2"; }
-    { locale = "ach"; arch = "linux-x86_64"; sha256 = "1a8f13b44107e9689aa339f19c8247142ce82ef9a63bb4be077c212d4d4ad03c"; }
-    { locale = "af"; arch = "linux-i686"; sha256 = "b8dcbf287b350becd7a4e1d812a2251bf10861fe6fe3c85ea9b56e4aafa2a156"; }
-    { locale = "af"; arch = "linux-x86_64"; sha256 = "241a503d4cd2793c538a5cc1ad0990b2a5cd40a584504cf5dde77a28d2f47049"; }
-    { locale = "an"; arch = "linux-i686"; sha256 = "530f5e4743384e543e4cf829f00e5f37adccf64b4af5067aab1e316aba72c579"; }
-    { locale = "an"; arch = "linux-x86_64"; sha256 = "1bbde5a3c897ebed7c7820362257626835c1adfafb29a20e80bcc4b1c40407b4"; }
-    { locale = "ar"; arch = "linux-i686"; sha256 = "f254b2f7117b866e2c8611d5367fc1e2a8e20e1997746204234ae6869c01f6e9"; }
-    { locale = "ar"; arch = "linux-x86_64"; sha256 = "bec6a50c9ce11906edb09591ed1f37d94291fb67b2d4ab9a8f5f87b0e837c0be"; }
-    { locale = "as"; arch = "linux-i686"; sha256 = "b894da79ba753489a3f0509aa54abb9cf67c84e80a73bc00d0e7e7483e1c4ac9"; }
-    { locale = "as"; arch = "linux-x86_64"; sha256 = "ef435b67eac29cf4024ad8df1d4efd413ea58fd76c0e4ec2f2595e7c90743953"; }
-    { locale = "ast"; arch = "linux-i686"; sha256 = "96566e2de543bb4b3bba195b99efb8ec1c01f6ec969dc75293ed66033b52a92b"; }
-    { locale = "ast"; arch = "linux-x86_64"; sha256 = "29f9ccdfc93a72db314df43564fce754ddc678b89a55035f23582bf4a7c66135"; }
-    { locale = "az"; arch = "linux-i686"; sha256 = "cc58914388b53df51d5bd78f0e63286166bbf278e691b8589bc7db18257627c5"; }
-    { locale = "az"; arch = "linux-x86_64"; sha256 = "7f1db3428190e1bbc01506a029df8c81a0ea67b301f161a5bb297c47d5db41d8"; }
-    { locale = "be"; arch = "linux-i686"; sha256 = "c8bd88c4ffb98d8611d760b144f46ab3cef4f7808f2b1008cd5aa75eadaf02eb"; }
-    { locale = "be"; arch = "linux-x86_64"; sha256 = "1b063e4e4a33b9d29f01d7c98a942446d738b195877a617dd454c2697fd6a539"; }
-    { locale = "bg"; arch = "linux-i686"; sha256 = "1186851b6a27a2d23572c9fa0a9bfabcfca1925d36e7fa79e5918541892bcda9"; }
-    { locale = "bg"; arch = "linux-x86_64"; sha256 = "d185c5eb1640d13ee9fd049db41d267af728de56f833bc32a182f69c4921d1c0"; }
-    { locale = "bn-BD"; arch = "linux-i686"; sha256 = "fcc0a0c46e913cb7b4d44c502f62ece83ae8d22703419edafd15321b77758625"; }
-    { locale = "bn-BD"; arch = "linux-x86_64"; sha256 = "d1e066c2347e109fab28e525b5780edb9c5c063322745d971e4ad79a110568f6"; }
-    { locale = "bn-IN"; arch = "linux-i686"; sha256 = "3a85767878b840411c57d176af597666aaeaede9a290032f374629eac536eeca"; }
-    { locale = "bn-IN"; arch = "linux-x86_64"; sha256 = "a3314e2a9f74d9f2c85e592a74e1353b2f048349ba65bf4cfdf35c72b130cd61"; }
-    { locale = "br"; arch = "linux-i686"; sha256 = "a6cd3445e65ca3c818856d6a3b9069aa437ea638f11bb8be520db73604150090"; }
-    { locale = "br"; arch = "linux-x86_64"; sha256 = "9c9f5720b568d768933d7d55bfa7853bb7918bcc651b7c2e281ccf3d2a5e2218"; }
-    { locale = "bs"; arch = "linux-i686"; sha256 = "9c0844cc1dde7712219626148988df642ab10e81494d4794a51a61bb92ddd110"; }
-    { locale = "bs"; arch = "linux-x86_64"; sha256 = "44d91b25d18aa108adf49677069ebd75236f82c7016ee9d518e2ff3f6ad40ffb"; }
-    { locale = "ca"; arch = "linux-i686"; sha256 = "5669828dec411832064e790e65203dabd3703a86090e87a931c6bd495fd39bc7"; }
-    { locale = "ca"; arch = "linux-x86_64"; sha256 = "1e1cec512fb7038327488ce884e171ecda23ae26f98d39159ca96b8acea2029a"; }
-    { locale = "cs"; arch = "linux-i686"; sha256 = "a7bdf99153ae8351c3f4f98db5e65d2a0598457dc0774508fc6ebe26c40ff43e"; }
-    { locale = "cs"; arch = "linux-x86_64"; sha256 = "16fd46498fa33334a5bd1cf06351b410f7df41526c195de21959bf837ce5d488"; }
-    { locale = "cy"; arch = "linux-i686"; sha256 = "8a251c77bbdb6a44163285cacb3a78ffe85835cbe0b9156ad300e733c9ee3934"; }
-    { locale = "cy"; arch = "linux-x86_64"; sha256 = "61f2b6b13d9ce1066b6207b16865a038cb35c51f61a5bc05503cf948704320f7"; }
-    { locale = "da"; arch = "linux-i686"; sha256 = "d1e5d20f7b396bb8b823e7a15a6e220fb930601c2df6e9fc5ca588d3ffce1698"; }
-    { locale = "da"; arch = "linux-x86_64"; sha256 = "a5f20fb678a51a526ebd135b149c6769dda46827174259cabbc4912c6f0619d5"; }
-    { locale = "de"; arch = "linux-i686"; sha256 = "74e9e40b191fd56e99708910c8798d4a8588271a90eef6f7658e042a0765d0e5"; }
-    { locale = "de"; arch = "linux-x86_64"; sha256 = "470781e1debb2085fa538008cd3203c64b534b5a88c6a6ac01418a3ef344216b"; }
-    { locale = "dsb"; arch = "linux-i686"; sha256 = "459e0d6c55ad822bae10a47a7b14004153a3f3363026556568d7108411318104"; }
-    { locale = "dsb"; arch = "linux-x86_64"; sha256 = "97fd138bb33c80a3213b33d4796573b65d4659b888959730cc02e726bcc65388"; }
-    { locale = "el"; arch = "linux-i686"; sha256 = "41b684530ed9bd80c03cb0cd8b1e4de8b3af383f611884965e98215ade1dd8c7"; }
-    { locale = "el"; arch = "linux-x86_64"; sha256 = "b1a7f2a4de87510b9630c6cade94b7f628bbf04289119d3912ea0eb5260b55b2"; }
-    { locale = "en-GB"; arch = "linux-i686"; sha256 = "3c40217b451bd28dd5f1aebcb9a9f7aafdfa3c9c7fd635d69674912a9e73f77c"; }
-    { locale = "en-GB"; arch = "linux-x86_64"; sha256 = "6aa6cd0945bbe97b30e431fdb09a4deb45a0aba6e1283f881a35732b7403e247"; }
-    { locale = "en-US"; arch = "linux-i686"; sha256 = "dd6c585c24e1e9212b65eabee8e52c5dbc9e4acce4fc51c32aacd82b3c6333e3"; }
-    { locale = "en-US"; arch = "linux-x86_64"; sha256 = "9c56ff8734eb860a6038f6bd00d98aeabe57037e230c66d551aac451a27efa79"; }
-    { locale = "en-ZA"; arch = "linux-i686"; sha256 = "0335775eb1a073d1889e8a43f913ea096bbd735a0b98687c75c7fde5eb636f44"; }
-    { locale = "en-ZA"; arch = "linux-x86_64"; sha256 = "5ab68e226bfc141167a477779181c48a84cabe80f250c874182ad0364d0c3dd5"; }
-    { locale = "eo"; arch = "linux-i686"; sha256 = "99a0cf562a067cd30d1047814c1984364b1702e93e638016a4fe8910868cfcdf"; }
-    { locale = "eo"; arch = "linux-x86_64"; sha256 = "ba0bc0093bf2b0ea82eb958fdf06683f4941bd9a44138c793175a0b9e5a86ad4"; }
-    { locale = "es-AR"; arch = "linux-i686"; sha256 = "3adaec2ccb2b1949492c27c466daa5809afc690bf0559418d2d60faae0b5456a"; }
-    { locale = "es-AR"; arch = "linux-x86_64"; sha256 = "67f774442c64d653d624a270eea1202fad389f926c6b7dee56ef965e65311ef0"; }
-    { locale = "es-CL"; arch = "linux-i686"; sha256 = "ee56546d943795434a6759a55dec6e848f244691dc234f4c62746aa1f73cb85d"; }
-    { locale = "es-CL"; arch = "linux-x86_64"; sha256 = "cdbf12f21efb2e18d23ef9c6322c96469c72140200fa47c554067df3a9f89b8d"; }
-    { locale = "es-ES"; arch = "linux-i686"; sha256 = "d3518ffe26d3c21beb009c657b93cf2f01be416f697d89beac497c71044f134a"; }
-    { locale = "es-ES"; arch = "linux-x86_64"; sha256 = "ae34d9f586b28b1063cfebb755edc2a11214085f3a185f31d757c2358493ed13"; }
-    { locale = "es-MX"; arch = "linux-i686"; sha256 = "09a03624363efba7e5d707c312f58e577019b8b7987d817fe1cf77bf2afa7dfc"; }
-    { locale = "es-MX"; arch = "linux-x86_64"; sha256 = "820c50a0991779f664be8013e10a6db2833caa4b1fed370a7d6a8eb71f5766f3"; }
-    { locale = "et"; arch = "linux-i686"; sha256 = "bb2d259606836c5d01d149f2735639cad7411efcd5e0e5deacdc3f1bbae8d80d"; }
-    { locale = "et"; arch = "linux-x86_64"; sha256 = "17265f828cb3232cca73b3bf5b806cf361769c77bfef0e6571a16eb73036cccb"; }
-    { locale = "eu"; arch = "linux-i686"; sha256 = "0bedcadc3b60ecb58af25d5950fe693063eb80f65d6d85e72ff0cdab3e7f2030"; }
-    { locale = "eu"; arch = "linux-x86_64"; sha256 = "371d5648c7ffaf325ef34030ad0a9971246bc1df354fc11dd66bc461dce303fc"; }
-    { locale = "fa"; arch = "linux-i686"; sha256 = "a7c55492f08e5f44d5cccb015d00abf8b8e74dec7da37e937f8d0f76a4c49338"; }
-    { locale = "fa"; arch = "linux-x86_64"; sha256 = "6fe831c56d96dbed1c4a6859ba58dc20bbdf43efbc2bb225a707df7966f8b9dc"; }
-    { locale = "ff"; arch = "linux-i686"; sha256 = "5cf4f3235db02c385ffc355e0fa1060b79afd5a8899ff31da1d0dad4d065e4cf"; }
-    { locale = "ff"; arch = "linux-x86_64"; sha256 = "0576772ddcbdbe3d26ae20dd47b4e635de709c34eb6a797afab7743ac68815bf"; }
-    { locale = "fi"; arch = "linux-i686"; sha256 = "8edd2e8058fc848456b2dc1bb54f669159b232b5423dcde6638e5d61294f1ffe"; }
-    { locale = "fi"; arch = "linux-x86_64"; sha256 = "94bd189308502abea3d6d762378220097d3d743cc42872e6c43cdcd86aa51b4f"; }
-    { locale = "fr"; arch = "linux-i686"; sha256 = "652f87501ba2a5baf1de865d7a607837a9ed623834c2d796baf4e3891fc78a6b"; }
-    { locale = "fr"; arch = "linux-x86_64"; sha256 = "94c3725ea6fc2a7833e9ee60fdcd0ae3a53c80ce7f13ca00634b5d99b12a4607"; }
-    { locale = "fy-NL"; arch = "linux-i686"; sha256 = "8d9ed839afa148da954acfdca139dbcf9f235c097fc7c562a8ab52f9ece68b4b"; }
-    { locale = "fy-NL"; arch = "linux-x86_64"; sha256 = "650c8a50b8473fd09dbcd1c818ca8c3ab0c6618696198124f32e0153307e2aa3"; }
-    { locale = "ga-IE"; arch = "linux-i686"; sha256 = "a70af727b36bc7d084211a880318f3a9f73977ff75f728b50cc4bfa9398c61d2"; }
-    { locale = "ga-IE"; arch = "linux-x86_64"; sha256 = "01d3635c38068facc135fcca979517d729999db52f4a00c0b2ee27cf830df870"; }
-    { locale = "gd"; arch = "linux-i686"; sha256 = "9763cbe0387cb86f91cdd6b1dfa6e257cc40c4525c753869ee091bfe49f172e8"; }
-    { locale = "gd"; arch = "linux-x86_64"; sha256 = "16d3452fdbabada41626d981dee0e48282d672d9d6073b363ede9e86c4ed56ce"; }
-    { locale = "gl"; arch = "linux-i686"; sha256 = "facde8f17e2f90e49a02b36d016535e1123c7f78ac44ee1110c80dc472e84133"; }
-    { locale = "gl"; arch = "linux-x86_64"; sha256 = "b0955c4381f7f0013e9e0b1dcf8d8c53a3bf694af6970638b2e88dc080771ed7"; }
-    { locale = "gu-IN"; arch = "linux-i686"; sha256 = "cb42e0750736bd14c81bbb76bb05e02c97e798b01d9f41bad091295f9bbb5655"; }
-    { locale = "gu-IN"; arch = "linux-x86_64"; sha256 = "c497650eda2e4fc0f99b9d9c1ef0df33b0ea7b6e32d2eb7d4ee109e5ae1f2add"; }
-    { locale = "he"; arch = "linux-i686"; sha256 = "d4cc561b6ce55f0820e6bd8479de9fd1ed53fd228e7cef28a890aebd687c26aa"; }
-    { locale = "he"; arch = "linux-x86_64"; sha256 = "9294083a0ce8b06cc565c9d643d3e45d50393a5abff230dde8fe42aa29d8b870"; }
-    { locale = "hi-IN"; arch = "linux-i686"; sha256 = "3493dda678fe94e13d34a62d194b612037f472546b96a94de2390706139636ef"; }
-    { locale = "hi-IN"; arch = "linux-x86_64"; sha256 = "db45625e758d3db82705373004cc16176f8376bf087ac11da06c7c22e613dc2a"; }
-    { locale = "hr"; arch = "linux-i686"; sha256 = "227399d033c4a7877387ac965d84ac265600bc16614de1b99618f39808b92894"; }
-    { locale = "hr"; arch = "linux-x86_64"; sha256 = "a4f061ed24c66f936da13f8d93eb311f8fda7cc468d7cc9f71a4c747bbd9af19"; }
-    { locale = "hsb"; arch = "linux-i686"; sha256 = "41bc010d4cca63bc77b8d637e6ca2731e3c5900b6783955335aae0ee3d2eedae"; }
-    { locale = "hsb"; arch = "linux-x86_64"; sha256 = "4618d03269cad3fe8ca3d618de581d37fef37b9276e72613d2c12b212bb2c894"; }
-    { locale = "hu"; arch = "linux-i686"; sha256 = "be456ef5df061985f7413fc7af45b4f0b86ac4a99a57d3574d8ad6dba727a8fe"; }
-    { locale = "hu"; arch = "linux-x86_64"; sha256 = "c229ca2c9fba2ac98e912e5c5f4500d423b1f2cbf768e539112e97c0f0fe410b"; }
-    { locale = "hy-AM"; arch = "linux-i686"; sha256 = "0a569d1b8c8d685c3eb5701471420aa47110c737504a105f660dca72a82490af"; }
-    { locale = "hy-AM"; arch = "linux-x86_64"; sha256 = "b15c86feb6d69005244f409290489d8f5ffaff0c85ec876ba931be38c7de07b0"; }
-    { locale = "id"; arch = "linux-i686"; sha256 = "dc8ca98414ccc67087c896c84a0a223026f12ed9fec499eba6203b8ec0b3e6e7"; }
-    { locale = "id"; arch = "linux-x86_64"; sha256 = "6a831ab4c2605fdbac15ac81853a19f5c8633756ad5136f93c3eb76637e2b997"; }
-    { locale = "is"; arch = "linux-i686"; sha256 = "02e9a2022c0da27e069689d25ba80c1d04dc29e6a045833fa1c5e503b5ca9f9a"; }
-    { locale = "is"; arch = "linux-x86_64"; sha256 = "0ffd2b8f1fdafd91ae4e089c075446f57adcc748bea4994d40207e5cba9a5655"; }
-    { locale = "it"; arch = "linux-i686"; sha256 = "f84d5304a37e33883322c9c508f4d342f99901c9339d293308ef78bb561a3c40"; }
-    { locale = "it"; arch = "linux-x86_64"; sha256 = "78c5cb912d6c24d5a7636fd400470d298e4f58493ca6fd3e5f6b88e4b8037e77"; }
-    { locale = "ja"; arch = "linux-i686"; sha256 = "a3d563846ef60176712574a9f66d24a785f749390afde21cbc4823e9d30cc3ba"; }
-    { locale = "ja"; arch = "linux-x86_64"; sha256 = "56bdf673d645dff09e96970fc4cb33b1810d57051e7c12f6fe1ba01fa971e293"; }
-    { locale = "kk"; arch = "linux-i686"; sha256 = "a5b10502bacf265e2157b7246457c33adcf037e4e28291e26a7fdd9f53f94638"; }
-    { locale = "kk"; arch = "linux-x86_64"; sha256 = "2a7c74168d040653cbc31d6d03846b9165f617cebb74388818d73d681056561d"; }
-    { locale = "km"; arch = "linux-i686"; sha256 = "26e696f0a03d7d6c3541563f89ba08d06a47039ca93f15d2f1909db7ca1b8d08"; }
-    { locale = "km"; arch = "linux-x86_64"; sha256 = "18676450680d18631a855dcf91fd4592f8e3e908b04122476ae62d619bfbdd4f"; }
-    { locale = "kn"; arch = "linux-i686"; sha256 = "cf6c95c0f06381f3aa4eb03c8854a530e63b0b5c6d971dc019a5c6cf81f80b0b"; }
-    { locale = "kn"; arch = "linux-x86_64"; sha256 = "fabd1b824a4593454f8c9d7c6c47f7244ec9d1800cbe397042fb3bc41a75d09b"; }
-    { locale = "ko"; arch = "linux-i686"; sha256 = "d3d9ff36de18ca424511df1ddbd4c49c84499491510a064a6f55f15599e1c172"; }
-    { locale = "ko"; arch = "linux-x86_64"; sha256 = "e8eef3e4c6201e1d1e936ee6ec53f875b6c2a0496d308b8fbe03b5cbdf229bec"; }
-    { locale = "lij"; arch = "linux-i686"; sha256 = "de6b35a675539d1bf0ff1c8f3837ba030da64b0e51c30e594515ac13578495f5"; }
-    { locale = "lij"; arch = "linux-x86_64"; sha256 = "9d2351a7bed09127b618cfd86f2d394fdefcbbf2801da3a60a697982b5bbb9f1"; }
-    { locale = "lt"; arch = "linux-i686"; sha256 = "5e5c3d5083b8d71a249f9e5009072132c9524063fa0cdb1f47ad0ff5260725c7"; }
-    { locale = "lt"; arch = "linux-x86_64"; sha256 = "c57df2ce20d09070514f783a12e179ff05a4ac14e7ec67b0081f284f70079468"; }
-    { locale = "lv"; arch = "linux-i686"; sha256 = "30267f85939965eab0ec50f4c869a0a42fa0d0775ae516088f9a3ff57f1bf3d2"; }
-    { locale = "lv"; arch = "linux-x86_64"; sha256 = "c1389231d627df347910d28172a823da18f2ebd5697093035faa499da24755eb"; }
-    { locale = "mai"; arch = "linux-i686"; sha256 = "6dec829e1ea28f8c4480d0517f72909d2d652fd827693dc919298906b62b47d2"; }
-    { locale = "mai"; arch = "linux-x86_64"; sha256 = "29ed57ad173243d7cc2460a534c3f63709e235db74810a0d6f12dc460c5f4a52"; }
-    { locale = "mk"; arch = "linux-i686"; sha256 = "98d4c529ca979e4ba03b3c1640feb0c93ca1ac2a92ac07403a39a07adce8df44"; }
-    { locale = "mk"; arch = "linux-x86_64"; sha256 = "53d6752d67e3277afe3ea239ceb1f890edc5a15fe078d41bc074246598376603"; }
-    { locale = "ml"; arch = "linux-i686"; sha256 = "321d682e8e1e42e8e4522d791e7e7ae13d1622d740038f3586813099f0275d96"; }
-    { locale = "ml"; arch = "linux-x86_64"; sha256 = "f0dfba4cd8fd961ef6c088ef9139b8ce5e33fcefa8cda142c9f51bfae663c092"; }
-    { locale = "mr"; arch = "linux-i686"; sha256 = "b40b8fbbe5ab56055d57f7b9a67ff00e84b7c7d19afc7bb07b4311ef3fb6c66b"; }
-    { locale = "mr"; arch = "linux-x86_64"; sha256 = "3bb64e13d59a1c65460282e4236655a0c2997d894e9b897a8dc3b20a4baca3c9"; }
-    { locale = "ms"; arch = "linux-i686"; sha256 = "15aeda467f0c0c893dd923ee56fcf2547242f0a4089709ce0cbdb27778c71b1b"; }
-    { locale = "ms"; arch = "linux-x86_64"; sha256 = "32cea21ff68efd7c384746c32c0138464fbae4d25065fe58d6d56e191ee5b082"; }
-    { locale = "nb-NO"; arch = "linux-i686"; sha256 = "371af3de1ae68ba242cc55cb7c080008ca305c61d5c8c4e687f53568bcb8f416"; }
-    { locale = "nb-NO"; arch = "linux-x86_64"; sha256 = "54e17787e0d31893dcba314e98cfb795fd6f85e335a0e84ce35a0f44a56b6e1d"; }
-    { locale = "nl"; arch = "linux-i686"; sha256 = "92df7a99107ccd938800161e759beb6269a6a30f69c892064e130280a3caa692"; }
-    { locale = "nl"; arch = "linux-x86_64"; sha256 = "41c1bfc828917d58cf8f334b8d2b333ddb50dd416faaae41a0c063bd8c23942c"; }
-    { locale = "nn-NO"; arch = "linux-i686"; sha256 = "ad96e3c670c244d366ce0d600d87a308d95e51309ab86becf1c8c69245dbed0f"; }
-    { locale = "nn-NO"; arch = "linux-x86_64"; sha256 = "eee10d92a2bcc32507936c3c2c5c2c220a4de955aa8b48d23f0d923c9b0faa48"; }
-    { locale = "or"; arch = "linux-i686"; sha256 = "1ddaa000c9b3d5a7dccdddaeb8fda53ba821935bf24ee5c2ca0053e3b2900bd7"; }
-    { locale = "or"; arch = "linux-x86_64"; sha256 = "0d62ab80bdd5853d8dfae01d9420929d9321d1f6b9f40d372c6241f1345de76a"; }
-    { locale = "pa-IN"; arch = "linux-i686"; sha256 = "accdde423ac5c518d14b435d00e1f536cd240f31108b58f0b5e1a925637faab4"; }
-    { locale = "pa-IN"; arch = "linux-x86_64"; sha256 = "89ae2f460c6fdab846d6b41dba84f63c94a7bfc1f61e3e79da5d643d4c1a1fca"; }
-    { locale = "pl"; arch = "linux-i686"; sha256 = "d8e043d8ba0c223f0232facef10b6d2e2ee13733bf8670a9101796bfddb3c2f1"; }
-    { locale = "pl"; arch = "linux-x86_64"; sha256 = "f6ada91433d48b699c02fddf22e2d8aa36e6b0cc365b73625bf6fb80ed3fb877"; }
-    { locale = "pt-BR"; arch = "linux-i686"; sha256 = "b2d294d7761cfc3c8a58ee072bb8a0b82cc79724f6b103073632e682fda32f60"; }
-    { locale = "pt-BR"; arch = "linux-x86_64"; sha256 = "642c56b5d510f5efc8a365be956789d7760bfe983aa397ae194eef5bd15f601b"; }
-    { locale = "pt-PT"; arch = "linux-i686"; sha256 = "6bc224414c39047c42040ebaaa7e7d61bb09939a9878ec4a2d7d7e8c31a7ecfc"; }
-    { locale = "pt-PT"; arch = "linux-x86_64"; sha256 = "cc00a2fb38fed6ffef5a6a6931b043c65948c18f3d502a0e3ae641a1847203b7"; }
-    { locale = "rm"; arch = "linux-i686"; sha256 = "2cebf2678e1a469447205a7495f17185259d73a72439f8fd400eee957e571bbc"; }
-    { locale = "rm"; arch = "linux-x86_64"; sha256 = "32fe2ef01b0d495476768eff7e4750c2c82196e60f50c2e824adbf611f275289"; }
-    { locale = "ro"; arch = "linux-i686"; sha256 = "289cef6b438a59bac459c203a6b1b2965b089f1487ea78ff524a6a68f5996862"; }
-    { locale = "ro"; arch = "linux-x86_64"; sha256 = "7df67b1a5a12297a214d1f794c84b58ca12a182ee780e2574116214dfc785388"; }
-    { locale = "ru"; arch = "linux-i686"; sha256 = "65fd6a9a90b4e5c8fc784850dd5bce41901b0d241dae9c37110bf99643d52d32"; }
-    { locale = "ru"; arch = "linux-x86_64"; sha256 = "585683dca4c427ecbcc17d42465b6e374a76d5266b908df1b47f4a1ad81e7794"; }
-    { locale = "si"; arch = "linux-i686"; sha256 = "6567d5ab15a1bd20426569a6480d6e44f2c1917145fa607357f0d3d0502c840a"; }
-    { locale = "si"; arch = "linux-x86_64"; sha256 = "f0aad93013b6070516851a13352d1aabd0d10bd7891eaea878d3632c1b295296"; }
-    { locale = "sk"; arch = "linux-i686"; sha256 = "c6da9d539302dca6ad8e3165ca595eb80438fb4caea11979c0e07ca215696929"; }
-    { locale = "sk"; arch = "linux-x86_64"; sha256 = "236dd9171f471849e8cddb2b8ff0166e41bdedcb0bb3c1662fdffa83c3e89374"; }
-    { locale = "sl"; arch = "linux-i686"; sha256 = "4b9160bfa7579fc893a40387f0185cb74d7db2cfb0eabd2aa032259ed53b7a97"; }
-    { locale = "sl"; arch = "linux-x86_64"; sha256 = "56bc853e4e5e21d08b2ccd04687388473c45ac4403d0b51ed41d8a6a3a26e396"; }
-    { locale = "son"; arch = "linux-i686"; sha256 = "b73fcee703ce937ec25993da5e09163541fef9eaa4e65ec7d5358f1dfa1b596f"; }
-    { locale = "son"; arch = "linux-x86_64"; sha256 = "95ef838ac58e82ec435ddf7e2ea0bbf8b8d1bdb34832aa664d1ad8f5abbd9a13"; }
-    { locale = "sq"; arch = "linux-i686"; sha256 = "370313d2cf543ab3aeaa5de11f748d69a168a82d6e29c27d4c398bb577fdb06d"; }
-    { locale = "sq"; arch = "linux-x86_64"; sha256 = "a86a6604169ab6d9bc2657a0d26db0a3f96b2927223c5a43128dcf49bad243f1"; }
-    { locale = "sr"; arch = "linux-i686"; sha256 = "a7ad2ec678944f37cfee69025871369b658013f77df9df0f1bbfd9cbc03666d2"; }
-    { locale = "sr"; arch = "linux-x86_64"; sha256 = "b081bc35064722b4de95f4e29c4ee203bca124ebe0c33bbf91f0e11f904928f7"; }
-    { locale = "sv-SE"; arch = "linux-i686"; sha256 = "5a6fe1f1c7e1d5bd91a0c82e47ce5b88e31611cf51d6452afde3ef06d2d1a695"; }
-    { locale = "sv-SE"; arch = "linux-x86_64"; sha256 = "9a09a020acabfaef4fa25d94723fa437c57761f0dbd9bda880b8ca3acb5248df"; }
-    { locale = "ta"; arch = "linux-i686"; sha256 = "0e0839d5a899576f3fd796079748dba8612526bd5f855e8718eccb3ed05944c0"; }
-    { locale = "ta"; arch = "linux-x86_64"; sha256 = "cdcd8e06216289df7cdb4f82f01207a7112fa4f52040bd70c2f497b3d701730a"; }
-    { locale = "te"; arch = "linux-i686"; sha256 = "e4609f803edb243ba8c8fbfb7ecea2e652a9e94adeec2f6c03af42c2e8bc5b74"; }
-    { locale = "te"; arch = "linux-x86_64"; sha256 = "b9151a27be6a8de94fa25b53dfb85e765cc2ff823c2de6a0d0583883fc30ea48"; }
-    { locale = "th"; arch = "linux-i686"; sha256 = "48349866a10948cc0b4f8b6bc2fecd5dcbd4d09ff4ba569f7fb3e569edadd976"; }
-    { locale = "th"; arch = "linux-x86_64"; sha256 = "ef38e6a99cc8cb9e32e95af0ae7f7c99b82310e28b082b6aa085aa80f180ef60"; }
-    { locale = "tr"; arch = "linux-i686"; sha256 = "fbad5fa2196dddb5061fec1f47fa7af85c0a824f520588b7446d2740928e34cd"; }
-    { locale = "tr"; arch = "linux-x86_64"; sha256 = "c644f251f1e43acc3baa550b540750fb7d11c2f440c7906e1955d34694a0d718"; }
-    { locale = "uk"; arch = "linux-i686"; sha256 = "9db7dc494734011ed61c5286fcb1f4b4dfb418528792ef92fbfc3734a9618129"; }
-    { locale = "uk"; arch = "linux-x86_64"; sha256 = "06cbcceb189bad7174cf46678535cd4bfb1062e5ac878fd313fc341315001106"; }
-    { locale = "uz"; arch = "linux-i686"; sha256 = "cfa94474277edc7739c11795b2907b894c87f5c573c43aaf5a951a2f13a9c8ef"; }
-    { locale = "uz"; arch = "linux-x86_64"; sha256 = "e3a581e965fbb3711e6ca6d6d5b378eded8e8ea9767f94993c50632b6f4a7aed"; }
-    { locale = "vi"; arch = "linux-i686"; sha256 = "ecd4a5b8fa66e78cdb93b04eb2b3a5ac354bd5e231d8f4bcbf2acfb94b5190b5"; }
-    { locale = "vi"; arch = "linux-x86_64"; sha256 = "1d52852d973d5d6bea8ef860b216aff4eea59dff576f13ae67aa9b96ef0c9878"; }
-    { locale = "xh"; arch = "linux-i686"; sha256 = "24befe5e2fe2001ab3827543f97b52ecd15f5cbad89d977584aa4dc08a0e9c11"; }
-    { locale = "xh"; arch = "linux-x86_64"; sha256 = "4cafc2a6028d8141e47b09a9d8d96404cb4b5806cfaab452566f9a7baff89f25"; }
-    { locale = "zh-CN"; arch = "linux-i686"; sha256 = "80ec43ed8918fa452271988d53875f184196460b15086fe793af4842458ab790"; }
-    { locale = "zh-CN"; arch = "linux-x86_64"; sha256 = "1d3fc933a5b3f4082fac9176f6a802e01f8a26d711c339116799e58629843f27"; }
-    { locale = "zh-TW"; arch = "linux-i686"; sha256 = "a255ce81f6ac1774ae6c8a5b9208169864a672f22f7037c93f01758c4eaa357b"; }
-    { locale = "zh-TW"; arch = "linux-x86_64"; sha256 = "27b048c3df2ff25fd6f7c33cc30016e8a657a2f30ef7b0da9a2f4097c1b5e494"; }
+    { locale = "ach"; arch = "linux-i686"; sha256 = "1274cb4148d115ab4d8bc5b5c6826e80863e2bf0f76f0165521beb5da2fb5d22"; }
+    { locale = "ach"; arch = "linux-x86_64"; sha256 = "2184a0a1b3bcb833369959cb1fb641ac9501dad40828d7260022dc3492f4444b"; }
+    { locale = "af"; arch = "linux-i686"; sha256 = "807efe3a2277494f04e957b60f033c31d58145b5dd1e13fac3c027e811849932"; }
+    { locale = "af"; arch = "linux-x86_64"; sha256 = "53f654dca168125a1c55842125c3480f41d3f66b5ea2b0978912f5602d7a317b"; }
+    { locale = "an"; arch = "linux-i686"; sha256 = "ad97be84a2c59570919939ad72542d140a7c46c45ae2747c24f5cbebbf201222"; }
+    { locale = "an"; arch = "linux-x86_64"; sha256 = "1608d249fb454be2d241f512d74662d0089f85a1d7ff8888d43aa3efcd6c2f73"; }
+    { locale = "ar"; arch = "linux-i686"; sha256 = "d464251e1734271cf5854d2b9dcc7bb391205f78f6f80263b5648e0e03e841b8"; }
+    { locale = "ar"; arch = "linux-x86_64"; sha256 = "0cfb84665d40bc40f3a2bf77f58fd499ec9a33aec3c82aa384edda9fb64756eb"; }
+    { locale = "as"; arch = "linux-i686"; sha256 = "d20fe776c5a036016a89754e30a773082ec018112d7f8848b532f56aa3f91bd6"; }
+    { locale = "as"; arch = "linux-x86_64"; sha256 = "4eec5f44fa188e84376cb87249410decd7662271782f347d7f9cda40a52b40ad"; }
+    { locale = "ast"; arch = "linux-i686"; sha256 = "2c75f6b6cc9202d090eb349f9fc4f5995724d6c5675149dfdfb0476475e964d6"; }
+    { locale = "ast"; arch = "linux-x86_64"; sha256 = "39b23638d5e2aea613ec0f32b7ad71b7084dd333146413c82d5f91c42d7bc099"; }
+    { locale = "az"; arch = "linux-i686"; sha256 = "b07d6481777a4b9bf1f06a00c820e4cad6e7ae414099afb1619bb1ae71fc8b5d"; }
+    { locale = "az"; arch = "linux-x86_64"; sha256 = "da5852870bda9c27ec1a16893d990180e08031565c54390828c0ae2d38cedc89"; }
+    { locale = "be"; arch = "linux-i686"; sha256 = "a04ee5c4521e46675919aa9cac9a56277cd741195248ffcf260eaf875e992afb"; }
+    { locale = "be"; arch = "linux-x86_64"; sha256 = "41d8a66b2f39575c7fd5164464c0c8430255e86a2c56eaaef1283107fe92832d"; }
+    { locale = "bg"; arch = "linux-i686"; sha256 = "edf94d80e1a9641569123f6a711699f840919398e5e7230fa4fde9d35b0ad09c"; }
+    { locale = "bg"; arch = "linux-x86_64"; sha256 = "8e1fc0d661c3b54ecc2848fb9309040c4250e0eb9be206e515474dc0cf893ed4"; }
+    { locale = "bn-BD"; arch = "linux-i686"; sha256 = "76237b91fd2efe99f07c11d6a0080e85dd7ea6c0414e917a74da6d1361297439"; }
+    { locale = "bn-BD"; arch = "linux-x86_64"; sha256 = "c6cc9b00423124879b4900918ff791531c7b3b3f11866ad16fb27630aba6a1a8"; }
+    { locale = "bn-IN"; arch = "linux-i686"; sha256 = "ea378725ca575e30f42dabff703acfc7246498fd765dcd3fc2922f0fbb0cda31"; }
+    { locale = "bn-IN"; arch = "linux-x86_64"; sha256 = "fbf01a2b84d8aa35a388baaf56b2034207a12f4a2a9b79faaccf772f8a23d705"; }
+    { locale = "br"; arch = "linux-i686"; sha256 = "adbbcfd6cff2e0dc5fbcaa91dd6b2dfc13d04a80be35ea365907d8aa2f17256a"; }
+    { locale = "br"; arch = "linux-x86_64"; sha256 = "7b557210b559f920dd3b9e69371d98f08ce2fe0d929e04a1b88fd56fcc793122"; }
+    { locale = "bs"; arch = "linux-i686"; sha256 = "32508d4c75f5e23e1082513ebc4a20f5f6d98277c5121abde475eaf48a762b81"; }
+    { locale = "bs"; arch = "linux-x86_64"; sha256 = "a2c6354582d8dd42b8e180a705c158d4b85ba3ff68d97863129dc71b05a83612"; }
+    { locale = "ca"; arch = "linux-i686"; sha256 = "e8155974306fd84d7fc3330ed7a8da5b234f1790dc6792c9e59648c93660866a"; }
+    { locale = "ca"; arch = "linux-x86_64"; sha256 = "46cd90407fe839356b63eecdee839dbde68651ebb631419273b6c4d7d31d84ce"; }
+    { locale = "cs"; arch = "linux-i686"; sha256 = "50cdc07a438ef44ff6a7585583c38c604a71081770f38add190079300afe3b54"; }
+    { locale = "cs"; arch = "linux-x86_64"; sha256 = "1e4bf0b42a263a99b16bf083d0152e667fdd534c0a2cdcd6557f6b85506aa0e4"; }
+    { locale = "cy"; arch = "linux-i686"; sha256 = "95c184685fa32bfa8999a953b1b1001d5d8a73ae82bd2b70d70e6feb990f5b77"; }
+    { locale = "cy"; arch = "linux-x86_64"; sha256 = "7117b1067f753c7d692b73c6aab610fa0eabf423e24444f7ac8893339264414f"; }
+    { locale = "da"; arch = "linux-i686"; sha256 = "46d179f893df3e7af77da5f3355d2418b0fcffd3060d0c9aebc62087075177b8"; }
+    { locale = "da"; arch = "linux-x86_64"; sha256 = "0514a6f88470681b93a9d8202f48159d031387e5e42d14923cfa1cea2113d753"; }
+    { locale = "de"; arch = "linux-i686"; sha256 = "4d30e8a59ba3ac04e387df7df6be1edf88b08ca37463fd9ccf301def3542cc35"; }
+    { locale = "de"; arch = "linux-x86_64"; sha256 = "ae6f94e6a782103efd18515a6596a5ee06943b2d1321f03127d54ae7ed147131"; }
+    { locale = "dsb"; arch = "linux-i686"; sha256 = "62880a87963abf9e36e820644a8165f980f7b48634b1a1f825f5aee0d2e19e74"; }
+    { locale = "dsb"; arch = "linux-x86_64"; sha256 = "ff2a596f46b02bea98fa36defa0afd96c064912a79ea8b4f98aae46901624f22"; }
+    { locale = "el"; arch = "linux-i686"; sha256 = "5fb00e56adfd520d114208ba72b9a3fb5306903e0b2b3669bb109549b0b4ef6e"; }
+    { locale = "el"; arch = "linux-x86_64"; sha256 = "df3fd6d2206918c324182ada0a3bce912726a48383537be69a695e678a0cbeb5"; }
+    { locale = "en-GB"; arch = "linux-i686"; sha256 = "d3e21c467cf25b5629cb9bfa5c18daba024e3665e5c69830f472dfc93b062e04"; }
+    { locale = "en-GB"; arch = "linux-x86_64"; sha256 = "210d41c4e9861713dba228d34781b05850b9839606a975580b0dedca556e8e53"; }
+    { locale = "en-US"; arch = "linux-i686"; sha256 = "78b95a47e73d2ef7d436f59fb1e7f300c6075bae4ab41d3557b6b17520416d57"; }
+    { locale = "en-US"; arch = "linux-x86_64"; sha256 = "6f27b0499ee599b6dae1e7ef5a79e935fb186b6fdfb2f09274cdf40bcbf2006f"; }
+    { locale = "en-ZA"; arch = "linux-i686"; sha256 = "f16af1ead4c5ba73ec2b137764cac5e610574f107763c20667f9d565f10b4ca6"; }
+    { locale = "en-ZA"; arch = "linux-x86_64"; sha256 = "de561c70c19a8e921fe8035af4513a0b1c3fc184739f42e4d6e76051278a0e75"; }
+    { locale = "eo"; arch = "linux-i686"; sha256 = "78670d675bff447c654717763157e4726e0fe3612568e993c2eb7cfd9b893ef7"; }
+    { locale = "eo"; arch = "linux-x86_64"; sha256 = "fa8d9ddc8113a33c2c9776cee0eeeccf46b00aa2f099e9ebda3aef370104212c"; }
+    { locale = "es-AR"; arch = "linux-i686"; sha256 = "77366f398047143357cf250903cc0ccc99c58bbf882e8de7f106237632a5c944"; }
+    { locale = "es-AR"; arch = "linux-x86_64"; sha256 = "453245f940832fd4f3e3d3509d83e0e6d900d0154623b779a830d3d990652027"; }
+    { locale = "es-CL"; arch = "linux-i686"; sha256 = "ff985d60ce0ae316c7b9452bd3f385d80a1ab5e1671119a859450e2a930edd65"; }
+    { locale = "es-CL"; arch = "linux-x86_64"; sha256 = "992ae0721558d042041d46da1f8ed3763a2c9dbd2c54063e3ce074ef7a49329a"; }
+    { locale = "es-ES"; arch = "linux-i686"; sha256 = "2195599d5d196903b21a27e3447524a31fc69845af2a02cd7e4e5ebc8d1695b2"; }
+    { locale = "es-ES"; arch = "linux-x86_64"; sha256 = "9e7cafa1a4b9712c58812acaadd49f41c027dd41af569df326b9668d64fedfc3"; }
+    { locale = "es-MX"; arch = "linux-i686"; sha256 = "63ed5abc352b5eb16e0f91c7da69cb9121363607c312674c6d9c9d2c45211bda"; }
+    { locale = "es-MX"; arch = "linux-x86_64"; sha256 = "063c73c0285ec2761e7483d21f6e43769fc9cb7aeb7a93803e63fffb7c4245c4"; }
+    { locale = "et"; arch = "linux-i686"; sha256 = "b331149411d855616857bd4eca5911f570deb601b203ce21ddf11b854de363e5"; }
+    { locale = "et"; arch = "linux-x86_64"; sha256 = "a482ce4d21251a5757dafaf86d5afc708989db0a367357a34c3b5fba0a05f8ef"; }
+    { locale = "eu"; arch = "linux-i686"; sha256 = "3ec3222f06b468a3d94b68c2dccbc21d9b63de765be90fdcb594be4146885786"; }
+    { locale = "eu"; arch = "linux-x86_64"; sha256 = "411490db2e9acd6cc6170b8a6c90d7e2a9beb83f4437d087e755b0845aac8c4a"; }
+    { locale = "fa"; arch = "linux-i686"; sha256 = "b7804d3f0c8c43ef256b44b0bd9e32caa2aab5c7a7ef3b072cd14adfc5b24e0e"; }
+    { locale = "fa"; arch = "linux-x86_64"; sha256 = "91601b52dc9557e17eb80db60a0c9a023ea9ef5d06f8355b077b9e7ffd3800b3"; }
+    { locale = "ff"; arch = "linux-i686"; sha256 = "2143e1d2629b4b1aa6f35f4dfbfaaece09711b65a9da80d6a7303d70362ca8a2"; }
+    { locale = "ff"; arch = "linux-x86_64"; sha256 = "20fd859ea943e3d0a3bfd0427b07117233ac6c980aedf1c4461dc71f2f132ee4"; }
+    { locale = "fi"; arch = "linux-i686"; sha256 = "6bea2d99cd49e3ddadecec22d4832abfd037b7e4a7036b2638f8dd61ba33e227"; }
+    { locale = "fi"; arch = "linux-x86_64"; sha256 = "0eb961fd7512d0223dac43c4895a69404c1d533224d880e619ec91809ae476cc"; }
+    { locale = "fr"; arch = "linux-i686"; sha256 = "86f07727d64fa4122291d9de053b8654d190833f89d3b4d382786c697ee47bf0"; }
+    { locale = "fr"; arch = "linux-x86_64"; sha256 = "63b23116db3c464d6a7bd3e72f9fe82aa236c4e542994621194736fa76c16451"; }
+    { locale = "fy-NL"; arch = "linux-i686"; sha256 = "de6ba7ee545d59c4d60380bc21a68e00cf88f6ce598d326cc04c57b104267610"; }
+    { locale = "fy-NL"; arch = "linux-x86_64"; sha256 = "48a1e32a6f110119d729584cd0c5002bdbff2d67e3ed58e777e6eaf443449295"; }
+    { locale = "ga-IE"; arch = "linux-i686"; sha256 = "42d784a229b674016e51ddd71d634fc20a39c6f6c3c9b98f8f52c1be2146a447"; }
+    { locale = "ga-IE"; arch = "linux-x86_64"; sha256 = "7b8c257448701a7f252da43a6fd466bb80326405d81683525feefb1d1947856c"; }
+    { locale = "gd"; arch = "linux-i686"; sha256 = "f192ee509e71d58dc8cdca8cfdae4d103bb9542b6c9a807f2b8e9e1b81f0309b"; }
+    { locale = "gd"; arch = "linux-x86_64"; sha256 = "03135f6eb67046aee154040c1d089504ff307bc3fcbacc55c6266827e3675d6e"; }
+    { locale = "gl"; arch = "linux-i686"; sha256 = "73fb03a71ccf7d6bd1dcb0fa28c21745f3944c28e51e700b190f1b872b38c2a0"; }
+    { locale = "gl"; arch = "linux-x86_64"; sha256 = "33832cee5dabd5e9114b9848cebe505b59bbf9a0151f6ac9f3229edcf9462e6e"; }
+    { locale = "gu-IN"; arch = "linux-i686"; sha256 = "8f2a45c81547a2b89194bdbc9e52f22d7d1b3bd356960433c970d59b2ce3b4d4"; }
+    { locale = "gu-IN"; arch = "linux-x86_64"; sha256 = "4be14ca66c881c81f525d997cadc291632159722b5b9baabb430c9dfba6218e5"; }
+    { locale = "he"; arch = "linux-i686"; sha256 = "452a9742ac4fc7ed3daa436bebe16a7d9530fe9c1587591e2a2a5247adcd4ce4"; }
+    { locale = "he"; arch = "linux-x86_64"; sha256 = "57a347dccb36b7f53af06e850ea8170364fe4c50b2164fa6b51231eb834f777a"; }
+    { locale = "hi-IN"; arch = "linux-i686"; sha256 = "8a4b1d09f715742fd9465d2fdd525d271b94ed1d0face088b8d1ae10b5ee00c6"; }
+    { locale = "hi-IN"; arch = "linux-x86_64"; sha256 = "7a5f1dee1cd04118c366c315ed5d7228829e097e39405dd7115d85d0c4791517"; }
+    { locale = "hr"; arch = "linux-i686"; sha256 = "05e80b6d007cd3cdfe2f993c5194ce84b9d111b500378f8da675b7c478a6ab51"; }
+    { locale = "hr"; arch = "linux-x86_64"; sha256 = "570b5eb8072f39af37fa0f9bf3eb51ef538862c6488295ec8d193d84b8ed8206"; }
+    { locale = "hsb"; arch = "linux-i686"; sha256 = "2b6a3c03d2f4c8e59503c896bb3654452cb75115aeec24c3b10f4a528c4c0322"; }
+    { locale = "hsb"; arch = "linux-x86_64"; sha256 = "c94b2af1158abb85e0883c6cd8f6f361debfa99d2291f62c47fc7a2413c33758"; }
+    { locale = "hu"; arch = "linux-i686"; sha256 = "0082c743077a1e50575b96e6e4ce4bd65c4fe6830b112d87fc0157556aa4d38d"; }
+    { locale = "hu"; arch = "linux-x86_64"; sha256 = "3dba1ec3efed6f27429ddb7fb3cef5f5061783f6ca7ce3fc64de40e22159c1bd"; }
+    { locale = "hy-AM"; arch = "linux-i686"; sha256 = "4ccb6b342a9a914392fa3a242136b39cba32f0d6029c5f5c4cb9c5c2658a9813"; }
+    { locale = "hy-AM"; arch = "linux-x86_64"; sha256 = "632b713c29d84da3e3e800e7b520a84e3647b5717e08710fc32047270f037de5"; }
+    { locale = "id"; arch = "linux-i686"; sha256 = "6bf6556a9ea92d2dfa3e49bb8563e2de5cc53b264c2e43fed08183717babeee8"; }
+    { locale = "id"; arch = "linux-x86_64"; sha256 = "9d321c03c2392f590288c6f928838e2d5dffd27a7cd7b047199b8170a99619bc"; }
+    { locale = "is"; arch = "linux-i686"; sha256 = "cb6f3d253b4f3bc010a3ea5be449c68050f893d7af912a7b161ef09af881774d"; }
+    { locale = "is"; arch = "linux-x86_64"; sha256 = "edab26c92c2e5e3590775adfca72cddc876e0974cc4101ffe0554c79cec79f51"; }
+    { locale = "it"; arch = "linux-i686"; sha256 = "7e09f9e10f216659afc0e4395e5914c99914dc62742b47091ffe104c70c5158d"; }
+    { locale = "it"; arch = "linux-x86_64"; sha256 = "e1d362fea0f3abed1e9894d5c5ceb9648d4d29e908a99b0b31725d2fbd2f97d0"; }
+    { locale = "ja"; arch = "linux-i686"; sha256 = "db2f20165e5f9d940e409694f10e045855a8dcbdc08004f637827348cea8d760"; }
+    { locale = "ja"; arch = "linux-x86_64"; sha256 = "425784e5502ca41ec131fbb71a0f8390468d08a80848cbf8e8c27de752755646"; }
+    { locale = "kk"; arch = "linux-i686"; sha256 = "c7faf20960a5882f61173974c62ce4f57e6d65f210a608c4ad29c6135f3f9de2"; }
+    { locale = "kk"; arch = "linux-x86_64"; sha256 = "56849c7caa7b8058e65438a090e8d1c9465548afc8413ed9b62846147573649b"; }
+    { locale = "km"; arch = "linux-i686"; sha256 = "1df201969617dd64f9532128216305780130871c2bd7b52632e9d6759efa633f"; }
+    { locale = "km"; arch = "linux-x86_64"; sha256 = "5445cc000d95bf43a822d9f95581a75aee4ed267aa291a377c8bbd6e10d99bae"; }
+    { locale = "kn"; arch = "linux-i686"; sha256 = "d6388df75df201b0d876fd2da6d4865fe9803a81ad385e3ec51cd0f1e23ee581"; }
+    { locale = "kn"; arch = "linux-x86_64"; sha256 = "6fa81e2c9077ace3215de6583e860887209ef68d4cc15243a585771453a6e98f"; }
+    { locale = "ko"; arch = "linux-i686"; sha256 = "2c7d2fa3727b5befdf8e538b0f31ea43a9f1ce4cd164ead8cddd231525f6d523"; }
+    { locale = "ko"; arch = "linux-x86_64"; sha256 = "91f89a54979bd625ad5ff840bf876205a151e023b7fcfbd3a917fb2d9e586ce0"; }
+    { locale = "lij"; arch = "linux-i686"; sha256 = "3bab33ddca338da11b75b34f2db6c78ac89ceec4b0936c1a0e54f71b00926da6"; }
+    { locale = "lij"; arch = "linux-x86_64"; sha256 = "ad470c6c38adee3ba65098dd69a358176d8fc750b9e4062a4adffbd9d610a4cf"; }
+    { locale = "lt"; arch = "linux-i686"; sha256 = "a2e50a5330a18ea49edbcc45f7cd0c6daf8044bb8e4393569bf937a03ea44be7"; }
+    { locale = "lt"; arch = "linux-x86_64"; sha256 = "761ab112b43a21553bee96a845a0300b492f4189e49cf3952a5f2abb3ef3da98"; }
+    { locale = "lv"; arch = "linux-i686"; sha256 = "08ee4150abdf8f6a5e609e7c7a86ad0624b65b6750df7f7e89fdcaeb2af3ab58"; }
+    { locale = "lv"; arch = "linux-x86_64"; sha256 = "32e2ccb0b162c7b48a1b331547fb4449470833397662e37cad054885ddc22a1f"; }
+    { locale = "mai"; arch = "linux-i686"; sha256 = "33733010e364be12ce023ae890afe14a95426a904429c422875d5cd0fbbbdd05"; }
+    { locale = "mai"; arch = "linux-x86_64"; sha256 = "621886c515627faa305c3029b880d88f88671e2bf1dee55c07f29adeb7b3b07b"; }
+    { locale = "mk"; arch = "linux-i686"; sha256 = "64833dae9d93818289edae4b3964dd6abcfe7b1a35751e6b4836d635ed383262"; }
+    { locale = "mk"; arch = "linux-x86_64"; sha256 = "344f82fa85ba3ec1fc945aaf7e185b2fb7b6077ae9d178ba0bd31e381096b0da"; }
+    { locale = "ml"; arch = "linux-i686"; sha256 = "7f659b446ead282c12be202510f42b0b286cf4667399ce891f2e412b23b9c39c"; }
+    { locale = "ml"; arch = "linux-x86_64"; sha256 = "9277acf9c4836fbeef17482f87343cc14c81adaf0939b12dc943e28cdb42dbda"; }
+    { locale = "mr"; arch = "linux-i686"; sha256 = "ab8a5d5282c43ba3e7b3007f9c85a8bb90f981a9eaaaaa2825b4767791a98aaf"; }
+    { locale = "mr"; arch = "linux-x86_64"; sha256 = "032aa9462b189faee85aa41da633c44d91962ccf7e0f58ba332ef039d8c909f0"; }
+    { locale = "ms"; arch = "linux-i686"; sha256 = "05446c324dd379bddb4adf457c8b889512383f97f3402fff915a331977fbad19"; }
+    { locale = "ms"; arch = "linux-x86_64"; sha256 = "92f9ab50f8f6acc962408fccf2d04a431689a8b3ebfb7267b5354f3fd45f2ee1"; }
+    { locale = "nb-NO"; arch = "linux-i686"; sha256 = "5f17aa376b3b427be78149330f39d7551c0662c96e3748353aaff66a0678d76a"; }
+    { locale = "nb-NO"; arch = "linux-x86_64"; sha256 = "c80518adfb3297e9b86b6e756543af0c00b93b94a582ae0d2ea9ae09e492aa39"; }
+    { locale = "nl"; arch = "linux-i686"; sha256 = "3742c55f29df607949a022c58198047c85bca9cce92bcac2ad3edd1d59369d3e"; }
+    { locale = "nl"; arch = "linux-x86_64"; sha256 = "821242ff332f747a7e64e191821d5ef364ce60e81bc6469b578f418f6247138c"; }
+    { locale = "nn-NO"; arch = "linux-i686"; sha256 = "666fde211cb7bafbc16d225a06717f12f3bc00b4bb1a1c370ae36013037ce8df"; }
+    { locale = "nn-NO"; arch = "linux-x86_64"; sha256 = "0b552296bd154d78fb615f60feb63442ad9790c31101ede4bdb8dc101d163a26"; }
+    { locale = "or"; arch = "linux-i686"; sha256 = "28453ca9c48bc0c06bd5f57f110d4a9d4d8418dd7175b353664eea3547dd2f94"; }
+    { locale = "or"; arch = "linux-x86_64"; sha256 = "dc273e392c654be0160ee60c2db2ef90acff7771ed0aeade38dd96051df9ee29"; }
+    { locale = "pa-IN"; arch = "linux-i686"; sha256 = "e690cf215c693ef3e934a5d4a2b06c98e4da3b205bf44b3392b6fbfaee464167"; }
+    { locale = "pa-IN"; arch = "linux-x86_64"; sha256 = "b399037e89c83872238489ec82d6683f0383bd9efd559f497ca4c60f6b32d6b0"; }
+    { locale = "pl"; arch = "linux-i686"; sha256 = "f455c411b3c46155bb37086f16878e18cbf493d6845ff5c9731ce86bf8743f1b"; }
+    { locale = "pl"; arch = "linux-x86_64"; sha256 = "37561debefd6e7cc0790517bc0afa8e924b65abebee654390f1e175797b98eea"; }
+    { locale = "pt-BR"; arch = "linux-i686"; sha256 = "f98e9944ae43b739f44743392e5aedf8eb968a1cdee85ee9e458225c2e250305"; }
+    { locale = "pt-BR"; arch = "linux-x86_64"; sha256 = "b10a4c8ce4be229a384c48663fe1391b2a6ae276bacf0475660989fc795c9494"; }
+    { locale = "pt-PT"; arch = "linux-i686"; sha256 = "9bbe3af6bad4f052332621e2cd2fbeefed70bdb1726045c49db23b2e5ccd116a"; }
+    { locale = "pt-PT"; arch = "linux-x86_64"; sha256 = "b1b5df4587b7706e8f2ef95978cd1e8ff3d13e57f003a82918005a358175e87d"; }
+    { locale = "rm"; arch = "linux-i686"; sha256 = "0e36c1f71249c93c2d7ed4e950f05e6879a57e5c2bd95da53ce7ebb5ce7b0264"; }
+    { locale = "rm"; arch = "linux-x86_64"; sha256 = "91b165b2703605bf3fd53f610c1362b54ae4814eaeee4ee79e3dbca76c29f3f5"; }
+    { locale = "ro"; arch = "linux-i686"; sha256 = "ec74d573c28236eee3e0db9f4f618666816598becca2547e6532d2c9ba49af59"; }
+    { locale = "ro"; arch = "linux-x86_64"; sha256 = "da44dd696ecfa24ac80edd7b3270f960c35235e8be5c315a21a34305858fb14a"; }
+    { locale = "ru"; arch = "linux-i686"; sha256 = "4c6a0778715f18eeebe377cb097c8871c30e704674ec28c96a239f24d7104256"; }
+    { locale = "ru"; arch = "linux-x86_64"; sha256 = "be1f22e43c9bccc89dfe03bd5888fff08e7e15c9660d381435d86e0e9b55467c"; }
+    { locale = "si"; arch = "linux-i686"; sha256 = "d4f78ac52a4457a8e28d7b87d1c9a58224f4b30f3b70178b721eef4207014ae2"; }
+    { locale = "si"; arch = "linux-x86_64"; sha256 = "246c553262c646a5065c684b752f7e410973c3c7354b051ce404188efdd7393c"; }
+    { locale = "sk"; arch = "linux-i686"; sha256 = "629fff240304c8e45854ec3d9d9e66b67430663484f17e93eb109738cf5c7d8b"; }
+    { locale = "sk"; arch = "linux-x86_64"; sha256 = "804c9b3a7377ad0863e510e4a07166bcbe3fc89ba0704983e1b44122e0d1c6b4"; }
+    { locale = "sl"; arch = "linux-i686"; sha256 = "546882ca19cc9b764264df9565ae13f0a72c167b641bfde2c5f040f1a62445a3"; }
+    { locale = "sl"; arch = "linux-x86_64"; sha256 = "e6981343cdf05ac4e8f0b5f8477e3dbfaf852415089485e95dca74168a720489"; }
+    { locale = "son"; arch = "linux-i686"; sha256 = "77d7c08293b29e773fdcd5bf3e9adab80b6bc838cb7557436b43cfd5db3b4247"; }
+    { locale = "son"; arch = "linux-x86_64"; sha256 = "8853c8b5b650a1ec898c2819e3d185662fc2c1823a5c2c3db90154c023280a1d"; }
+    { locale = "sq"; arch = "linux-i686"; sha256 = "1a9c4879b63973a02d6f4b9d7d07f0cfbcd1da2da5af82f0dba167d651f22126"; }
+    { locale = "sq"; arch = "linux-x86_64"; sha256 = "6f713b8fdd256c0062bcd1f653a852cd2fb0d63c8bd5016d6bb72a70184b7fac"; }
+    { locale = "sr"; arch = "linux-i686"; sha256 = "79efab1a2d6597ffbeef32b969febe70cf589695e0142208df1f4fdc8018d791"; }
+    { locale = "sr"; arch = "linux-x86_64"; sha256 = "e2ae5c1b10e70c729c263f9950d3d20d1ecd011a76e3919c6b67cd410ac214b9"; }
+    { locale = "sv-SE"; arch = "linux-i686"; sha256 = "79e75bf8894b5102373c58c19fbcf3bcc3c2c59bfdf3cf76c97306bd6def34da"; }
+    { locale = "sv-SE"; arch = "linux-x86_64"; sha256 = "3dfbf13fefa507d6975de0e92ce5d32da1e0b7c1d6deb4fe7551b305cc818a51"; }
+    { locale = "ta"; arch = "linux-i686"; sha256 = "9f3b56250f344da8bbb3fb23dda1c7bd5bd6dcb8997df27af3b92a259d0102cd"; }
+    { locale = "ta"; arch = "linux-x86_64"; sha256 = "9ec347d26885049750c3a0d17c75557bcf67d3a28048920a6d7aafee5805e8f8"; }
+    { locale = "te"; arch = "linux-i686"; sha256 = "b25bab31e21ff3fbb0eea10d1b127837c73e8e4bada958385c21482dafc1a7e4"; }
+    { locale = "te"; arch = "linux-x86_64"; sha256 = "1c1e6b3dfa8ee24e40f05d41cf0da97c92108d7ca97645b4c4ce671c3fed641d"; }
+    { locale = "th"; arch = "linux-i686"; sha256 = "350caf486c89265b61bfd91cc9df4a20d7ff1071fdf995e7aa03b8c27d83c702"; }
+    { locale = "th"; arch = "linux-x86_64"; sha256 = "7a8784265237951140b62a219da144e2f5091cb1d75d8af3e5a4d3ebdc4a2d0e"; }
+    { locale = "tr"; arch = "linux-i686"; sha256 = "b623db840358f2275143f0748fb988c7088799ab55ce4570ce8e47fa891b2c98"; }
+    { locale = "tr"; arch = "linux-x86_64"; sha256 = "65f7883a2f03881949196c90ca2b3c13c374ccf51b749348a92040361671ace7"; }
+    { locale = "uk"; arch = "linux-i686"; sha256 = "8ce4cae2d1fd912b9fd4e440012fa4dad7a912f6c78d3349cfa2a4764f609a94"; }
+    { locale = "uk"; arch = "linux-x86_64"; sha256 = "53ac6bae5e8efbfc819df8f16eb9ebba2bce886db423743ac760c89dc48739a2"; }
+    { locale = "uz"; arch = "linux-i686"; sha256 = "22a5e05529c6a4fb6488bfcc1e0c2b2297e72e18a47464e8e8148f1dc94c639e"; }
+    { locale = "uz"; arch = "linux-x86_64"; sha256 = "8a3fa76e01715c602238bf0a5d31b8acb733d0efe9fbad390f6c2aa5d9e6ebb1"; }
+    { locale = "vi"; arch = "linux-i686"; sha256 = "453f93b065b5e4f66d549c8482ef31edbbef5d9a77fefb87b25808540d368dd0"; }
+    { locale = "vi"; arch = "linux-x86_64"; sha256 = "2965dbde06aa9207236b33636bec971dbd01f71f9b0d13681d991befec931242"; }
+    { locale = "xh"; arch = "linux-i686"; sha256 = "edfffe8ab6f446760f13d5351be2c8f4cb2db28e9f1d6b9bb80b1e8fca191b42"; }
+    { locale = "xh"; arch = "linux-x86_64"; sha256 = "ac3308380a60489a5965968215f7134fdb5e1f8586925fbb0c4d42cff940b794"; }
+    { locale = "zh-CN"; arch = "linux-i686"; sha256 = "8058ee0f3a6ab3d229ce1f34ed4c38cbdc53e05cf1bb1a06535b7c12e7d5570d"; }
+    { locale = "zh-CN"; arch = "linux-x86_64"; sha256 = "ea91bbd7af46d63996260a32737d55e191a2dce4827561ab1c60ade26ed4ca91"; }
+    { locale = "zh-TW"; arch = "linux-i686"; sha256 = "18e9090333dd6a174feb0bc98dc849e933dd806205ea62d7cf292d8a6b65a2ca"; }
+    { locale = "zh-TW"; arch = "linux-x86_64"; sha256 = "9dc786ddb1b87245c1fcc5e88e601a1b2680141c363336ae099d953405c2d6cb"; }
   ];
 }

pkgs/applications/networking/browsers/mozilla-plugins/flashplayer-11/default.nix

···
 in
 stdenv.mkDerivation rec {
   name = "flashplayer-${version}";
-  version = "11.2.202.554";
+  version = "11.2.202.559";
 
   src = fetchurl {
     url = "https://fpdownload.macromedia.com/pub/flashplayer/installers/archive/fp_${version}_archive.zip";
-    sha256 = "0pjan07k419pk3lmfdl5vww0ipf5b76cxqhxwjrikb1fc4x993fi";
+    sha256 = "1vb01pd1jhhh86r01nwdzcf66d72jksiyiyp92hs4khy6n5qfsl3";
   };
 
   buildInputs = [ unzip ];

pkgs/applications/networking/feedreaders/rawdog/default.nix

···
 { stdenv, fetchurl, pythonPackages }:
 
+let version = "2.21"; in
 pythonPackages.buildPythonPackage rec {
-  name = "rawdog-2.20";
+  name = "rawdog-${version}";
 
   src = fetchurl {
     url = "http://offog.org/files/${name}.tar.gz";
-    sha256 = "0a63b26cc111b0deca441f498177b49be0330760c5c0e24584cdb9ba1e7fd5a6";
+    sha256 = "0f5z7b70pyhjl6s28hgxninsr86s4dj5ycd50sv6bfz4hm1c2030";
   };
 
   propagatedBuildInputs = with pythonPackages; [ feedparser ];
 
   namePrefix = "";
   
-  meta = {
+  meta = with stdenv.lib; {
+    inherit version;
     homepage = "http://offog.org/code/rawdog/";
-    description = "An RSS Aggregator Without Delusions Of Grandeur";
-    license = stdenv.lib.licenses.gpl2;
-    platform = stdenv.lib.platforms.unix;
+    description = "RSS Aggregator Without Delusions Of Grandeur";
+    license = licenses.gpl2;
+    platform = platforms.unix;
+    maintainers = with maintainers; [ nckx ];
   };
 }

pkgs/applications/networking/irc/hexchat/default.nix

···
     desktop_file_utils hicolor_icon_theme
   ];
 
+ #hexchat and heachat-text loads enchant spell checking library at run time and so it needs to have route to the path
+  patchPhase = ''
+    sed -i "s,libenchant.so.1,${enchant}/lib/libenchant.so.1,g" src/fe-gtk/sexy-spell-entry.c
+  '';
+
   configureFlags = [ "--enable-shm" "--enable-textfe" ];
 
   meta = with stdenv.lib; {

pkgs/applications/networking/irc/xchat/default.nix

···
-{stdenv, fetchurl, pkgconfig, tcl, gtk}:
+{stdenv, fetchurl, pkgconfig, tcl, gtk, gtkspell }:
 
 stdenv.mkDerivation {
   name = "xchat-2.8.8";
···
     url = http://www.xchat.org/files/source/2.8/xchat-2.8.8.tar.bz2;
     sha256 = "0d6d69437b5e1e45f3e66270fe369344943de8a1190e498fafa5296315a27db0";
   };
-  buildInputs = [pkgconfig tcl gtk];
-  configureFlags = "--disable-nls";
+  buildInputs = [pkgconfig tcl gtk gtkspell];
+  configureFlags = "--disable-nls --enable-spell=gtkspell";
 
   patches = [ ./glib-top-level-header.patch ];
 

pkgs/applications/networking/mailreaders/imapfilter.nix

···
 { stdenv, fetchurl, openssl, lua, pcre }:
 
 stdenv.mkDerivation rec {
-  name = "imapfilter-2.5.7";
+  name = "imapfilter-2.6.3";
 
   src = fetchurl {
-    url = "https://github.com/lefcha/imapfilter/archive/v2.5.7.tar.gz";
-    sha256 = "1l7sg7pyw1i8cxqnyb5xv983fakj8mxq6w44qd7w3kc7l6ixd4n7";
+    url = "https://github.com/lefcha/imapfilter/archive/v2.6.3.tar.gz";
+    sha256 = "0i6j9ilzh43b9gyqs3y3rv0d9yvbbg12gcbqbar9i92wdlnqcx0i";
   };
 
   makeFlagsArray = "PREFIX=$(out)";

pkgs/applications/networking/mumble/default.nix

···
       cp man/mum* $out/share/man/man1
     '' + (overrides.installPhase or "");
 
+    enableParallelBuilding = true;
+
     meta = {
       description = "Low-latency, high quality voice chat software";
       homepage = "http://mumble.sourceforge.net/";
···
     type = "murmur";
 
     postPatch = optional iceSupport ''
-      sed -i 's,/usr/share/Ice/,${zeroc_ice}/,g' src/murmur/murmur.pro
+      grep -Rl '/usr/share/Ice' . | xargs sed -i 's,/usr/share/Ice/,${zeroc_ice}/,g'
     '';
 
     configureFlags = [

pkgs/applications/networking/newsreaders/liferea/default.nix

···
   '';
 
   meta = with stdenv.lib; {
-    description = "A GTK-based news feed agregator";
+    description = "A GTK-based news feed aggregator";
     homepage = http://lzone.de/liferea/;
     license = licenses.gpl2Plus;
     maintainers = with maintainers; [ vcunat romildo ];

pkgs/applications/networking/p2p/qbittorrent/default.nix

···
 { stdenv, fetchurl, pkgconfig, which
-, boost, libtorrentRasterbar, qt4
+, boost, libtorrentRasterbar, qt5
 , debugSupport ? false # Debugging
 , guiSupport ? true, dbus_libs ? null # GUI (disable to run headless)
 , webuiSupport ? true # WebUI
···
 with stdenv.lib;
 stdenv.mkDerivation rec {
   name = "qbittorrent-${version}";
-  version = "3.2.3";
+  version = "3.3.1";
 
   src = fetchurl {
     url = "mirror://sourceforge/qbittorrent/${name}.tar.xz";
-    sha256 = "05590ak4nnqkah8dy71cxf7mqv6phw0ih1719dm761mxf8vrz9w6";
+    sha256 = "1li9law732n4vc7sn6i92pwxn8li7ypqaxcmfpm17kk978immlfs";
   };
 
   nativeBuildInputs = [ pkgconfig which ];
 
-  buildInputs = [ boost libtorrentRasterbar qt4 ]
+  buildInputs = [ boost libtorrentRasterbar qt5.qtbase qt5.qttools ]
     ++ optional guiSupport dbus_libs;
 
   configureFlags = [
···
     (if guiSupport then "" else "--disable-gui")
     (if webuiSupport then "" else "--disable-webui")
   ] ++ optional debugSupport "--enable-debug";
+
+  # The lrelease binary is named lrelease instead of lrelease-qt4
+  patches = [ ./fix-lrelease.patch];
 
   # https://github.com/qbittorrent/qBittorrent/issues/1992 
   enableParallelBuilding = false;

pkgs/applications/networking/p2p/qbittorrent/fix-lrelease.patch

···
+diff --git a/qm_gen.pri b/qm_gen.pri
+index ed29b76..2d5990c 100644
+--- a/qm_gen.pri
++++ b/qm_gen.pri
+@@ -5,7 +5,7 @@ isEmpty(QMAKE_LRELEASE) {
+     win32|os2:QMAKE_LRELEASE = $$[QT_INSTALL_BINS]\\lrelease.exe
+     else:QMAKE_LRELEASE = $$[QT_INSTALL_BINS]/lrelease
+     unix {
+-        !exists($$QMAKE_LRELEASE) { QMAKE_LRELEASE = lrelease-qt4 }
++        !exists($$QMAKE_LRELEASE) { QMAKE_LRELEASE = lrelease }
+     } else {
+         !exists($$QMAKE_LRELEASE) { QMAKE_LRELEASE = lrelease }
+     }

pkgs/applications/office/kmymoney/default.nix

···
 { stdenv, fetchurl, cmake, kdelibs, automoc4, kdepimlibs, gettext, pkgconfig
 , shared_mime_info, perl, boost, gpgme, gmpxx, libalkimia, libofx, libical
-, doxygen }:
+, doxygen, aqbanking, gwenhywfar }:
 
 stdenv.mkDerivation rec {
-  name = "kmymoney-4.6.4";
+  name = "kmymoney-4.7.2";
 
   src = fetchurl {
     url = "mirror://sourceforge/kmymoney2/${name}.tar.xz";
-    sha256 = "04n0lgi2yrx67bgjzbdbcm10pxs7l53srmp240znzw59njnjyll9";
+    sha256 = "0g9rakjx7zmw4bf7m5516rrx0n3bl2by3nn24iiz9209yfgw5cmz";
   };
 
+  cmakeFlags = [
+    "-DENABLE_KBANKING='true'"
+  ];
+
   buildInputs = [ kdepimlibs perl boost gpgme gmpxx libalkimia libofx libical
-                  doxygen ];
+                  doxygen aqbanking gwenhywfar ];
   nativeBuildInputs = [ cmake automoc4 gettext shared_mime_info pkgconfig ];
 
   KDEDIRS = libalkimia;

pkgs/applications/office/libreoffice/default.nix

···
 , librsvg, gnome_vfs, mesa, bsh, CoinMP, libwps, libabw
 , autoconf, automake, openldap, bash, hunspell, librdf_redland, nss, nspr
 , libwpg, dbus_glib, glibc, qt4, kde4, clucene_core, libcdr, lcms, vigra
-, unixODBC, mdds, saneBackends, mythes, libexttextcat, libvisio
+, unixODBC, mdds, sane-backends, mythes, libexttextcat, libvisio
 , fontsConf, pkgconfig, libzip, bluez5, libtool, maven
 , libatomic_ops, graphite2, harfbuzz, libodfgen
 , librevenge, libe-book, libmwaw, glm, glew, gst_all_1
 , gdb, commonsLogging
-, langs ? [ "en-US" "en-GB" "ca" "ru" "eo" "fr" "nl" "de" "sl" ]
+, langs ? [ "en-US" "en-GB" "ca" "ru" "eo" "fr" "nl" "de" "sl" "pl" ]
 , withHelp ? true
 }:
 
···
       libXdmcp libpthreadstubs mesa mythes gst_all_1.gstreamer
       gst_all_1.gst-plugins-base
       neon nspr nss openldap openssl ORBit2 pam perl pkgconfigUpstream poppler
-      python3 sablotron saneBackends tcsh unzip vigra which zip zlib
+      python3 sablotron sane-backends tcsh unzip vigra which zip zlib
       mdds bluez5 glibc libcmis libwps libabw
       libxshmfence libatomic_ops graphite2 harfbuzz
       librevenge libe-book libmwaw glm glew

pkgs/applications/office/skrooge/default.nix

···
 , libxslt, kdelibs, kdepimlibs, grantlee, qjson, qca2, libofx, sqlite, boost }:
 
 stdenv.mkDerivation rec {
-  name = "skrooge-1.10.0";
+  name = "skrooge-1.12.5";
 
   src = fetchurl {
-    url = "http://download.kde.org/stable/skrooge/${name}.tar.bz2";
-    sha256 = "0rsw2xdgws5bvnf3h4hg16liahigcxgaxls7f8hzr9wipxx5xqda";
+    url = "http://download.kde.org/stable/skrooge/${name}.tar.xz";
+    sha256 = "1mnkm0367knh0a65gifr20p42ql9zndw7d6kmbvfshvpfsmghl40";
   };
 
   buildInputs = [ libxslt kdelibs kdepimlibs grantlee qjson qca2 libofx sqlite boost ];

pkgs/applications/office/zotero/default.nix

···
 
   xpi = fetchurl {
     url = "https://download.zotero.org/extension/zotero-${version}.xpi";
-    sha256 = "15wdbwnaxs748psjnxw40wld45npjjmvwx70c0jx2p63y6ks2gcx";
+    sha256 = "02h2ja08v8as4fawj683rh5rmxsjf5d0qmvqa77i176nm20y5s7s";
   };
 
-  version = "4.0.26";
+  version = "4.0.28";
 
 in
 stdenv.mkDerivation {
···
   inherit version;
 
   src = fetchurl {
-    url = "https://github.com/zotero/zotero-standalone-build/archive/${version}.tar.gz";
-    sha256 = "11gbislxkhfycnii05v6d8h9qdp5rk5xag7kdnsih67gicnn467g";
+    url = "https://github.com/zotero/zotero-standalone-build/archive/4.0.28.8.tar.gz";
+    sha256 = "ab1fd5dde9bd2a6b6d31cc9a53183a04de3698f1273a943ef31ecc4c42808a68";
   };
 
   nativeBuildInputs = [ perl unzipNLS ];

pkgs/applications/science/logic/alt-ergo/default.nix

···
-{ fetchurl, stdenv, ocaml, ocamlPackages }:
+{ fetchurl, stdenv, ocamlPackages }:
 
 stdenv.mkDerivation rec {
   name = "alt-ergo-${version}";
···
     description = "High-performance theorem prover and SMT solver";
     homepage    = "http://alt-ergo.ocamlpro.com/";
     license     = stdenv.lib.licenses.cecill-c; # LGPL-2 compatible
-    platforms   = stdenv.lib.platforms.linux;
+    platforms   = stdenv.lib.platforms.linux ++ stdenv.lib.platforms.darwin;
     maintainers = [ stdenv.lib.maintainers.thoughtpolice ];
   };
 }

pkgs/applications/science/logic/metis-prover/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "metis-prover-${version}";
-  version = "2.3";
+  version = "2.3.20160101";
 
   src = fetchurl {
     url = "http://www.gilith.com/software/metis/metis.tar.gz";
-    sha256 = "07wqhic66i5ip2j194x6pswwrxyxrimpc4vg0haa5aqv9pfpmxad";
+    sha256 = "0wkh506ggwmfacwl19n84n1xi6ak4xhrc96d9pdkpk8zdwh5w58l";
   };
 
   nativeBuildInputs = [ perl ];
···
     homepage = http://www.gilith.com/research/metis/;
     license = licenses.mit;
     maintainers = with maintainers; [ gebner ];
+    platforms = platforms.unix;
   };
 }

pkgs/applications/video/avidemux/default.nix

···
 assert faacSupport -> faac != null;
 
 stdenv.mkDerivation {
-  name = "avidemux-2.6.9";
+  name = "avidemux-2.5.6";
 
   src = fetchurl {
-    url = mirror://sourceforge/avidemux/avidemux_2.6.9.tar.gz;
-    sha256 = "01jhgricd7m9hdhr22yrdjfrnl41zccm2yxw7gfb02mwcswvswy0";
+    url = mirror://sourceforge/avidemux/avidemux_2.5.6.tar.gz;
+    sha256 = "12wvxz0n2g85f079d8mdkkp2zm279d34m9v7qgcqndh48cn7znnn";
   };
 
   buildInputs = [ cmake pkgconfig libxml2 qt4 gtk gettext SDL libXv
···
   meta = {
     homepage = http://fixounet.free.fr/avidemux/;
     description = "Free video editor designed for simple video editing tasks";
-    maintainers = with stdenv.lib.maintainers; [ viric jagajaga ];
+    maintainers = with stdenv.lib.maintainers; [viric];
     platforms = with stdenv.lib.platforms; linux;
   };
 }

pkgs/applications/video/bomi/default.nix

···
                   libvdpau
                   libva
                   libbluray
+                  qtquickcontrols
                 ]
                 ++ optional jackSupport jack
                 ++ optional portaudioSupport portaudio

pkgs/applications/video/mkvtoolnix/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "mkvtoolnix-${version}";
-  version = "8.3.0";
+  version = "8.4.0";
 
   src = fetchurl {
     url = "http://www.bunkus.org/videotools/mkvtoolnix/sources/${name}.tar.xz";
-    sha256 = "0dzwmwa76y4nhb5brp5a1kxgxjr71czd8vj218qmrlwm54i85gc7";
+    sha256 = "0y7qm8q9vpvjiw7b69k9140pw9nhvs6ggmk56yxnmcd02inm19gn";
   };
 
   patchPhase = ''

pkgs/applications/virtualization/docker/default.nix

···
 { stdenv, fetchFromGitHub, makeWrapper
 , go, sqlite, iproute, bridge-utils, devicemapper
-, btrfsProgs, iptables, e2fsprogs, xz, utillinux
+, btrfs-progs, iptables, e2fsprogs, xz, utillinux
 , enableLxc ? false, lxc
 }:
 
···
   };
 
   buildInputs = [
-    makeWrapper go sqlite iproute bridge-utils devicemapper btrfsProgs
+    makeWrapper go sqlite iproute bridge-utils devicemapper btrfs-progs
     iptables e2fsprogs
   ];
 

pkgs/build-support/fetchgitlocal/default.nix

···
       preferLocalBuild = true;
     } ''
       cd ${srcStr}
-      ROOT=$(git rev-parse --show-toplevel) # path to repo
+      DOT_GIT=$(git rev-parse --resolve-git-dir .git) # path to repo
 
-      cp $ROOT/.git/index $ROOT/.git/index-user # backup index
+      cp $DOT_GIT/index $DOT_GIT/index-user # backup index
       git reset # reset index
       git add . # add current directory
 
···
       git rev-parse $(git write-tree) \
         | tr -d '\n' > $out
 
-      mv $ROOT/.git/index-user $ROOT/.git/index # restore index
+      mv $DOT_GIT/index-user $DOT_GIT/index # restore index
     '';
 
   gitHash = builtins.readFile gitHashFile; # cache against git hash

pkgs/build-support/native-darwin-cctools-wrapper/builder.sh

···
-source $stdenv/setup
-
-mkdir -p $out/bin
-for i in $binaries
-do 
-    ln -s "/usr/bin/$i" "$out/bin/"
-done
-
-# MIG assumes the standard Darwin core utilities (e.g., `rm -d'), so
-# let it see the impure directories.
-cat > "$out/bin/mig" <<EOF
-#!/bin/sh
-export PATH="/usr/bin:/bin:\$PATH"
-exec /usr/bin/mig "\$@"
-EOF
-chmod +x "$out/bin/mig"

pkgs/build-support/native-darwin-cctools-wrapper/default.nix

···
-{stdenv}:
-
-stdenv.mkDerivation {
-  name = "native-darwin-cctools-wrapper";
-
-  # Standard binaries normally found under /usr/bin (MIG is omitted here, and
-  # handled specially in ./builder.sh).
-  binaries =
-    [ "ar" "as" "c++filt" "gprof" "ld" "nm" "nmedit" "ranlib"
-      "size" "strings" "strip" "dsymutil" "libtool" "lipo"
-      "install_name_tool" "arch" "sw_vers"
-    ];
-
-  builder = ./builder.sh;
-}

pkgs/build-support/upstream-updater/update-walker.txt

···
+update-walker is an imperative semiautomated update helper.
+
+It runs the X.upstream file to find the freshest version of the package in
+the specified upstream source and updates the corresponding X.nix file.
+
+
+
+The simplest available commands:
+
+url: set the upstream source list URL equal to $1; the default is
+meta.downloadPage with meta.homepage fallback
+
+dl_url_re: set the regular expression used to select download links to $1; the
+default is meta.downloadURLRegexp or '[.]tar[.]([^./])+\$' if it is not set
+
+target: specify target expression; default is to replace .upstream extension
+with .nix extension
+
+name: specify the derivation name; default is the basename of the dirname
+of the .upstream file
+
+attribute_name: specify the attribute name to evaluate for getting the current
+version from meta.version; default is to use the derivation name
+
+minimize_overwrite: set config options that mean that only version= and
+sha256= have to be replaced; the default is to regenerate a full upstream
+description block with url, name, version, hash etc.
+
+
+
+A lot of packages can be updated in a pseudo-declarative style using only
+the commands from the previous paragraph.
+
+Some packages do not need any non-default settings, in these case just setting
+meta.updateWalker to true is enough, you can run update-walker directly on the
+.nix file afterwards. In this case minimize_overwrite it implied unless
+meta.fullRegenerate is set.
+
+
+
+The packages that require more fine-grained control than the described options
+allow, you need to take into account the default control flow of the tool.
+
+First, the definitions from update-walker script and additional definitions
+from update-walker-service-specific.sh are loaded. Then the config is executed
+as a shell script. Some of the commands it can use do remember whether they
+have been used. Afterwards the following steps happen: 
+
+attribute_name is set to name unless it has been already set
+
+meta.version is read from the NixPkgs package called attribute_name
+
+download URL regexp is set to default unless it has been already set in the
+updater script
+
+the download page URL gets set to default value unless it has been set
+previously
+
+if the action of getting the download page and choosing the freshest link by
+version has not yet been taken, it happens
+
+if the version has not yet been extracted from the URL, it gets extracted
+
+target nix expression to update gets set to the default value unless it has
+been set explicitly
+
+if the URL version is fresher than the packaged version, the new file gets
+downloaded and its hash is calculated
+
+do_overwrite function is called; the default calculates a big upstream data
+block and puts it after the '# Generated upstream information' marker (the
+marker can be changed by the command marker)
+
+
+
+If the update needs some special logic, it is put into the updater script and
+the corresponding steps are skipped because the needed action has already been
+performed. 
+
+For example: 
+
+minimize_overwrite is exactly the same as
+
+do_overwrite() { do_overwrite_just_version; }
+
+redefinition. You can do a more complex do_overwrite redifinition, if needed.
+It can probably use ensure_hash to download the source and calculate the hash
+and set_var_value.
+
+set_var_value alters the $3-th instance of assigning the $1 name in the
+expression to the value $2. $3 defaults to 1. It can modify $4 instead of the
+current target, it can put the value without quotes if $5 is 1.
+
+
+
+Typical steps include:
+
+ensure_choice: download current URL and find the freshest version link on the
+page, it is now the new URL
+
+ensure_hash: download current URL and calculate the source package hash
+
+ensure_version: extract version from the URL
+
+SF_redirect: replace the current URL with a SourceForge.net mirror:// URL
+
+SF_version_dir: assume SourceForge.net layout and choose the freshest
+version-named subdirectory in the file catalog; you can optionally specify $1
+as a directory name regexp (digits and periods will be required after it)
+
+SF_version_tarball: assume SourceForge.net layout and choose the freshest
+tarball download link
+
+version: apply replacement of $1 with $2 (extended regexp format) to extract
+the version from URL
+
+version_link: choose the freshest versioned link, $1 is the regexp of
+acceptable links

pkgs/data/documentation/man-pages/default.nix

···
 { stdenv, fetchurl }:
 
-let version = "4.03"; in
+let version = "4.04"; in
 stdenv.mkDerivation rec {
   name = "man-pages-${version}";
 
   src = fetchurl {
     url = "mirror://kernel/linux/docs/man-pages/${name}.tar.xz";
-    sha256 = "177w71rwsw3lsh9pjqy625s5iwz1ahdaj7prys1bpc4bqi78q5mh";
+    sha256 = "0v8zxq4scfixy3pjpw9ankvv5v8frv62khv4xm1jpkswyq6rbqcg";
   };
 
   makeFlags = [ "MANDIR=$(out)/share/man" ];

pkgs/data/fonts/cantarell-fonts/default.nix

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation {
-  name = "cantarell-fonts-0.0.16";
+  name = "cantarell-fonts-0.0.17";
 
   src = fetchurl {
-    url = mirror://gnome/sources/cantarell-fonts/0.0/cantarell-fonts-0.0.16.tar.xz;
-    sha256 = "071g2l89gdjgqhapw9dbm1ch6hnzydhf7b38pi86fm91adaqggqm";
+    url = mirror://gnome/sources/cantarell-fonts/0.0/cantarell-fonts-0.0.17.tar.xz;
+    sha256 = "0kx05fw1i11zcqx5yv9y9iprpl49k51sibz86bc58a50n1w6gcwn";
   };
 
   meta = {

pkgs/data/fonts/fira-code/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "fira-code-${version}";
-  version = "1.101";
+  version = "1.102";
 
   src = fetchurl {
     url = "https://github.com/tonsky/FiraCode/releases/download/${version}/FiraCode_${version}.zip";
-    sha256 = "0wbjk4cyibyjp7kjvwnm7as1ch312zwjbi469v26sl41svf53s5v";
+    sha256 = "0vcrzf7dmcy3n2ic05ihadmfgzmmmp0vz8grnqaxfi3y1jpw8ggy";
   };
 
   buildInputs = [ unzip ];

pkgs/desktops/kde-4.14/kdegraphics/libksane.nix

···
-{ stdenv, kde, kdelibs, saneBackends }:
+{ stdenv, kde, kdelibs, sane-backends }:
 
 kde {
-  buildInputs = [ kdelibs saneBackends ];
+  buildInputs = [ kdelibs sane-backends ];
 
   meta = {
     description = "An image scanning library that provides a QWidget that contains all the logic needed to interface a sacanner";

pkgs/desktops/kde-4.14/kdeutils/print-manager.nix

···
 { kde, kdelibs
-, pythonPackages, cups, pyqt4, pykde4, pycups, system_config_printer }:
+, pythonPackages, cups, pyqt4, pykde4, pycups, system-config-printer }:
 
-let s_c_p = system_config_printer.override { withGUI = false; }; in
+let s_c_p = system-config-printer.override { withGUI = false; }; in
 
 kde rec {
   buildInputs = [ kdelibs pythonPackages.python pythonPackages.wrapPython

pkgs/development/compilers/go/1.5.nix

···
     sed -i '/TestCgoLookupIP/areturn' src/net/cgo_unix_test.go
     sed -i '/TestChdirAndGetwd/areturn' src/os/os_test.go
     sed -i '/TestRead0/areturn' src/os/os_test.go
+    sed -i '/TestNohup/areturn' src/os/signal/signal_test.go
     sed -i '/TestSystemRoots/areturn' src/crypto/x509/root_darwin_test.go
 
     sed -i '/TestGoInstallRebuildsStalePackagesInOtherGOPATH/areturn' src/cmd/go/go_test.go

pkgs/development/compilers/orc/default.nix

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  name = "orc-0.4.23";
+  name = "orc-0.4.24";
 
   src = fetchurl {
     url = "http://gstreamer.freedesktop.org/src/orc/${name}.tar.xz";
-    sha256 = "1ryz1gfgrxcj806cakcblxf0bcwq8p2mw8k86fs3f5wlwayawzkn";
+    sha256 = "16ykgdrgxr6pfpy931p979cs68klvwmk3ii1k0a00wr4nn9x931k";
   };
 
   outputs = [ "out" "doc" ];

pkgs/development/compilers/uhc/default.nix

···
   meta = with stdenv.lib; {
     homepage = "http://www.cs.uu.nl/wiki/UHC";
     description = "Utrecht Haskell Compiler";
-    maintainers = [ maintainers.phausmann ];
+    maintainers = [ maintainers.phile314 ];
 
     # UHC i686 support is broken, see
     # https://github.com/UU-ComputerScience/uhc/issues/52

pkgs/development/coq-modules/flocq/default.nix

···
 stdenv.mkDerivation rec {
 
   name = "coq-flocq-${coq.coq-version}-${version}";
-  version = "2.5.0";
+  version = "2.5.1";
 
   src = fetchurl {
-    url = "https://gforge.inria.fr/frs/download.php/file/33979/flocq-${version}.tar.gz";
-    sha256 = "0v3qiaz7vxfc5nk8rxwi39mik7hm7p5kb040q2pimb69qgfl6vml";
+    url = https://gforge.inria.fr/frs/download.php/file/35430/flocq-2.5.1.tar.gz;
+    sha256 = "1a0gznvg32ckxgs3jzznc1368p8x2ny4vfwrnavb3h0ljcl1mlzy";
   };
 
   buildInputs = [ coq.ocaml coq.camlp5 bash which autoconf automake ];

pkgs/development/coq-modules/mathcomp/generic.nix

···
   buildFlags = stdenv.lib.optionalString withDoc "doc";
 
   preBuild = ''
+    patchShebangs etc/utils/ssrcoqdep
     cd mathcomp
     export COQBIN=${coq}/bin/
   '';

pkgs/development/coq-modules/ssreflect/generic.nix

···
   inherit patches;
 
   preBuild = ''
+    patchShebangs etc/utils/ssrcoqdep
     cd mathcomp/ssreflect
     export COQBIN=${coq}/bin/
   '';

pkgs/development/haskell-modules/configuration-common.nix

···
   # https://github.com/sol/hpack/issues/53
   hpack = dontCheck super.hpack;
 
+  # Tests require `docker` command in PATH
+  # Tests require running docker service :on localhost
+  docker = dontCheck super.docker;
+
   # https://github.com/deech/fltkhs/issues/16
   fltkhs = overrideCabal super.fltkhs (drv: {
     libraryToolDepends = (drv.libraryToolDepends or []) ++ [pkgs.autoconf];

pkgs/development/haskell-modules/hackage-packages.nix

···
      }) {};
 
   "bindings-sane" = callPackage
-    ({ mkDerivation, base, bindings-DSL, saneBackends }:
+    ({ mkDerivation, base, bindings-DSL, sane-backends }:
      mkDerivation {
        pname = "bindings-sane";
        version = "0.0.1";
        sha256 = "a27eb00e69a804e65f39246611a747f3a833a87dab536c7f3cde60583a60b04b";
        libraryHaskellDepends = [ base bindings-DSL ];
-       libraryPkgconfigDepends = [ saneBackends ];
+       libraryPkgconfigDepends = [ sane-backends ];
        homepage = "http://floss.scru.org/bindings-sane";
        description = "FFI bindings to libsane";
        license = stdenv.lib.licenses.gpl3;
        hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
-     }) {inherit (pkgs) saneBackends;};
+     }) {inherit (pkgs) sane-backends;};
 
   "bindings-sc3" = callPackage
     ({ mkDerivation, base, bindings-DSL, scsynth }:

pkgs/development/interpreters/ceptre/default.nix

···
 { stdenv, fetchgit, mlton }:
 
 stdenv.mkDerivation rec {
-  name = "ceptre-2015-11-20";
+  name = "ceptre-2016-01-01";
 
   src = fetchgit {
     url = https://github.com/chrisamaphone/interactive-lp;
-    rev = "adb59d980f903e49a63b668618241d1b8beb28be";
-    sha256 = "1pyl2imrvq2icr2rr4ys7djnizppbgqldgsv5525xsvzm78w3ac7";
+    rev = "b3d21489d4994f03d2982de273eea90bc7fba5d0";
+    sha256 = "01f72q435kmf3mkgnn47hlnv6k3i5kjb26pbjrwvysc6am33jlcb";
   };
 
   nativeBuildInputs = [ mlton ];

pkgs/development/libraries/boolstuff/default.nix

···
 let baseurl = "http://perso.b2b2c.ca/sarrazip/dev"; in
 
 stdenv.mkDerivation rec {
-  name = "boolstuff-0.1.14";
+  name = "boolstuff-0.1.15";
 
   src = fetchurl {
     url = "${baseurl}/${name}.tar.gz";
-    sha256 = "1ccn9v3kxz44pv3mr8q0l2i9769jiigw1gfv47ia50mbspwb87r6";
+    sha256 = "1mzw4368hqw0b6xr01yqcbs9jk9ma3qq9hk3iqxmkiwqqxgirgln";
   };
 
   nativeBuildInputs = [ pkgconfig ];
 
-  meta = { 
+  meta = {
     description = "Library for operations on boolean expression binary trees";
     homepage = "${baseurl}/boolstuff.html";
     license = "GPL";

pkgs/development/libraries/cmark/default.nix

···
+{ stdenv, fetchurl, cmake }:
+
+stdenv.mkDerivation rec {
+  version = "0.23.0";
+  name = "cmark-${version}";
+
+  src = fetchurl {
+    url = "https://github.com/jgm/cmark/archive/${version}.tar.gz";
+    sha256 = "87d289965066fce7be247d44c0304af1b20817dcc1b563702302ae33f2be0596";
+  };
+
+  buildInputs = [ cmake ];
+
+  meta = {
+    description = "CommonMark parsing and rendering library and program in C";
+    homepage = https://github.com/jgm/cmark;
+    maintainers = [ stdenv.lib.maintainers.michelk ];
+  };
+}

pkgs/development/libraries/enet/default.nix

···
 {stdenv, fetchurl}:
 
 stdenv.mkDerivation rec {
-  name = "enet-1.3.12";
+  name = "enet-1.3.13";
 
   src = fetchurl {
     url = "http://enet.bespin.org/download/${name}.tar.gz";
-    sha256 = "02qxgsn20m306hg3pklfa35mjlc2fqcsd1x4pi3xnbfy1nyir1d5";
+    sha256 = "0p53mnmjbm56wizwraznynx13fcibcxiqny110dp6a5a3w174q73";
   };
 
   meta = {

pkgs/development/libraries/ffms/default.nix

···
 { stdenv, fetchurl, zlib, ffmpeg, pkgconfig }:
 
 stdenv.mkDerivation rec {
-  name = "ffms-2.20";
+  name = "ffms-2.21";
 
   src = fetchurl {
-    url = https://codeload.github.com/FFMS/ffms2/tar.gz/2.20;
+    url = https://codeload.github.com/FFMS/ffms2/tar.gz/2.21;
     name = "${name}.tar.gz";
-    sha256 = "183klnhl57zf0i8xlr7yvj89ih83pzd48c37qpr57hjn4wbq1n67";
+    sha256 = "00h2a5yhvr1qzbrzwbjv1ybxrx25lchgral6yxv36aaf4pi3rhn2";
   };
 
   NIX_CFLAGS_COMPILE = "-fPIC";

pkgs/development/libraries/gloox/default.nix

···
 assert idnSupport -> libidn != null;
 
 let
-  version = "1.0.13";
+  version = "1.0.14";
 in
 stdenv.mkDerivation rec {
   name = "gloox-${version}";
 
   src = fetchurl {
     url = "http://camaya.net/download/gloox-${version}.tar.bz2";
-    sha256 = "12payqyx1ly8nm3qn24bj0kyy9d08sixnjqxw7fn6rbwr7m1x7sd";
+    sha256 = "0h9r4382qv0vqc91x1qz1nivxw1r2l874s1kl0bskzm9dyk742sj";
   };
 
   buildInputs = [ ]

pkgs/development/libraries/libpsl/default.nix

···
 { stdenv, fetchFromGitHub, autoreconfHook, docbook_xsl, gtk_doc, icu
-, libxslt, pkgconfig }:
+, libxslt, pkgconfig, python }:
 
 let
 
···
     owner = "publicsuffix";
   };
 
-  libVersion = "0.11.0";
+  libVersion = "0.12.0";
 
 in stdenv.mkDerivation {
   name = "libpsl-${version}";
 
   src = fetchFromGitHub {
-    sha256 = "08k7prrr83lg6jmm5r5k4alpm2in4qlnx49ypb4bxv16lq8dcnmm";
+    sha256 = "13w3lc752az2swymg408f3w2lbqs0f2h5ri6d5jw1vv9z0ij9xlw";
     rev = "libpsl-${libVersion}";
     repo = "libpsl";
     owner = "rockdaboot";
   };
 
   buildInputs = [ icu libxslt ];
-  nativeBuildInputs = [ autoreconfHook docbook_xsl gtk_doc pkgconfig ];
+  nativeBuildInputs = [ autoreconfHook docbook_xsl gtk_doc pkgconfig python ];
 
   postPatch = ''
     substituteInPlace src/psl.c --replace bits/stat.h sys/stat.h
+    patchShebangs src/make_dafsa.py
   '';
 
   preAutoreconf = ''
···
     # The libpsl check phase requires the list's test scripts (tests/) as well
     cp -Rv "${listSources}"/* list
   '';
-  configureFlags = [ "--disable-static" "--enable-gtk-doc" "--enable-man" ];
+  configureFlags = [
+    "--disable-builtin"
+    "--disable-static"
+    "--enable-gtk-doc"
+    "--enable-man"
+  ];
 
   enableParallelBuilding = true;
 

pkgs/development/libraries/libvirt/build-on-bsd.patch

···
+diff -Naur libvirt-1.3.0.orig/src/admin/admin_protocol.c libvirt-1.3.0/src/admin/admin_protocol.c
+--- libvirt-1.3.0.orig/src/admin/admin_protocol.c	2015-12-02 16:17:07.000000000 +0100
++++ libvirt-1.3.0/src/admin/admin_protocol.c	2016-01-04 17:57:10.043412857 +0100
+@@ -6,6 +6,25 @@
+ 
+ #include "admin_protocol.h"
+ 
++/* cygwin's xdr implementation defines xdr_u_int64_t instead of xdr_uint64_t
++ * and lacks IXDR_PUT_INT32 and IXDR_GET_INT32
++ */
++#ifdef HAVE_XDR_U_INT64_T
++# define xdr_uint64_t xdr_u_int64_t
++#endif
++#ifndef IXDR_PUT_INT32
++# define IXDR_PUT_INT32 IXDR_PUT_LONG
++#endif
++#ifndef IXDR_GET_INT32
++# define IXDR_GET_INT32 IXDR_GET_LONG
++#endif
++#ifndef IXDR_PUT_U_INT32
++# define IXDR_PUT_U_INT32 IXDR_PUT_U_LONG
++#endif
++#ifndef IXDR_GET_U_INT32
++# define IXDR_GET_U_INT32 IXDR_GET_U_LONG
++#endif
++
+ bool_t
+ xdr_admin_nonnull_string (XDR *xdrs, admin_nonnull_string *objp)
+ {
+diff -Naur libvirt-1.3.0.orig/src/logging/log_protocol.c libvirt-1.3.0/src/logging/log_protocol.c
+--- libvirt-1.3.0.orig/src/logging/log_protocol.c	2015-12-08 13:07:35.000000000 +0100
++++ libvirt-1.3.0/src/logging/log_protocol.c	2016-01-04 17:56:50.673463563 +0100
+@@ -7,6 +7,25 @@
+ #include "log_protocol.h"
+ #include "internal.h"
+ 
++/* cygwin's xdr implementation defines xdr_u_int64_t instead of xdr_uint64_t
++ * and lacks IXDR_PUT_INT32 and IXDR_GET_INT32
++ */
++#ifdef HAVE_XDR_U_INT64_T
++# define xdr_uint64_t xdr_u_int64_t
++#endif
++#ifndef IXDR_PUT_INT32
++# define IXDR_PUT_INT32 IXDR_PUT_LONG
++#endif
++#ifndef IXDR_GET_INT32
++# define IXDR_GET_INT32 IXDR_GET_LONG
++#endif
++#ifndef IXDR_PUT_U_INT32
++# define IXDR_PUT_U_INT32 IXDR_PUT_U_LONG
++#endif
++#ifndef IXDR_GET_U_INT32
++# define IXDR_GET_U_INT32 IXDR_GET_U_LONG
++#endif
++
+ bool_t
+ xdr_virLogManagerProtocolUUID (XDR *xdrs, virLogManagerProtocolUUID objp)
+ {

pkgs/development/libraries/libvirt/default.nix

···
-{ stdenv, fetchurl, pkgconfig, libxml2, gnutls, devicemapper, perl, python
+{ stdenv, fetchurl, fetchpatch
+, pkgconfig, makeWrapper
+, libxml2, gnutls, devicemapper, perl, python
 , iproute, iptables, readline, lvm2, utillinux, udev, libpciaccess, gettext
-, libtasn1, ebtables, libgcrypt, yajl, makeWrapper, pmutils, libcap_ng
+, libtasn1, ebtables, libgcrypt, yajl, pmutils, libcap_ng
 , dnsmasq, libnl, libpcap, libxslt, xhtml1, numad, numactl, perlPackages
 , curl, libiconv, gmp, xen
 }:
 
 stdenv.mkDerivation rec {
   name = "libvirt-${version}";
-  version = "1.2.19";
+  version = "1.3.0";
 
   src = fetchurl {
     url = "http://libvirt.org/sources/${name}.tar.gz";
-    sha256 = "0vnxmqf04frrj18lrvq7wc70wh179d382py14006879k0cgi8b18";
+    sha256 = "ebcf5645fa565e3fe2fe94a86e841db9b768cf0e0a7e6cf395c6327f9a23bd64";
   };
 
+  patches = [ ./build-on-bsd.patch ];
+
+  nativeBuildInputs = [ makeWrapper pkgconfig ];
   buildInputs = [
-    pkgconfig libxml2 gnutls perl python readline
-    gettext libtasn1 libgcrypt yajl makeWrapper
+    libxml2 gnutls perl python readline
+    gettext libtasn1 libgcrypt yajl
     libxslt xhtml1 perlPackages.XMLXPath curl libpcap
   ] ++ stdenv.lib.optionals stdenv.isLinux [
     libpciaccess devicemapper lvm2 utillinux udev libcap_ng

pkgs/development/libraries/policykit/default.nix

···
-{ stdenv, fetchurl, pkgconfig, glib, dbus, dbus_glib, expat, pam
-, intltool, gettext, libxslt, docbook_xsl }:
-
-stdenv.mkDerivation rec {
-  name = "policykit-0.9";
-  
-  src = fetchurl {
-    url = http://hal.freedesktop.org/releases/PolicyKit-0.9.tar.gz;
-    sha256 = "1dw05s4xqj67i3c13knzl04l8jap0kywzpav6fidpmqrximpq37l";
-  };
-  
-  buildInputs =
-    [ pkgconfig glib dbus_glib pam intltool gettext libxslt ];
-
-  propagatedBuildInputs = [ expat dbus.libs ];
-
-  configureFlags = "--localstatedir=/var --sysconfdir=/etc";
-
-  installFlags = "localstatedir=$(TMPDIR)/var sysconfdir=$(out)/etc"; # keep `make install' happy
-
-  # Read policy files from /etc/PolicyKit/policy instead of
-  # /usr/share/PolicyKit/policy.  Using PACKAGE_DATA_DIR is hacky, but
-  # it works because it's only used in the C code for finding the
-  # policy directory.
-  NIX_CFLAGS_COMPILE = "-DPACKAGE_DATA_DIR=\"/etc\"";
-
-  # Needed to build the manpages.
-  XML_CATALOG_FILES = "${docbook_xsl}/xml/xsl/docbook/catalog.xml";
-  
-  meta = {
-    homepage = http://www.freedesktop.org/wiki/Software/PolicyKit;
-    description = "A toolkit for defining and handling the policy that allows unprivileged processes to speak to privileged processes (obsolete)";
-    platforms = stdenv.lib.platforms.linux;
-  };
-}

pkgs/development/libraries/qmltermwidget/default.nix

···
 
   patchPhase = ''
     substituteInPlace qmltermwidget.pro \
-      --replace '$$[QT_INSTALL_QML]' "/lib/qml/"
+      --replace '$$[QT_INSTALL_QML]' "/lib/qt5/qml/"
   '';
 
   configurePhase = "qmake PREFIX=$out";

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

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  version = "6.13";
+  version = "6.14.1";
   name = "checkstyle-${version}";
 
   src = fetchurl {
     url = "mirror://sourceforge/checkstyle/${name}-bin.tar.gz";
-    sha256 = "0k53kj0mx0shypagny134yrhkjgawzs5yixaxv87br52ablcqdvx";
+    sha256 = "1dcg7libqs797v6x5vdvvc44rqfvwcjh125wczy9v87nl8imc2l3";
   };
 
   installPhase = ''

pkgs/development/tools/build-managers/gnustep/make/default.nix

···
 { stdenv, fetchurl }:
 
+let version = "2.6.7"; in
 stdenv.mkDerivation rec {
   name = "gnustep-make-${version}";
-  version = "1.0";
 
   src = fetchurl {
-    url = "http://ftpmain.gnustep.org/pub/gnustep/core/gnustep-make-2.6.6.tar.gz";
-    sha256 = "07cqr8x17bia9w6clbmiv7ay6r9nplrjz2cyzinv4w7zfpc19vxw";
+    url = "http://ftpmain.gnustep.org/pub/gnustep/core/${name}.tar.gz";
+    sha256 = "1r2is23xdg4qirckb6bd4lynfwnnw5d9522wib3ndk1xgirmfaqi";
   };
 
   patchPhase = ''
     substituteInPlace GNUmakefile.in \
-      --replace which type \
-      --replace 'tooldir = $(DESTDIR)' 'tooldir = ' \
-      --replace 'makedir = $(DESTDIR)' 'makedir = ' \
-      --replace 'mandir  = $(DESTDIR)' 'mandir  = '
+      --replace which type
 
     substituteInPlace FilesystemLayouts/apple \
       --replace /usr/local ""
+
+    substituteInPlace configure \
+      --replace /Library/GNUstep "$out"
   '';
 
-  installFlags = "DESTDIR=$(out)";
+  installFlags = [ "PREFIX=$(out)" ];
 
   postInstall = ''
     mkdir -p $out/nix-support

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

···
-{ stdenv, fetchurl, runCommand, gcc, zlib }:
+{ stdenv, fetchurl, fetchpatch, runCommand, gcc, zlib }:
 
 let
   name = "ccache-${version}";
···
     inherit sha256;
     url = "mirror://samba/ccache/${name}.tar.xz";
   };
+
+  patches = [
+    (fetchpatch {
+      sha256 = "1gwnxx1w2nx1szi0v5vgwcx9i23pxygkqqnrawhal68qgz5c34wh";
+      name = "dont-update-manifest-in-readonly-modes.patch";
+      # The primary git.samba.org doesn't seem to like our curl much...
+      url = "https://github.com/jrosdahl/ccache/commit/a7ab503f07e31ebeaaec34fbaa30e264308a299d.patch";
+    })
+  ];
 
   buildInputs = [ zlib ];
 

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

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "global-6.5.1";
+  name = "global-6.5.2";
 
   src = fetchurl {
     url = "mirror://gnu/global/${name}.tar.gz";
-    sha256 = "1y34nbazsw2p6r2jhv27z15qvm9mhy5xjchpz8pwps00shkm578f";
+    sha256 = "07qx3dbjwkbd1dn42qs7zgj77rxdj2psfrf7bx7yx9al38f87z60";
   };
 
   nativeBuildInputs = [ libtool makeWrapper ];

pkgs/development/tools/ocaml/omake/default.nix

···
   name = "${pname}-${version}";
 
   src = fetchurl {
-    url = "${webpage}/downloads/${pname}-${version}.tar.gz";
+    url = "mirror://debian/pool/main/o/omake/omake_${version}.orig.tar.gz";
     sha256 = "1bfxbsimfivq0ar2g5fkzvr5ql97n5dg562pfyd29y4zyh4mwrsv";
   };
   patchFlags = "-p0";

pkgs/games/simutrans/default.nix

···
   );
 
   ver1 = "120";
-  ver2 = "0";
+  ver2 = "1";
   ver3 = "1";
   version =   "${ver1}.${ver2}.${ver3}";
   ver_dash =  "${ver1}-${ver2}-${ver3}";
···
 
   binary_src = fetchurl {
     url = "mirror://sourceforge/simutrans/simutrans/${ver_dash}/simutrans-src-${ver_dash}.zip";
-    sha256 = "10rn259nxq2hhfpar8zwgxi1p4djvyygcm2f6qhih7l9clvnw2h1";
+    sha256 = "00cyxbn17r9p1f08jvx1wrhydxknkrxj5wk6ld912yicfql998r0";
   };
 
 
···
     (pakName: attrs: mkPak (attrs // {inherit pakName;}))
   {
     pak64 = {
-      srcPath = "${ver2_dash}/simupak64-${ver_dash}";
+      # No release for 120.1 yet!
+      srcPath = "120-0/simupak64-120-0-1";
       sha256 = "0y5v1ncpjyhjkkznqmk13kg5d0slhjbbvg1y8q5jxhmhlkghk9q2";
     };
     "pak64.japan" = {
-      srcPath = "${ver2_dash}/simupak64.japan-${ver_dash}";
+      # No release for 120.1 yet!
+      srcPath = "120-0/simupak64.japan-120-0-1";
       sha256 = "14swy3h4ij74bgaw7scyvmivfb5fmp21nixmhlpk3mav3wr3167i";
     };
 
     pak128 = {
-      srcPath = "pak128%20for%20ST%20120%20%282.5.2%2B%20nightly%20r1560%2C%20bugfixes%29/pak128-r1560--ST120";
-      sha256 = "1wd51brc4aglqi3w7s8fxgxrw0k7f653w4wbnmk83k07fwfdyf24";
+      srcPath = "pak128%20for%20ST%20120%20%282.5.3%2C%20minor%20changes%29/pak128-2.5.3--ST120";
+      sha256 = "19c66wvfg6rn7s9awi99cfp83hs9d8dmsjlmgn8m91a19fp9isdh";
     };
     "pak128.britain" = {
-      srcPath = "pak128.Britain%20for%20${ver2_dash}/pak128.Britain.1.16-${ver2_dash}";
-      sha256 = "1rww9rnpk22l2z3s1d7y2gmd6iwhv72s7pff8krnh7z0q386waak";
+      srcPath = "pak128.Britain%20for%20${ver2_dash}/pak128.Britain.1.17-${ver2_dash}";
+      sha256 = "1nviwqizvch9n3n826nmmi7c707dxv0727m7lhc1n2zsrrxcxlr5";
     };
     "pak128.cs" = { # note: it needs pak128 to work
       url = "mirror://sourceforge/simutrans/Pak128.CS/pak128.cz_v.0.2.1.zip";
···
     };
     "pak128.german" = {
       url = "mirror://sourceforge/simutrans/PAK128.german/"
-        + "PAK128.german_0.7_${ver1}.x/PAK128.german_0.7.0.1_${ver1}.x.zip";
-      sha256 = "1575akms18raxaijy2kfyqm07wdx6y5q85n7wgvq2fqydrnx33w8";
+        + "PAK128.german_0.8_${ver1}.x/PAK128.german_0.8.0_${ver1}.x.zip";
+      sha256 = "1a8pc88vi59zlvff9i1f8nphdmisqmgg03qkdvrf5ks46aw8j6s5";
     };
 
     /* This release contains accented filenames that prevent unzipping.
···
     stdenv.mkDerivation {
       name = "simutrans-${pakName}";
       unpackPhase = "true";
+      preferLocalBuild = true;
       installPhase = let src = fetchurl { inherit url sha256; };
       in ''
         mkdir -p "$out/share/simutrans/${pakName}"
···
 
       homepage = http://www.simutrans.com/;
       license = with licenses; [ artistic1 gpl1Plus ];
-      maintainers = with maintainers; [ kkallio vcunat ];
+      maintainers = with maintainers; [ kkallio vcunat phile314 ];
       platforms = with platforms; linux ++ darwin;
     };
   };

pkgs/misc/cups/cups-pk-helper.nix

···
+{ stdenv, fetchurl, intltool, pkgconfig, glib, polkit, cups }:
+
+stdenv.mkDerivation rec {
+  version = "0.2.5";
+  name = "cups-pk-helper-${version}";
+
+  src = fetchurl {
+    url = "http://www.freedesktop.org/software/cups-pk-helper/releases/cups-pk-helper-${version}.tar.xz";
+    sha256 = "0651ij5p5s0n3xxbaqsy72s22nx9hfkrjgvg766lkqd1cpniw8hr";
+  };
+
+  buildInputs = [ intltool pkgconfig glib polkit cups ];
+
+  meta = with stdenv.lib; {
+    description = "PolicyKit helper to configure cups with fine-grained privileges";
+    homepage = http://www.freedesktop.org/wiki/Software/cups-pk-helper/;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.bjornfor ];
+  };
+}

pkgs/misc/cups/drivers/cups-bjnp/default.nix

···
   NIX_CFLAGS_COMPILE = "-include stdio.h";
 
   meta = {
+    description = "CUPS back-end for Canon printers";
+    longDescription = ''
+      CUPS back-end for the canon printers using the proprietary USB over IP
+      BJNP protocol. This back-end allows Cups to print over the network to a
+      Canon printer. The design is based on reverse engineering of the protocol.
+    '';
     homepage = http://cups-bjnp.sourceforge.net;
   };
 }

pkgs/misc/drivers/hplip/3.15.9.nix

···
 { stdenv, fetchurl, substituteAll
 , pkgconfig
-, cups, zlib, libjpeg, libusb1, pythonPackages, saneBackends, dbus, usbutils
+, cups, zlib, libjpeg, libusb1, pythonPackages, sane-backends, dbus, usbutils
 , net_snmp, polkit
 , qtSupport ? true, qt4, pyqt4
 , withPlugin ? false
···
     libusb1
     pythonPackages.python
     pythonPackages.wrapPython
-    saneBackends
+    sane-backends
     dbus
     net_snmp
   ] ++ stdenv.lib.optionals qtSupport [

pkgs/misc/drivers/hplip/default.nix

···
 { stdenv, fetchurl, substituteAll
 , pkgconfig
-, cups, zlib, libjpeg, libusb1, pythonPackages, saneBackends, dbus, usbutils
+, cups, zlib, libjpeg, libusb1, pythonPackages, sane-backends, dbus, usbutils
 , net_snmp, polkit
 , qtSupport ? true, qt4, pyqt4
 , withPlugin ? false
···
     libusb1
     pythonPackages.python
     pythonPackages.wrapPython
-    saneBackends
+    sane-backends
     dbus
     net_snmp
   ] ++ stdenv.lib.optionals qtSupport [

pkgs/misc/emulators/wine/base.nix

···
 { stdenv, lib, pkgArches,
   name, version, src, monos, geckos, platforms,
+  pulseaudioSupport,
   buildScript ? null, configureFlags ? ""
 }:
 
···
 
   nativeBuildInputs = toBuildInputs pkgArches (pkgs: (with pkgs; [
     freetype fontconfig mesa mesa_noglu.osmesa libdrm libpng libjpeg openssl gnutls cups ncurses
-  ]) ++ (with pkgs.xorg; [
+  ])
+  ++ lib.optional pulseaudioSupport pkgs.libpulseaudio
+  ++ (with pkgs.xorg; [
     xlibsWrapper libXi libXcursor libXinerama libXrandr libXrender libXxf86vm libXcomposite
   ]));
 

pkgs/misc/emulators/wine/default.nix

···
 { lib, pkgs, system, callPackage,
   wineRelease ? "stable",
   wineBuild ? (if system == "x86_64-linux" then "wineWow" else "wine32"),
+  pulseaudioSupport ? false,
   libtxc_dxtn_Name ? "libtxc_dxtn_s2tc" }:
 
 let wine-build = build: release:
       lib.getAttr build (callPackage ./packages.nix {
         wineRelease = release;
+        inherit pulseaudioSupport;
       });
 
 in if wineRelease == "staging" then

pkgs/misc/emulators/wine/packages.nix

···
 { system, stdenv, stdenv_32bit, lib, pkgs, pkgsi686Linux, fetchurl,
+  pulseaudioSupport,
   wineRelease ? "stable"
 }:
 
···
     name = "wine-${version}";
     inherit (sources) version src;
     inherit (pkgsi686Linux) lib stdenv;
+    inherit pulseaudioSupport;
     pkgArches = [ pkgsi686Linux ];
     geckos = with sources; [ wineGecko32 ];
     monos = with sources; [ wineMono ];
···
     name = "wine64-${version}";
     inherit (sources) version src;
     inherit lib stdenv;
+    inherit pulseaudioSupport;
     pkgArches = [ pkgs ];
     geckos = with sources; [ wineGecko64 ];
     monos = with sources; [ wineMono ];
···
     inherit (sources) version src;
     inherit lib;
     stdenv = stdenv_32bit;
+    inherit pulseaudioSupport;
     pkgArches = [ pkgs pkgsi686Linux ];
     geckos = with sources; [ wineGecko32 wineGecko64 ];
     monos = with sources; [ wineMono ];

pkgs/misc/emulators/wine/staging.nix

···
 in assert (builtins.parseDrvName wineUnstable.name).version == version;
 
 stdenv.lib.overrideDerivation wineUnstable (self: {
-  nativeBuildInputs = build-inputs [ "libpulseaudio" libtxc_dxtn_Name ] self.nativeBuildInputs; 
+  nativeBuildInputs = build-inputs [ libtxc_dxtn_Name ] self.nativeBuildInputs; 
   buildInputs = build-inputs [ "perl" "utillinux" "autoconf" ] self.buildInputs;
 
   name = "${self.name}-staging";

pkgs/misc/vim-plugins/default.nix

···
   };
 
   Hoogle = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "Hoogle-2015-11-27";
+    name = "Hoogle-2015-12-24";
     src = fetchgit {
       url = "git://github.com/Twinside/vim-hoogle";
-      rev = "f0deb22baad592329b158217143f8b324548b4bd";
-      sha256 = "e98b9b729b8c7dfcf34ccd36940e4d855975580864cf36f5e4bb88336fd1e263";
+      rev = "a5db36f048ac16ab9774fc86f36cd4ae9a444932";
+      sha256 = "31cb37f9fa38e15a52bc35c050e173afc2af5fe8b3d6e5f2026cd5a89bb1a5a0";
     };
     dependencies = [];
 
···
   };
 
   Syntastic = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "Syntastic-2015-12-10";
+    name = "Syntastic-2016-01-04";
     src = fetchgit {
       url = "git://github.com/scrooloose/syntastic";
-      rev = "48736aa376341518d7bedf3a39daf0ae9e1dcdc0";
-      sha256 = "2a523c7d54b5afee1eda6073c71ffcea7ba60e5240d91ea235f007ad89fb8e55";
+      rev = "3280220e6c612d03a451d7ee0624893093dcb87b";
+      sha256 = "6d066843aeacd9534df5b67c64bb4efd7afb1aaea9024f6dfb74a312a73c8bad";
     };
     dependencies = [];
 
···
   };
 
   UltiSnips = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "UltiSnips-2015-12-09";
+    name = "UltiSnips-2015-12-22";
     src = fetchgit {
       url = "git://github.com/SirVer/ultisnips";
-      rev = "5a2dcc5cbfa4c1e4a981d57544eb51fc5baeecea";
-      sha256 = "dd9b087b7a08b75a60f104cf734b604f8823a219b76531694b4957fce6a2a8d5";
+      rev = "dbd43ad27cbfed14c9dc3de6d5acb5f4edb8f649";
+      sha256 = "3a1c59ae4097e72c91724157249d6a578e7ef2b10ed675e4372ce9968d66af66";
     };
     dependencies = [];
 
···
   };
 
   ctrlp-py-matcher = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "ctrlp-py-matcher-2015-07-18";
+    name = "ctrlp-py-matcher-2015-12-22";
     src = fetchgit {
       url = "git://github.com/FelikZ/ctrlp-py-matcher";
-      rev = "9e84cf8072866b92faf5082cb93a554b75e35fd0";
-      sha256 = "7d4d5f7da148ddc9c8956aca87f53d9d0ff458b8fb4bc4ab2a9bff2ee6026cde";
+      rev = "08b98ff7ba5191616fa4f099a63cdcbad70a0c0f";
+      sha256 = "72514b65e12dfa249e51d676d38ff88933309827ef0ece71f3a90a21b4a943e6";
     };
     dependencies = [];
 
···
   };
 
   fugitive = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "fugitive-2015-12-15";
+    name = "fugitive-2015-12-26";
     src = fetchgit {
       url = "git://github.com/tpope/vim-fugitive";
-      rev = "8851b8fe643517af160f59dfc3d88a0c4eed1fa5";
-      sha256 = "bba527606ab63cc6cce24ca1b44226aa37aced7f1aac4c352a6b83ce522c4b5f";
+      rev = "18d6d1ab82d9ac15586d7d3c1a36f9ef6fb50eae";
+      sha256 = "f448970d07eaf35c0a6d29634ee2114650934943602da8f2bf5a4e3920d62aa2";
     };
     dependencies = [];
 
···
   };
 
   neomake = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "neomake-2015-12-11";
+    name = "neomake-2015-12-31";
     src = fetchgit {
       url = "git://github.com/benekastah/neomake";
-      rev = "d4c0a6f062a0d098126e87bb718b92fe7b79fd97";
-      sha256 = "1b2f1e024ffdfe0613c0aeb4c6fc64d64c6a25a00841538b7a371efd34cb8615";
+      rev = "6342a7d7e09083a549800a3cdc0ef95358a73ba7";
+      sha256 = "b7d3637b8575ae94dc0e68c4e5fcc41197b3083d1d7302c2e038431a24a3e9d7";
     };
     dependencies = [];
 
···
   };
 
   ctrlp-vim = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "ctrlp-vim-2015-11-30";
+    name = "ctrlp-vim-2015-12-30";
     src = fetchgit {
       url = "git://github.com/ctrlpvim/ctrlp.vim";
-      rev = "7a80267ed061f3dc30bb319f438bdadfd8c7b1fd";
-      sha256 = "ae29eb79ca32ca0edd32602cf6b1e1276ccd4f5086ac4297a7f0dea2dd2e1f1b";
+      rev = "97490deda3326182281133454b8813850db4c444";
+      sha256 = "1671dffe85dfc2655c06784b783b08f8553f5b90e04b7e9a861d7054c695adbc";
     };
     dependencies = [];
 
   };
 
   vim-jade = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "vim-jade-2015-11-23";
+    name = "vim-jade-2016-01-03";
     src = fetchgit {
       url = "git://github.com/digitaltoad/vim-jade";
-      rev = "f760e239386df055eb1892243624fdf7f7c58392";
-      sha256 = "812e65090e6a1c31f433878fd1012673a8244d8b6974b1c2ffd1558c30c716cc";
+      rev = "999cd2859a7772de707a70afc97f5a7d41a82df9";
+      sha256 = "039c1e9b91ac6417c2f38e8b30647115b10ad5485e78782a84100f22ae2da1d8";
     };
     dependencies = [];
 
···
   };
 
   vim-go = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "vim-go-2015-12-15";
+    name = "vim-go-2016-01-03";
     src = fetchgit {
       url = "git://github.com/fatih/vim-go";
-      rev = "70c363044df808e34d947815d01a37d4e7564421";
-      sha256 = "9f1764a5e8c7450c4af9fc64b3170e10d89c4d6b4ad69a758878bed16362cf09";
+      rev = "b26351b55a7a44e29f1bde3b82ead43a6980760d";
+      sha256 = "57cc4240de5ea185c645c37a0fc51f0b352ad7d2798124f58786ed95579d1bc3";
     };
     dependencies = [];
 
···
   };
 
   vimtex = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "vimtex-2015-12-16";
+    name = "vimtex-2016-01-03";
     src = fetchgit {
       url = "git://github.com/lervag/vimtex";
-      rev = "e982722e89462716e2ecdb6ce7aa9baea6dc8c98";
-      sha256 = "4c0e8399b97cbd24b0131c3e22fc8873d04576e21156b80e5c678b4ce3d19fe0";
+      rev = "2de4129abd6b7e441d625403ff420734452ed112";
+      sha256 = "0f7a69cd48c6cd6ff9981ec3e4e6bc678491d2b42cf80a274464c0cb762f3397";
     };
     dependencies = [];
 
   };
 
   vim-easymotion = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "vim-easymotion-2015-10-27";
+    name = "vim-easymotion-2016-01-03";
     src = fetchgit {
       url = "git://github.com/lokaltog/vim-easymotion";
-      rev = "a21d4474f0e9df7a721246e0a3b386068901965f";
-      sha256 = "96bb705e9ff626b139a7f92906468eda63d743b8457a1dc1e4de9c3cf9486525";
+      rev = "39abbf30a7bfc16de139b52ce0d7d2a286da52a8";
+      sha256 = "5c0be765c2fdb95c632020e0d03a70a2683a9d8f5b2d934be94b89cdb9bbd089";
     };
     dependencies = [];
 
···
   };
 
   vim-startify = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "vim-startify-2015-12-11";
+    name = "vim-startify-2015-12-28";
     src = fetchgit {
       url = "git://github.com/mhinz/vim-startify";
-      rev = "295fe7a09a881448eea1aa71d26f53dcda3c499b";
-      sha256 = "a561488ae8870364f822a93ef18d35511b4dd7e779fd18e365851e8d216df61e";
+      rev = "84fb86e5dab808dd99f10565f1aac066292a1289";
+      sha256 = "bb05abdd59e38dcb1985438ddfad7cd23f514a6bc2fe84b5e114872e1ca82dc0";
     };
     dependencies = [];
 
···
   };
 
   vim-watchdogs = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "vim-watchdogs-2015-07-29";
+    name = "vim-watchdogs-2015-12-27";
     src = fetchgit {
       url = "git://github.com/osyo-manga/vim-watchdogs";
-      rev = "e1fce3b4bbe07d55bd7340d25ca0dc900747ad6f";
-      sha256 = "72ec214364c674ee1ccd29a6dae925e6cbcaf90e57fef133385a96319108dd2c";
+      rev = "52842b03ab0c2e60563ff121d274f8a66ca7e0fc";
+      sha256 = "bbf304319a40e755d47afbe0f172ad47aea35f5253669e5da60d8bd717b67070";
     };
     dependencies = [];
 
   };
 
   racer = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "racer-2015-12-11";
+    name = "racer-2016-01-02";
     src = fetchgit {
       url = "git://github.com/phildawes/racer";
-      rev = "ce1915a6fd76f76433f30cfaf1fe1b2a8e21cdd4";
-      sha256 = "24d48cbf6d69e397cd7a9925c42e2a10fb8c9dc4a0ef8b9122894847224fd735";
+      rev = "c94a17f844c13d2f115a53013c0f9e063bc31f23";
+      sha256 = "fc42c224fbe12459e17c941ab6d084c838f11b1aabec55eaeebf617df2037124";
     };
     dependencies = [];
     buildPhase = ''
···
   };
 
   neocomplete-vim = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "neocomplete-vim-2015-12-13";
+    name = "neocomplete-vim-2016-01-03";
     src = fetchgit {
       url = "git://github.com/shougo/neocomplete.vim";
-      rev = "d1cb4c57e5eb8b453b63432dcbcb45a15c0fd07e";
-      sha256 = "a704696e66101875e98a1b2b6815acad647b87a07a3842fd6f9f91b8a70411e5";
+      rev = "4c108ddadcf44c83c2ee38e5ac0dc8b0b31ed9a8";
+      sha256 = "b112cfac177c142f09e4904f9d1b30ca402ed7642f0a4f8f003808dd804df52a";
     };
     dependencies = [];
 
   };
 
   neosnippet-snippets = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "neosnippet-snippets-2015-12-13";
+    name = "neosnippet-snippets-2016-01-04";
     src = fetchgit {
       url = "git://github.com/shougo/neosnippet-snippets";
-      rev = "ec9267240ecb855657de830c9c68e5f6e34cfe65";
-      sha256 = "319a7ac504b462f7e466c9e02ff6e54b8374e5970f148552986c83136c423854";
+      rev = "1c6dacb99fcbeb186646ecafda3f07e07484b326";
+      sha256 = "fd834aa6d612f124d9d443d1ac11a0749d4df18f012de0c3729de2ecc3cbead5";
     };
     dependencies = [];
 
   };
 
   neosnippet-vim = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "neosnippet-vim-2015-12-16";
+    name = "neosnippet-vim-2016-01-04";
     src = fetchgit {
       url = "git://github.com/shougo/neosnippet.vim";
-      rev = "cfc99eedb5caf3d6baf867db5220a891b4686699";
-      sha256 = "aa34c6e28eb281bec6e617f03eb5e094cd2cfe18951f9e4823dda0ccdabaffad";
+      rev = "ac6ac62a5bf259f2db5aaf0751b919b377d1a9b2";
+      sha256 = "e9eaf68211965a71619bd3ff477982af7eccc30e6cb430a8fbf553469b22c127";
     };
     dependencies = [];
 
   };
 
   unite-vim = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "unite-vim-2015-12-13";
+    name = "unite-vim-2015-12-29";
     src = fetchgit {
       url = "git://github.com/shougo/unite.vim";
-      rev = "aefd6c32ef8dc5b357efe7d8e5cd3dd4aa785d5c";
-      sha256 = "83562a15afc1c41a5d407fd0eb7d26beec216a9431dd80992bcd615afd595e5e";
+      rev = "da791c335135fbd460caa8c8e4671e324ef1f328";
+      sha256 = "93a892a9acfcf47953e234b69f80249cc2c1d7cc6d097f173cf6f721fd59068f";
     };
     dependencies = [];
 
···
   };
 
   vimshell-vim = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "vimshell-vim-2015-11-24";
+    name = "vimshell-vim-2015-12-23";
     src = fetchgit {
       url = "git://github.com/shougo/vimshell.vim";
-      rev = "7931e3bf9fbba738b26bb76143dfc1df17f7a99b";
-      sha256 = "f51ee4e8b16460226ce74d87236834f13008dca16dbc9090d89576a545f573bc";
+      rev = "a5b3d99ba84e76cf94195c37ab762aef5f7b6e25";
+      sha256 = "9a58b00cca9b2cf7ef73cdef2174ab69b7fb427130e5b125b96c6b385dec1947";
     };
     dependencies = [ "vimproc-vim" ];
   };
···
   };
 
   vim-quickrun = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "vim-quickrun-2015-12-17";
+    name = "vim-quickrun-2015-12-28";
     src = fetchgit {
       url = "git://github.com/thinca/vim-quickrun";
-      rev = "97e1c8f6674d3ccce4730510d67c4e15894adcdc";
-      sha256 = "c61167569d5b05767fdaffc1b09aab729c777d01afaff8c0efd641a61ebe758c";
+      rev = "da5328d0aec495e4dc25232fd769a8a2e56d8f7d";
+      sha256 = "a70e2ffa05a2cc2306483e3ecc09972bcdf2d11bfafcfbf3f8195e23475e7102";
     };
     dependencies = [];
 
···
   };
 
   youcompleteme = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "youcompleteme-2015-12-13";
+    name = "youcompleteme-2016-01-01";
     src = fetchgit {
       url = "git://github.com/valloric/youcompleteme";
-      rev = "93c2a8644bcfc84590bea5e19eab350fe245e504";
-      sha256 = "32aaa99c5398d65875c1fdf5ed22f58aeeb267a2840930479523815b94b4111c";
+      rev = "07f4402f49a6cb987ebb17a4c17790816e06c3e7";
+      sha256 = "cf801f2efe00b20244520cc0806c050b56d768d3826ea4143dc0ac658c6019ba";
     };
     dependencies = [];
     buildInputs = [
···
   };
 
   vim-wakatime = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "vim-wakatime-2015-12-01";
+    name = "vim-wakatime-2015-12-29";
     src = fetchgit {
       url = "git://github.com/wakatime/vim-wakatime";
-      rev = "2b758403d8637cacbab1de603258c611408b9fa7";
-      sha256 = "e3a3da2dd40c4098b18815ca12d83ad1789f5342a8d822669a29e9900600e6ff";
+      rev = "6cf829f08d72ffe56a794a2e4ada5689e7d68237";
+      sha256 = "4913a63dd238bb14c04043e492b3d9f283ea821db86fad559b88ac9f65cf87d8";
     };
     dependencies = [];
     buildInputs = [ python ];
   };
 
   command-t = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "command-t-2015-04-29";
+    name = "command-t-2016-01-01";
     src = fetchgit {
       url = "git://github.com/wincent/command-t";
-      rev = "f7344ebbe95c532b2ad01f19877d6d611db0193b";
-      sha256 = "21d7ee2bbff3f79ec3c81bcf683acac6528ea89faef8b7dd075cc83662930a50";
+      rev = "978c0a6bbd8a318023a19787f95cc2041c614db6";
+      sha256 = "954bf0285ec37e975b227d3a1e80165fc52be673d9c5e510265dc911e06ff066";
     };
     dependencies = [];
     buildInputs = [ perl ruby ];
···
   };
 
   pathogen = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "pathogen-2015-09-20";
+    name = "pathogen-2015-12-25";
     src = fetchgit {
       url = "git://github.com/tpope/vim-pathogen";
-      rev = "b4174e4d1a16e7f0c5c6dfca923269a20a9f50c2";
-      sha256 = "703a1d3022cdb03d3d14fbba48be119f4bd7d546ba4bd33185bddaa161bbc63e";
+      rev = "4d584ea8c85408ca0d68b7b1693f3e2db8aa762a";
+      sha256 = "1a1b5e650aa5ff107ce68fecf4d9a57cafc2c15ab74686c5ea3c5985de07470d";
     };
     dependencies = [];
 
···
   };
 
   sensible = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "sensible-2015-12-11";
+    name = "sensible-2015-12-26";
     src = fetchgit {
       url = "git://github.com/tpope/vim-sensible";
-      rev = "8c4429c70c186f9be47121b126c13095793062a1";
-      sha256 = "f3b5de776ae4fa2c8769f2f04639d2a0218c88345beba9364899d359d32cf6e5";
+      rev = "680a5c693213daa158c816f068fffa895d961dc9";
+      sha256 = "959b55a97974d85374eccb58379c3f69c0ec43459d4df2484e42a437c61e34bc";
     };
     dependencies = [];
 
···
   };
 
   vim-airline = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "vim-airline-2015-10-18";
+    name = "vim-airline-2015-12-28";
     src = fetchgit {
       url = "git://github.com/bling/vim-airline";
-      rev = "14d14cf951c08fc88ca6c3e6f28fe47b99421e23";
-      sha256 = "cfc686cad3749e3bd933b5ae3ea35c4a9c02765be9223e6b30e7d801a9174aa7";
+      rev = "01383136565840a63aa056b82c74be40afcb8ba3";
+      sha256 = "bc9dfb3a0fa15c1149bb8ca5e6e745ca66e141862bbc08e071afec86b8bf9da9";
     };
     dependencies = [];
 
···
   };
 
   vim-multiple-cursors = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "vim-multiple-cursors-2015-10-30";
+    name = "vim-multiple-cursors-2016-01-01";
     src = fetchgit {
       url = "git://github.com/terryma/vim-multiple-cursors";
-      rev = "73a78c926ad208bd1984e575ceece276d61a1404";
-      sha256 = "74f51c7c6a903621ee3fc5e78fbce4853b5da086463d015c652808d155cbc7e6";
+      rev = "0dfd3f91b0ea1c70be8873d0a9e5c7d00369610f";
+      sha256 = "820662a93102bc1fac679f108d5e3400f7f5431196d84abf24484849e004c325";
     };
     dependencies = [];
 
···
   };
 
   vim-signify = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "vim-signify-2015-12-09";
+    name = "vim-signify-2015-12-27";
     src = fetchgit {
       url = "git://github.com/mhinz/vim-signify";
-      rev = "ecb796139eb0fc9b79fdc28e9b610fa1a2c5f589";
-      sha256 = "6086fb614a0da7f676f2f567b5dfc6ddd765167141f629dc8dbb02862e7db34c";
+      rev = "812b305b795144617cb44d5f4f6cf1c92e5366eb";
+      sha256 = "34eaaa24e6caf07d0e942f482861a6328578a524d76b630ca41d2fc650084225";
     };
     dependencies = [];
 
   };
 
   vim-snippets = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "vim-snippets-2015-12-17";
+    name = "vim-snippets-2016-01-04";
     src = fetchgit {
       url = "git://github.com/honza/vim-snippets";
-      rev = "d5153d63b16e956e892f039ac5982963660a1c68";
-      sha256 = "c79fc743ec1e565111876357136cee1a04ed6b3f58d1586df322a38b026f8a49";
+      rev = "40bcbf8a34a53d54e34fae9e4122ce25b7225144";
+      sha256 = "ef88a33110115b611ed2d707d052c3a4969ff57d8c44d480dd3fc28c9a44fcec";
     };
     dependencies = [];
 
   };
 
   vim-webdevicons = buildVimPluginFrom2Nix { # created by nix#NixDerivation
-    name = "vim-webdevicons-2015-12-01";
+    name = "vim-webdevicons-2015-12-21";
     src = fetchgit {
       url = "git://github.com/ryanoasis/vim-devicons";
-      rev = "0e1b7864cfee4b0585daa277bedd992f858e1e75";
-      sha256 = "e265c6c0906d0427409a98458192a4eb94afe671f26fc8de8890dae0e66f7764";
+      rev = "8ac3e02537d32648c3f9738c711639f8b940460c";
+      sha256 = "9d4ee89a551ab9e1ec3938e1eba1fd138bbee975ce3b247b5f56eb2613daefbc";
     };
     dependencies = [];
 

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

···
   version = "3.1.1";
 
   src = fetchurl {
-    url = "http://dl.lm-sensors.org/i2c-tools/releases/${name}.tar.bz2";
+    url = "http://http.debian.net/debian/pool/main/i/i2c-tools/i2c-tools_${version}.orig.tar.bz2";
     sha256 = "000pvg995qy1b15ks59gd0klri55hb33kqpg5czy84hw1pbdgm0l";
   };
 

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

···
 { stdenv, fetchurl, perl, buildLinux, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "4.4-rc6";
-  modDirVersion = "4.4.0-rc6";
+  version = "4.4-rc7";
+  modDirVersion = "4.4.0-rc7";
   extraMeta.branch = "4.4";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/testing/linux-${version}.tar.xz";
-    sha256 = "1brb1v6185pf8gnff753hvpdsbdmjr5nsbvj0s4ljlpcgljrn6cb";
+    sha256 = "11lk368wqsj76djh4c70447hidldr16h28yb839lpx05z6dpzshx";
   };
 
   features.iwlwifi = true;

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

···
 stdenv.mkDerivation {
   name = "uksmtools-${version}";
 
+  # This project uses git submodules, which fetchFromGitHub doesn't support:
   src = fetchgit {
     sha256 = "0ngdmici2vgi2z02brzc3f78j1g1y9myzfxn46zlm1skg94fp692";
     rev = "9f59a3a0b494b758aa91d7d8fa04e21b5e6463c0";

pkgs/servers/mpd/default.nix

···
   opt = stdenv.lib.optional;
   mkFlag = c: f: if c then "--enable-${f}" else "--disable-${f}";
   major = "0.19";
-  minor = "11";
+  minor = "12";
 
 in stdenv.mkDerivation rec {
   name = "mpd-${major}.${minor}";
   src = fetchurl {
     url    = "http://www.musicpd.org/download/mpd/${major}/${name}.tar.xz";
-    sha256 = "1iin50s8cnlsgjgjwkm1cbyxlwa0b79f6jfwydx5nyprbam6cp3s";
+    sha256 = "0xg8w5vn6xd0yfw55qj6wnav7v14nmr00s3d4w5gixbjrv3ycvvv";
   };
 
   buildInputs = [ pkgconfig glib boost ]

pkgs/servers/owncloud/default.nix

···
   };
 
   owncloud70 = common {
-    versiona = "7.0.11";
-    sha256 = "21dd75de4ed832f16f577eb6763d04c663ef13251153ba2e8847e3f5799d2ad2";
+    versiona = "7.0.12";
+    sha256 = "d1a0f73f5094ec1149b50e2409b5fea0a9bebb16d663789d4b8f98fed341aa91";
   };
 
   owncloud80 = common {
-    versiona = "8.0.9";
-    sha256 = "0c1f915f4123dbe07d564cf0172930568690ab5257d2fca4fec4ec515858bef1";
+    versiona = "8.0.10";
+    sha256 = "3054b997f258178b57efc526e14384829ac8ab94757191f2d03c13fcb0a3cd93";
   };
 
   owncloud81 = common {
-    versiona = "8.1.4";
-    sha256 = "e0f4bf0c85821fc1b6e7f6268080ad3ca3e98c41baa68a9d616809d74a77312d";
+    versiona = "8.1.5";
+    sha256 = "6d8687e40af32c5ca5adfea3fee556ed987b77ad15a1ead5d40cc87a8b76f4b4";
   };
 
   owncloud82 = common {
-    versiona = "8.2.1";
-    sha256 = "5390b2172562a5bf97a46e9a621d1dd92f9b74efaccbb77978c39eb90d6988d4";
+    versiona = "8.2.2";
+    sha256 = "d5b935f904744b8b40b310f19679702387c852498d0dc7aaeda4555a3db9ad5b";
   };
 
 }

pkgs/servers/x11/xorg/replacements.nix

···
-{stdenv, fetchurl, xorg, automake, autoconf, libtool, makeOverridable}:
-{
-  xf86videoati = {src, suffix}: 
-  makeOverridable stdenv.mkDerivation {
-      name = "xf86-video-ati-${suffix}";
-      buildInputs = xorg.xf86videoati.buildInputs ++
-         [autoconf automake libtool];
-      builder = ./builder.sh;
-      inherit src;
-      preConfigure = ''
-        export NIX_CFLAGS_COMPILE="$NIX_CFLAGS_COMPILE -DPACKAGE_VERSION_MAJOR=6"
-        export NIX_CFLAGS_COMPILE="$NIX_CFLAGS_COMPILE -DPACKAGE_VERSION_MINOR=9"
-        export NIX_CFLAGS_COMPILE="$NIX_CFLAGS_COMPILE -DPACKAGE_VERSION_PATCHLEVEL=999"
-
-        sed -e 's/@DRIVER_MAN_SUFFIX@/man/g' -i man/Makefile.am
-        export DRIVER_MAN_DIR=$out/share/man/man5 
-
-        ./autogen.sh
-      '';
-  };
-}

pkgs/shells/fish/command-not-found.patch

···
+diff --git a/share/functions/__fish_config_interactive.fish b/share/functions/__fish_config_interactive.fish
+index c3864a8..a12ac4d 100644
+--- a/share/functions/__fish_config_interactive.fish
++++ b/share/functions/__fish_config_interactive.fish
+@@ -230,7 +230,7 @@ function __fish_config_interactive -d "Initializations that should be performed
+ 		# Check for NixOS handler
+ 		else if test -f /run/current-system/sw/bin/command-not-found
+ 			function __fish_command_not_found_handler --on-event fish_command_not_found
+-				/run/current-system/sw/bin/command-not-found $argv[1]
++				/run/current-system/sw/bin/command-not-found $argv
+ 			end
+ 		# Ubuntu Feisty places this command in the regular path instead
+ 		else if type -q -p command-not-found

pkgs/shells/fish/default.nix

···
   name = "fish-${version}";
   version = "2.2.0";
 
+  patches = [ ./command-not-found.patch ];
+
   src = fetchurl {
     url = "http://fishshell.com/files/${version}/${name}.tar.gz";
     sha256 = "0ympqz7llmf0hafxwglykplw6j5cz82yhlrw50lw4bnf2kykjqx7";

pkgs/stdenv/darwin/default.nix

···
-{ system      ? builtins.currentSystem
-, allPackages ? import ../../top-level/all-packages.nix
-, platform    ? null
-, config      ? {}
+{ system         ? builtins.currentSystem
+, allPackages    ? import ../../top-level/all-packages.nix
+, platform       ? null
+, config         ? {}
+
+# Allow passing in bootstrap files directly so we can test the stdenv bootstrap process when changing the bootstrap tools
+, bootstrapFiles ? let
+  fetch = { file, sha256, executable ? true }: import <nix/fetchurl.nix> {
+    url = "http://tarballs.nixos.org/stdenv-darwin/x86_64/4f07c88d467216d9692fefc951deb5cd3c4cc722/${file}";
+    inherit sha256 system executable;
+  }; in {
+    sh      = fetch { file = "sh";    sha256 = "1siix3wakzil31r2cydmh3v8a1nyq4605dwiabqc5lx73j4xzrzi"; };
+    bzip2   = fetch { file = "bzip2"; sha256 = "0zvqm977k11b5cl4ixxb5h0ds24g6z0f8m28z4pqxzpa353lqbla"; };
+    mkdir   = fetch { file = "mkdir"; sha256 = "13frk8lsfgzlb65p9l26cvxf06aag43yjk7vg9msn7ix3v8cmrg1"; };
+    cpio    = fetch { file = "cpio";  sha256 = "0ms5i9m1vdksj575sf1djwgm7zhnvfrrb44dxnfh9avr793rc2w4"; };
+    tarball = fetch { file = "bootstrap-tools.cpio.bz2"; sha256 = "1lz1b0grl4642h6n635xvi6imf0yyy1zyzdr9ing5aphzz0z5iic"; executable = false; };
+  }
 }:
 
-rec {
+let
+  libSystemProfile = ''
+    (import "${./standard-sandbox.sb}")
+  '';
+in rec {
   allPackages = import ../../top-level/all-packages.nix;
 
-  bootstrapTools = derivation {
+  commonPreHook = ''
+    export NIX_ENFORCE_PURITY=1
+    export NIX_IGNORE_LD_THROUGH_GCC=1
+    stripAllFlags=" " # the Darwin "strip" command doesn't know "-s"
+    export MACOSX_DEPLOYMENT_TARGET=10.7
+    export SDKROOT=
+    export CMAKE_OSX_ARCHITECTURES=x86_64
+    # Workaround for https://openradar.appspot.com/22671534 on 10.11.
+    export gl_cv_func_getcwd_abort_bug=no
+  '';
+
+  # The one dependency of /bin/sh :(
+  binShClosure = ''
+    (allow file-read* (literal "/usr/lib/libncurses.5.4.dylib"))
+  '';
+
+  bootstrapTools = derivation rec {
     inherit system;
 
-    name    = "trivial-bootstrap-tools";
-    builder = "/bin/sh";
-    args    = [ ./trivial-bootstrap.sh ];
+    name    = "bootstrap-tools";
+    builder = bootstrapFiles.sh; # Not a filename! Attribute 'sh' on bootstrapFiles
+    args    = [ ./unpack-bootstrap-tools.sh ];
 
-    mkdir   = "/bin/mkdir";
-    ln      = "/bin/ln";
+    inherit (bootstrapFiles) mkdir bzip2 cpio tarball;
+
+    __sandboxProfile = binShClosure + libSystemProfile;
   };
 
-  # The simplest stdenv possible to run fetchadc and get the Apple command-line tools
-  stage0 = rec {
-    fetchurl = import ../../build-support/fetchurl {
-      inherit stdenv;
-      curl = bootstrapTools;
+  stageFun = step: last: {shell             ? "${bootstrapTools}/bin/sh",
+                          overrides         ? (pkgs: {}),
+                          extraPreHook      ? "",
+                          extraBuildInputs  ? with last.pkgs; [ xz darwin.CF libcxx ],
+                          extraInitialPath  ? [],
+                          allowedRequisites ? null}:
+    let
+      thisStdenv = import ../generic {
+        inherit system config shell extraBuildInputs allowedRequisites;
+
+        name = "stdenv-darwin-boot-${toString step}";
+
+        cc = if isNull last then "/dev/null" else import ../../build-support/cc-wrapper {
+          inherit shell;
+          inherit (last) stdenv;
+          inherit (last.pkgs.darwin) dyld;
+
+          nativeTools  = true;
+          nativePrefix = bootstrapTools;
+          nativeLibc   = false;
+          libc         = last.pkgs.darwin.Libsystem;
+          isClang      = true;
+          cc           = { name = "clang-9.9.9"; outPath = bootstrapTools; };
+        };
+
+        preHook = stage0.stdenv.lib.optionalString (shell == "${bootstrapTools}/bin/sh") ''
+          # Don't patch #!/interpreter because it leads to retained
+          # dependencies on the bootstrapTools in the final stdenv.
+          dontPatchShebangs=1
+        '' + ''
+          ${commonPreHook}
+          ${extraPreHook}
+        '';
+        initialPath  = extraInitialPath ++ [ bootstrapTools ];
+        fetchurlBoot = import ../../build-support/fetchurl {
+          stdenv = stage0.stdenv;
+          curl   = bootstrapTools;
+        };
+
+        # The stdenvs themselves don't use mkDerivation, so I need to specify this here
+        stdenvSandboxProfile = binShClosure + libSystemProfile;
+        extraSandboxProfile  = binShClosure + libSystemProfile;
+
+        extraAttrs = { inherit platform; };
+        overrides  = pkgs: (overrides pkgs) // { fetchurl = thisStdenv.fetchurlBoot; };
+      };
+
+      thisPkgs = allPackages {
+        inherit system platform;
+        bootStdenv = thisStdenv;
+      };
+    in { stdenv = thisStdenv; pkgs = thisPkgs; };
+
+  stage0 = stageFun 0 null {
+    overrides = orig: with stage0; rec {
+      darwin = orig.darwin // {
+        Libsystem = stdenv.mkDerivation {
+          name = "bootstrap-Libsystem";
+          buildCommand = ''
+            mkdir -p $out
+            ln -s ${bootstrapTools}/lib $out/lib
+            ln -s ${bootstrapTools}/include-Libsystem $out/include
+          '';
+        };
+        dyld = bootstrapTools;
+      };
+
+      libcxx = stdenv.mkDerivation {
+        name = "bootstrap-libcxx";
+        phases = [ "installPhase" "fixupPhase" ];
+        installPhase = ''
+          mkdir -p $out/lib $out/include
+          ln -s ${bootstrapTools}/lib/libc++.dylib $out/lib/libc++.dylib
+          ln -s ${bootstrapTools}/include/c++      $out/include/c++
+        '';
+        linkCxxAbi = false;
+        setupHook = ../../development/compilers/llvm/3.6/libc++/setup-hook.sh;
+      };
+
+      libcxxabi = stdenv.mkDerivation {
+        name = "bootstrap-libcxxabi";
+        buildCommand = ''
+          mkdir -p $out/lib
+          ln -s ${bootstrapTools}/lib/libc++abi.dylib $out/lib/libc++abi.dylib
+        '';
+      };
+
     };
 
-    stdenv = import ../generic {
-      inherit system config;
-      name         = "stdenv-darwin-boot-0";
-      shell        = "/bin/bash";
-      initialPath  = [ bootstrapTools ];
-      fetchurlBoot = fetchurl;
-      cc           = null;
+    extraBuildInputs = [];
+  };
+
+  persistent0 = _: {};
+
+  stage1 = with stage0; stageFun 1 stage0 {
+    extraPreHook = "export NIX_CFLAGS_COMPILE+=\" -F${bootstrapTools}/Library/Frameworks\"";
+    extraBuildInputs = [ pkgs.libcxx ];
+
+    allowedRequisites =
+      [ bootstrapTools ] ++ (with pkgs; [ libcxx libcxxabi ]) ++ [ pkgs.darwin.Libsystem ];
+
+    overrides = persistent0;
+  };
+
+  persistent1 = orig: with stage1.pkgs; {
+    inherit
+      zlib patchutils m4 scons flex perl bison unifdef unzip openssl icu python
+      libxml2 gettext sharutils gmp libarchive ncurses pkg-config libedit groff
+      openssh sqlite sed serf openldap db cyrus-sasl expat apr-util subversion xz
+      findfreetype libssh curl cmake autoconf automake libtool ed cpio coreutils;
+
+    darwin = orig.darwin // {
+      inherit (darwin)
+        dyld Libsystem xnu configd libdispatch libclosure launchd;
     };
   };
 
-  buildTools = import ../../os-specific/darwin/command-line-tools {
-    inherit (stage0) stdenv fetchurl;
-    xar  = bootstrapTools;
-    gzip = bootstrapTools;
-    cpio = bootstrapTools;
+  stage2 = with stage1; stageFun 2 stage1 {
+    extraPreHook = ''
+      export PATH_LOCALE=${pkgs.darwin.locale}/share/locale
+    '';
+
+    allowedRequisites =
+      [ bootstrapTools ] ++
+      (with pkgs; [ xz libcxx libcxxabi icu ]) ++
+      (with pkgs.darwin; [ dyld Libsystem CF locale ]);
+
+    overrides = persistent1;
+  };
+
+  persistent2 = orig: with stage2.pkgs; {
+    inherit
+      patchutils m4 scons flex perl bison unifdef unzip openssl python
+      gettext sharutils libarchive pkg-config groff bash subversion
+      openssh sqlite sed serf openldap db cyrus-sasl expat apr-util
+      findfreetype libssh curl cmake autoconf automake libtool cpio
+      libcxx libcxxabi;
+
+    darwin = orig.darwin // {
+      inherit (darwin)
+        dyld Libsystem xnu configd libdispatch libclosure launchd libiconv locale;
+    };
   };
 
-  preHook = ''
-    export NIX_IGNORE_LD_THROUGH_GCC=1
-    export NIX_DONT_SET_RPATH=1
-    export NIX_NO_SELF_RPATH=1
-    dontFixLibtool=1
-    stripAllFlags=" " # the Darwin "strip" command doesn't know "-s"
-    xargsFlags=" "
-    export MACOSX_DEPLOYMENT_TARGET=10.7
-    # Use the 10.9 SDK if we're running on 10.9, and 10.10 if we're
-    # running on 10.10. We need to use the 10.10 headers for functions
-    # like readlinkat() that are dynamically detected by configure
-    # scripts. Very impure, obviously.
-    export SDKROOT=$(/usr/bin/xcrun --sdk macosx"$(/usr/bin/sw_vers -productVersion | /usr/bin/cut -d. -f1,2)" --show-sdk-path 2> /dev/null || echo /)
-    export NIX_CFLAGS_COMPILE+=" --sysroot=/var/empty -idirafter $SDKROOT/usr/include -F$SDKROOT/System/Library/Frameworks -Wno-multichar -Wno-deprecated-declarations"
-    export NIX_LDFLAGS_AFTER+=" -L$SDKROOT/usr/lib"
-    export CMAKE_OSX_ARCHITECTURES=x86_64
-    # Workaround for https://openradar.appspot.com/22671534 on 10.11.
-    export gl_cv_func_getcwd_abort_bug=no
-  '';
+  stage3 = with stage2; stageFun 3 stage2 {
+    shell = "${pkgs.bash}/bin/bash";
 
-  # A stdenv that wraps the Apple command-line tools and our other trivial symlinked bootstrap tools
-  stage1 = rec {
-    nativePrefix = "${buildTools.tools}/Library/Developer/CommandLineTools/usr";
+    # We have a valid shell here (this one has no bootstrap-tools runtime deps) so stageFun
+    # enables patchShebangs above. Unfortunately, patchShebangs ignores our $SHELL setting
+    # and instead goes by $PATH, which happens to contain bootstrapTools. So it goes and
+    # patches our shebangs back to point at bootstrapTools. This makes sure bash comes first.
+    extraInitialPath = [ pkgs.bash ];
 
-    stdenv = import ../generic {
-      name = "stdenv-darwin-boot-1";
+    extraPreHook = ''
+      export PATH_LOCALE=${pkgs.darwin.locale}/share/locale
+    '';
 
-      inherit system config;
-      inherit (stage0.stdenv) shell fetchurlBoot;
+    allowedRequisites =
+      [ bootstrapTools ] ++
+      (with pkgs; [ icu bash libcxx libcxxabi ]) ++
+      (with pkgs.darwin; [ dyld Libsystem locale ]);
 
-      initialPath = stage0.stdenv.initialPath ++ [ nativePrefix ];
+    overrides = persistent2;
+  };
 
-      preHook = preHook + "\n" + ''
-        export NIX_LDFLAGS_AFTER+=" -L/usr/lib"
-        export NIX_ENFORCE_PURITY=
-        export NIX_CFLAGS_COMPILE+=" -isystem ${nativePrefix}/include/c++/v1 -stdlib=libc++"
-        export NIX_CFLAGS_LINK+=" -stdlib=libc++ -Wl,-rpath,${nativePrefix}/lib"
-      '';
+  persistent3 = orig: with stage3.pkgs; {
+    inherit
+      gnumake gzip gnused bzip2 gawk ed xz patch bash
+      libcxxabi libcxx ncurses libffi zlib gmp pcre gnugrep
+      coreutils findutils diffutils patchutils;
 
-      cc = import ../../build-support/cc-wrapper {
-        nativeTools  = true;
-        nativePrefix = nativePrefix;
-        nativeLibc   = true;
-        stdenv       = stage0.stdenv;
-        shell        = "/bin/bash";
-        cc           = {
-          name    = "clang-9.9.9";
-          cc      = "/usr";
-          outPath = nativePrefix;
-        };
-        isClang      = true;
-      };
+    llvmPackages = let llvmOverride = llvmPackages.llvm.override { inherit libcxxabi; };
+    in orig.llvmPackages // {
+      llvm = llvmOverride;
+      clang-unwrapped = llvmPackages.clang-unwrapped.override { llvm = llvmOverride; };
     };
-    pkgs = allPackages {
-      inherit system platform;
-      bootStdenv = stdenv;
+
+    darwin = orig.darwin // {
+      inherit (darwin) dyld Libsystem libiconv locale;
     };
   };
 
-  stage2 = rec {
-    stdenv = import ../generic {
-      name = "stdenv-darwin-boot-2";
+  stage4 = with stage3; stageFun 4 stage3 {
+    shell = "${pkgs.bash}/bin/bash";
+    extraInitialPath = [ pkgs.bash ];
+    extraPreHook = ''
+      export PATH_LOCALE=${pkgs.darwin.locale}/share/locale
+    '';
+    overrides = persistent3;
+  };
 
-      inherit system config;
-      inherit (stage1.stdenv) shell fetchurlBoot preHook cc;
+  persistent4 = orig: with stage4.pkgs; {
+    inherit
+      gnumake gzip gnused bzip2 gawk ed xz patch bash
+      libcxxabi libcxx ncurses libffi zlib icu llvm gmp pcre gnugrep
+      coreutils findutils diffutils patchutils binutils binutils-raw;
 
-      initialPath = [ stage1.pkgs.xz stage1.pkgs.gnused ] ++ stage1.stdenv.initialPath;
+    llvmPackages = orig.llvmPackages // {
+      inherit (llvmPackages) llvm clang-unwrapped;
     };
-    pkgs = allPackages {
-      inherit system platform;
-      bootStdenv = stdenv;
+
+    darwin = orig.darwin // {
+      inherit (darwin) dyld Libsystem cctools libiconv;
     };
   };
 
-  # Use stage1 to build a whole set of actual tools so we don't have to rely on the Apple prebuilt ones or
-  # the ugly symlinked bootstrap tools anymore.
-  stage3 = with stage2; import ../generic {
-    name = "stdenv-darwin-boot-3";
-
+  stage5 = with stage4; import ../generic rec {
     inherit system config;
     inherit (stdenv) fetchurlBoot;
 
-    initialPath = (import ../common-path.nix) { inherit pkgs; };
+    name = "stdenv-darwin";
 
-    preHook = preHook + "\n" + ''
-      export NIX_ENFORCE_PURITY=1
+    preHook = commonPreHook + ''
+      export PATH_LOCALE=${pkgs.darwin.locale}/share/locale
     '';
 
+    stdenvSandboxProfile = binShClosure + libSystemProfile;
+    extraSandboxProfile  = binShClosure + libSystemProfile;
+
+    initialPath = import ../common-path.nix { inherit pkgs; };
+    shell       = "${pkgs.bash}/bin/bash";
+
     cc = import ../../build-support/cc-wrapper {
-      inherit stdenv;
-      nativeTools   = false;
-      nativeLibc    = true;
-      binutils      = pkgs.darwin.cctools;
-      cc            = pkgs.llvmPackages.clang-unwrapped;
-      coreutils     = pkgs.coreutils;
-      shell         = "${pkgs.bash}/bin/bash";
-      extraPackages = [ pkgs.libcxx ];
-      isClang       = true;
+      inherit stdenv shell;
+      nativeTools = false;
+      nativeLibc  = false;
+      inherit (pkgs) coreutils binutils;
+      inherit (pkgs.darwin) dyld;
+      cc   = pkgs.llvmPackages.clang-unwrapped;
+      libc = pkgs.darwin.Libsystem;
     };
 
-    shell = "${pkgs.bash}/bin/bash";
+    extraBuildInputs = with pkgs; [ darwin.CF libcxx ];
+
+    extraAttrs = {
+      inherit platform bootstrapTools;
+      libc         = pkgs.darwin.Libsystem;
+      shellPackage = pkgs.bash;
+    };
+
+    allowedRequisites = (with pkgs; [
+      xz libcxx libcxxabi icu gmp gnumake findutils bzip2 llvm zlib libffi
+      coreutils ed diffutils gnutar gzip ncurses gnused bash gawk
+      gnugrep llvmPackages.clang-unwrapped patch pcre binutils-raw binutils gettext
+    ]) ++ (with pkgs.darwin; [
+      dyld Libsystem CF cctools libiconv locale
+    ]);
+
+    overrides = orig: persistent4 orig // {
+      clang = cc;
+      inherit cc;
+    };
   };
 
-  stdenvDarwin = stage3;
+  stdenvDarwin = stage5;
 }

pkgs/stdenv/darwin/make-bootstrap-tools.nix

···
-{system ? builtins.currentSystem}:
+{ system ? builtins.currentSystem }:
 
-with import ../../top-level/all-packages.nix {inherit system;};
+with import ../../top-level/all-packages.nix { inherit system; };
 
 rec {
   # We want coreutils without ACL support.
···
   });
 
   build = stdenv.mkDerivation {
-    name = "build";
+    name = "stdenv-bootstrap-tools";
 
     buildInputs = [nukeReferences cpio];
 
···
       cp -d ${openssl}/lib/*.dylib $out/lib
 
       cp -d ${gnugrep.pcre}/lib/libpcre*.dylib $out/lib
-      cp -d ${libiconv}/lib/libiconv*.dylib $out/lib
+      cp -d ${libiconv}/lib/lib*.dylib $out/lib
+      cp -d ${gettext}/lib/libintl*.dylib $out/lib
+      chmod +x $out/lib/libintl*.dylib
+      cp -d ${ncurses}/lib/libncurses*.dylib $out/lib
 
       # Copy what we need of clang
-      cp -d ${llvmPackages.clang}/bin/clang $out/bin
-      cp -d ${llvmPackages.clang}/bin/clang++ $out/bin
-      cp -d ${llvmPackages.clang}/bin/clang-3.5 $out/bin
+      cp -d ${llvmPackages.clang-unwrapped}/bin/clang $out/bin
+      cp -d ${llvmPackages.clang-unwrapped}/bin/clang++ $out/bin
+      cp -d ${llvmPackages.clang-unwrapped}/bin/clang-[0-9].[0-9] $out/bin
 
-      cp -rL ${llvmPackages.clang}/lib/clang $out/lib
+      cp -rL ${llvmPackages.clang-unwrapped}/lib/clang $out/lib
 
       cp -d ${libcxx}/lib/libc++*.dylib $out/lib
       cp -d ${libcxxabi}/lib/libc++abi*.dylib $out/lib
···
         fi
       done
 
-      for i in $out/bin/* $out/lib/*.dylib $out/lib/clang/3.5.0/lib/darwin/*.dylib $out/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation; do
+      for i in $out/bin/* $out/lib/*.dylib $out/lib/clang/*/lib/darwin/*.dylib $out/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation; do
         if test -x $i -a ! -L $i; then
           echo "Adding rpath to $i"
           rpathify $i
···
       done
 
       nuke-refs $out/lib/*
-      nuke-refs $out/lib/clang/3.5.0/lib/darwin/*
+      nuke-refs $out/lib/clang/*/lib/darwin/*
       nuke-refs $out/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation
 
+      set -x
       mkdir $out/.pack
       mv $out/* $out/.pack
       mv $out/.pack $out/pack
 
       mkdir $out/on-server
-      (cd $out/pack && (find | cpio -o -H newc)) | bzip2 > $out/on-server/bootstrap-tools.cpio.bz2
+      cp ${stdenv.shell} $out/on-server/sh
+      cp ${cpio}/bin/cpio $out/on-server
+      cp ${coreutils_}/bin/mkdir $out/on-server
+      cp ${bzip2}/bin/bzip2 $out/on-server
 
-      mkdir $out/in-nixpkgs
-      cp ${stdenv.shell} $out/in-nixpkgs/sh
-      cp ${cpio}/bin/cpio $out/in-nixpkgs
-      cp ${coreutils_}/bin/mkdir $out/in-nixpkgs
-      cp ${bzip2}/bin/bzip2 $out/in-nixpkgs
+      chmod u+w $out/on-server/*
+      strip $out/on-server/*
+      nuke-refs $out/on-server/*
 
-      chmod u+w $out/in-nixpkgs/*
-      strip $out/in-nixpkgs/*
-      nuke-refs $out/in-nixpkgs/*
-
-      for i in $out/in-nixpkgs/*; do
+      for i in $out/on-server/*; do
         fix_dyld $i
       done
+
+      (cd $out/pack && (find | cpio -o -H newc)) | bzip2 > $out/on-server/bootstrap-tools.cpio.bz2
     '';
 
     allowedReferences = [];
+
+    meta = {
+      maintainers = [ stdenv.lib.maintainers.copumpkin ];
+    };
   };
 
-  host = stdenv.mkDerivation {
-    name = "host";
+  dist = stdenv.mkDerivation {
+    name = "stdenv-bootstrap-tools";
 
     buildCommand = ''
       mkdir -p $out/nix-support
-
-      for i in "${build}/on-server/"*; do
-        echo "file binary-dist $i" >> $out/nix-support/hydra-build-products
-      done
-
-      echo "darwin-bootstrap-tools-$(date +%Y.%m.%d)" >> $out/nix-support/hydra-release-name
+      echo "file tarball ${build}/on-server/bootstrap-tools.cpio.bz2" >> $out/nix-support/hydra-build-products
+      echo "file sh ${build}/on-server/sh" >> $out/nix-support/hydra-build-products
+      echo "file cpio ${build}/on-server/cpio" >> $out/nix-support/hydra-build-products
+      echo "file mkdir ${build}/on-server/mkdir" >> $out/nix-support/hydra-build-products
+      echo "file bzip2 ${build}/on-server/bzip2" >> $out/nix-support/hydra-build-products
     '';
+  };
 
-    allowedReferences = [ build ];
+  bootstrapFiles = {
+    sh      = "${build}/on-server/sh";
+    bzip2   = "${build}/on-server/bzip2";
+    mkdir   = "${build}/on-server/mkdir";
+    cpio    = "${build}/on-server/cpio";
+    tarball = "${build}/on-server/bootstrap-tools.cpio.bz2";
   };
 
-  unpack = stdenv.mkDerivation {
+  unpack = stdenv.mkDerivation (bootstrapFiles // {
     name = "unpack";
 
     # This is by necessity a near-duplicate of unpack-bootstrap-tools.sh. If we refer to it directly,
···
       EOF
     '';
 
-    tarball = "${build}/on-server/bootstrap-tools.cpio.bz2";
-
-    mkdir = "${build}/in-nixpkgs/mkdir";
-    bzip2 = "${build}/in-nixpkgs/bzip2";
-    cpio  = "${build}/in-nixpkgs/cpio";
-
     allowedReferences = [ "out" ];
-  };
+  });
 
   test = stdenv.mkDerivation {
     name = "test";
···
       # an SSL-capable curl
       curl --version | grep SSL
 
-      ${build}/in-nixpkgs/sh -c 'echo Hello World'
+      ${build}/on-server/sh -c 'echo Hello World'
 
       export flags="-idirafter ${unpack}/include-Libsystem --sysroot=${unpack} -L${unpack}/lib"
 
···
 
       $out/bin/hello
     '';
+  };
+
+  # The ultimate test: bootstrap a whole stdenv from the tools specified above and get a package set out of it
+  test-pkgs = let
+    stdenv = import ./. { inherit system bootstrapFiles; };
+  in import ../../top-level/all-packages.nix {
+    inherit system;
+    bootStdenv = stdenv.stdenvDarwin;
   };
 }

pkgs/stdenv/darwin/trivial-bootstrap.sh

···
-
-# Building bootstrap tools
-echo Building the trivial bootstrap environment...
-$mkdir -p $out/bin
-
-$ln -s $ln $out/bin/ln
-
-PATH=$out/bin/
-
-cd $out/bin
-
-ln -s $mkdir
-ln -s /bin/sh
-ln -s /bin/cp
-ln -s /bin/dd
-ln -s /bin/mv
-ln -s /bin/rm
-ln -s /bin/ls
-ln -s /bin/ps
-ln -s /bin/cat
-ln -s /bin/bash
-ln -s /bin/echo
-ln -s /bin/expr
-ln -s /bin/test
-ln -s /bin/date
-ln -s /bin/chmod
-ln -s /bin/rmdir
-ln -s /bin/sleep
-ln -s /bin/hostname
-
-ln -s /usr/bin/id
-ln -s /usr/bin/od
-ln -s /usr/bin/tr
-ln -s /usr/bin/wc
-ln -s /usr/bin/cut
-ln -s /usr/bin/cmp
-ln -s /usr/bin/sed
-ln -s /usr/bin/tar
-ln -s /usr/bin/xar
-ln -s /usr/bin/awk
-ln -s /usr/bin/env
-ln -s /usr/bin/tee
-ln -s /usr/bin/comm
-ln -s /usr/bin/cpio
-ln -s /usr/bin/curl
-ln -s /usr/bin/find
-ln -s /usr/bin/grep
-ln -s /usr/bin/gzip
-ln -s /usr/bin/head
-ln -s /usr/bin/tail
-ln -s /usr/bin/sort
-ln -s /usr/bin/uniq
-ln -s /usr/bin/less
-ln -s /usr/bin/true
-ln -s /usr/bin/diff
-ln -s /usr/bin/egrep
-ln -s /usr/bin/fgrep
-ln -s /usr/bin/patch
-ln -s /usr/bin/uname
-ln -s /usr/bin/touch
-ln -s /usr/bin/split
-ln -s /usr/bin/xargs
-ln -s /usr/bin/which
-ln -s /usr/bin/install
-ln -s /usr/bin/basename
-ln -s /usr/bin/dirname
-ln -s /usr/bin/readlink

pkgs/stdenv/default.nix

···
   # Linux standard environment.
   stdenvLinux = (import ./linux { inherit system allPackages platform config lib; }).stdenvLinux;
 
-  # Darwin standard environment.
   stdenvDarwin = (import ./darwin { inherit system allPackages platform config;}).stdenvDarwin;
-
-  # Pure Darwin standard environment. Allows building with the sandbox enabled. To use,
-  # you can add this to your nixpkgs config:
-  #
-  #   replaceStdenv = {pkgs}: pkgs.allStdenvs.stdenvDarwinPure
-  stdenvDarwinPure = (import ./pure-darwin { inherit system allPackages platform config;}).stage5;
 
   # Select the appropriate stdenv for the platform `system'.
   stdenv =
···
     if system == "armv7l-linux" then stdenvLinux else
     if system == "mips64el-linux" then stdenvLinux else
     if system == "powerpc-linux" then /* stdenvLinux */ stdenvNative else
-    if system == "x86_64-darwin" then stdenvDarwinPure else
+    if system == "x86_64-darwin" then stdenvDarwin else
     if system == "x86_64-solaris" then stdenvNix else
     if system == "i686-cygwin" then stdenvNative else
     if system == "x86_64-cygwin" then stdenvNative else

pkgs/stdenv/pure-darwin/default.nix

···
-{ system      ? builtins.currentSystem
-, allPackages ? import ../../top-level/all-packages.nix
-, platform    ? null
-, config      ? {}
-}:
-
-let
-  libSystemProfile = ''
-    (import "${./standard-sandbox.sb}")
-  '';
-
-  fetch = { file, sha256, executable ? true }: import <nix/fetchurl.nix> {
-    url = "http://tarballs.nixos.org/stdenv-darwin/x86_64/4f07c88d467216d9692fefc951deb5cd3c4cc722/${file}";
-    inherit sha256 system executable;
-  };
-
-  bootstrapFiles = {
-    sh    = fetch { file = "sh";    sha256 = "1siix3wakzil31r2cydmh3v8a1nyq4605dwiabqc5lx73j4xzrzi"; };
-    bzip2 = fetch { file = "bzip2"; sha256 = "0zvqm977k11b5cl4ixxb5h0ds24g6z0f8m28z4pqxzpa353lqbla"; };
-    mkdir = fetch { file = "mkdir"; sha256 = "13frk8lsfgzlb65p9l26cvxf06aag43yjk7vg9msn7ix3v8cmrg1"; };
-    cpio  = fetch { file = "cpio";  sha256 = "0ms5i9m1vdksj575sf1djwgm7zhnvfrrb44dxnfh9avr793rc2w4"; };
-  };
-
-  tarball = fetch { file = "bootstrap-tools.cpio.bz2"; sha256 = "1lz1b0grl4642h6n635xvi6imf0yyy1zyzdr9ing5aphzz0z5iic"; executable = false; };
-in rec {
-  allPackages = import ../../top-level/all-packages.nix;
-
-  commonPreHook = ''
-    export NIX_ENFORCE_PURITY=1
-    export NIX_IGNORE_LD_THROUGH_GCC=1
-    stripAllFlags=" " # the Darwin "strip" command doesn't know "-s"
-    export MACOSX_DEPLOYMENT_TARGET=10.7
-    export SDKROOT=
-    export CMAKE_OSX_ARCHITECTURES=x86_64
-    # Workaround for https://openradar.appspot.com/22671534 on 10.11.
-    export gl_cv_func_getcwd_abort_bug=no
-  '';
-
-  # The one dependency of /bin/sh :(
-  binShClosure = ''
-    (allow file-read* (literal "/usr/lib/libncurses.5.4.dylib"))
-  '';
-
-  bootstrapTools = derivation rec {
-    inherit system tarball;
-
-    name    = "bootstrap-tools";
-    builder = bootstrapFiles.sh; # Not a filename! Attribute 'sh' on bootstrapFiles
-    args    = [ ./unpack-bootstrap-tools.sh ];
-
-    inherit (bootstrapFiles) mkdir bzip2 cpio;
-
-    __sandboxProfile = binShClosure + libSystemProfile;
-  };
-
-  stageFun = step: last: {shell             ? "${bootstrapTools}/bin/sh",
-                          overrides         ? (pkgs: {}),
-                          extraPreHook      ? "",
-                          extraBuildInputs  ? with last.pkgs; [ xz darwin.CF libcxx ],
-                          extraInitialPath  ? [],
-                          allowedRequisites ? null}:
-    let
-      thisStdenv = import ../generic {
-        inherit system config shell extraBuildInputs allowedRequisites;
-
-        name = "stdenv-darwin-boot-${toString step}";
-
-        cc = if isNull last then "/dev/null" else import ../../build-support/cc-wrapper {
-          inherit shell;
-          inherit (last) stdenv;
-          inherit (last.pkgs.darwin) dyld;
-
-          nativeTools  = true;
-          nativePrefix = bootstrapTools;
-          nativeLibc   = false;
-          libc         = last.pkgs.darwin.Libsystem;
-          isClang      = true;
-          cc           = { name = "clang-9.9.9"; outPath = bootstrapTools; };
-        };
-
-        preHook = stage0.stdenv.lib.optionalString (shell == "${bootstrapTools}/bin/sh") ''
-          # Don't patch #!/interpreter because it leads to retained
-          # dependencies on the bootstrapTools in the final stdenv.
-          dontPatchShebangs=1
-        '' + ''
-          ${commonPreHook}
-          ${extraPreHook}
-        '';
-        initialPath  = extraInitialPath ++ [ bootstrapTools ];
-        fetchurlBoot = import ../../build-support/fetchurl {
-          stdenv = stage0.stdenv;
-          curl   = bootstrapTools;
-        };
-
-        # The stdenvs themselves don't use mkDerivation, so I need to specify this here
-        stdenvSandboxProfile = binShClosure + libSystemProfile;
-        extraSandboxProfile  = binShClosure + libSystemProfile;
-
-        extraAttrs = { inherit platform; };
-        overrides  = pkgs: (overrides pkgs) // { fetchurl = thisStdenv.fetchurlBoot; };
-      };
-
-      thisPkgs = allPackages {
-        inherit system platform;
-        bootStdenv = thisStdenv;
-      };
-    in { stdenv = thisStdenv; pkgs = thisPkgs; };
-
-  stage0 = stageFun 0 null {
-    overrides = orig: with stage0; rec {
-      darwin = orig.darwin // {
-        Libsystem = stdenv.mkDerivation {
-          name = "bootstrap-Libsystem";
-          buildCommand = ''
-            mkdir -p $out
-            ln -s ${bootstrapTools}/lib $out/lib
-            ln -s ${bootstrapTools}/include-Libsystem $out/include
-          '';
-        };
-        dyld = bootstrapTools;
-      };
-
-      libcxx = stdenv.mkDerivation {
-        name = "bootstrap-libcxx";
-        phases = [ "installPhase" "fixupPhase" ];
-        installPhase = ''
-          mkdir -p $out/lib $out/include
-          ln -s ${bootstrapTools}/lib/libc++.dylib $out/lib/libc++.dylib
-          ln -s ${bootstrapTools}/include/c++      $out/include/c++
-        '';
-        linkCxxAbi = false;
-        setupHook = ../../development/compilers/llvm/3.6/libc++/setup-hook.sh;
-      };
-
-      libcxxabi = stdenv.mkDerivation {
-        name = "bootstrap-libcxxabi";
-        buildCommand = ''
-          mkdir -p $out/lib
-          ln -s ${bootstrapTools}/lib/libc++abi.dylib $out/lib/libc++abi.dylib
-        '';
-      };
-
-    };
-
-    extraBuildInputs = [];
-  };
-
-  persistent0 = _: {};
-
-  stage1 = with stage0; stageFun 1 stage0 {
-    extraPreHook = "export NIX_CFLAGS_COMPILE+=\" -F${bootstrapTools}/Library/Frameworks\"";
-    extraBuildInputs = [ pkgs.libcxx ];
-
-    allowedRequisites =
-      [ bootstrapTools ] ++ (with pkgs; [ libcxx libcxxabi ]) ++ [ pkgs.darwin.Libsystem ];
-
-    overrides = persistent0;
-  };
-
-  persistent1 = orig: with stage1.pkgs; {
-    inherit
-      zlib patchutils m4 scons flex perl bison unifdef unzip openssl icu python
-      libxml2 gettext sharutils gmp libarchive ncurses pkg-config libedit groff
-      openssh sqlite sed serf openldap db cyrus-sasl expat apr-util subversion xz
-      findfreetype libssh curl cmake autoconf automake libtool ed cpio coreutils;
-
-    darwin = orig.darwin // {
-      inherit (darwin)
-        dyld Libsystem xnu configd libdispatch libclosure launchd;
-    };
-  };
-
-  stage2 = with stage1; stageFun 2 stage1 {
-    extraPreHook = ''
-      export PATH_LOCALE=${pkgs.darwin.locale}/share/locale
-    '';
-
-    allowedRequisites =
-      [ bootstrapTools ] ++
-      (with pkgs; [ xz libcxx libcxxabi icu ]) ++
-      (with pkgs.darwin; [ dyld Libsystem CF locale ]);
-
-    overrides = persistent1;
-  };
-
-  persistent2 = orig: with stage2.pkgs; {
-    inherit
-      patchutils m4 scons flex perl bison unifdef unzip openssl python
-      gettext sharutils libarchive pkg-config groff bash subversion
-      openssh sqlite sed serf openldap db cyrus-sasl expat apr-util
-      findfreetype libssh curl cmake autoconf automake libtool cpio
-      libcxx libcxxabi;
-
-    darwin = orig.darwin // {
-      inherit (darwin)
-        dyld Libsystem xnu configd libdispatch libclosure launchd libiconv locale;
-    };
-  };
-
-  stage3 = with stage2; stageFun 3 stage2 {
-    shell = "${pkgs.bash}/bin/bash";
-
-    # We have a valid shell here (this one has no bootstrap-tools runtime deps) so stageFun
-    # enables patchShebangs above. Unfortunately, patchShebangs ignores our $SHELL setting
-    # and instead goes by $PATH, which happens to contain bootstrapTools. So it goes and
-    # patches our shebangs back to point at bootstrapTools. This makes sure bash comes first.
-    extraInitialPath = [ pkgs.bash ];
-
-    extraPreHook = ''
-      export PATH_LOCALE=${pkgs.darwin.locale}/share/locale
-    '';
-
-    allowedRequisites =
-      [ bootstrapTools ] ++
-      (with pkgs; [ icu bash libcxx libcxxabi ]) ++
-      (with pkgs.darwin; [ dyld Libsystem locale ]);
-
-    overrides = persistent2;
-  };
-
-  persistent3 = orig: with stage3.pkgs; {
-    inherit
-      gnumake gzip gnused bzip2 gawk ed xz patch bash
-      libcxxabi libcxx ncurses libffi zlib gmp pcre gnugrep
-      coreutils findutils diffutils patchutils;
-
-    llvmPackages = let llvmOverride = llvmPackages.llvm.override { inherit libcxxabi; };
-    in orig.llvmPackages // {
-      llvm = llvmOverride;
-      clang-unwrapped = llvmPackages.clang-unwrapped.override { llvm = llvmOverride; };
-    };
-
-    darwin = orig.darwin // {
-      inherit (darwin) dyld Libsystem libiconv locale;
-    };
-  };
-
-  stage4 = with stage3; stageFun 4 stage3 {
-    shell = "${pkgs.bash}/bin/bash";
-    extraInitialPath = [ pkgs.bash ];
-    extraPreHook = ''
-      export PATH_LOCALE=${pkgs.darwin.locale}/share/locale
-    '';
-    overrides = persistent3;
-  };
-
-  persistent4 = orig: with stage4.pkgs; {
-    inherit
-      gnumake gzip gnused bzip2 gawk ed xz patch bash
-      libcxxabi libcxx ncurses libffi zlib icu llvm gmp pcre gnugrep
-      coreutils findutils diffutils patchutils binutils binutils-raw;
-
-    llvmPackages = orig.llvmPackages // {
-      inherit (llvmPackages) llvm clang-unwrapped;
-    };
-
-    darwin = orig.darwin // {
-      inherit (darwin) dyld Libsystem cctools libiconv;
-    };
-  };
-
-  stage5 = with stage4; import ../generic rec {
-    inherit system config;
-    inherit (stdenv) fetchurlBoot;
-
-    name = "stdenv-darwin";
-
-    preHook = commonPreHook + ''
-      export PATH_LOCALE=${pkgs.darwin.locale}/share/locale
-    '';
-
-    stdenvSandboxProfile = binShClosure + libSystemProfile;
-    extraSandboxProfile  = binShClosure + libSystemProfile;
-
-    initialPath = import ../common-path.nix { inherit pkgs; };
-    shell       = "${pkgs.bash}/bin/bash";
-
-    cc = import ../../build-support/cc-wrapper {
-      inherit stdenv shell;
-      nativeTools = false;
-      nativeLibc  = false;
-      inherit (pkgs) coreutils binutils;
-      inherit (pkgs.darwin) dyld;
-      cc   = pkgs.llvmPackages.clang-unwrapped;
-      libc = pkgs.darwin.Libsystem;
-    };
-
-    extraBuildInputs = with pkgs; [ darwin.CF libcxx ];
-
-    extraAttrs = {
-      inherit platform bootstrapTools;
-      libc         = pkgs.darwin.Libsystem;
-      shellPackage = pkgs.bash;
-    };
-
-    allowedRequisites = (with pkgs; [
-      xz libcxx libcxxabi icu gmp gnumake findutils bzip2 llvm zlib libffi
-      coreutils ed diffutils gnutar gzip ncurses gnused bash gawk
-      gnugrep llvmPackages.clang-unwrapped patch pcre binutils-raw binutils gettext
-    ]) ++ (with pkgs.darwin; [
-      dyld Libsystem CF cctools libiconv locale
-    ]);
-
-    overrides = orig: persistent4 orig // {
-      clang = cc;
-      inherit cc;
-    };
-  };
-}

pkgs/stdenv/pure-darwin/make-bootstrap-tools.nix

···
-with import ../../top-level/all-packages.nix { system = "x86_64-darwin"; };
-
-rec {
-  # We want coreutils without ACL support.
-  coreutils_ = coreutils.override (orig: {
-    aclSupport = false;
-  });
-
-  build = stdenv.mkDerivation {
-    name = "stdenv-bootstrap-tools";
-
-    buildInputs = [nukeReferences cpio];
-
-    buildCommand = ''
-      mkdir -p $out/bin $out/lib
-
-      # Our (fake) loader
-      cp -d ${darwin.dyld}/lib/dyld $out/lib/
-
-      # C standard library stuff
-      cp -d ${darwin.Libsystem}/lib/*.o $out/lib/
-      cp -d ${darwin.Libsystem}/lib/*.dylib $out/lib/
-      cp -d ${darwin.Libsystem}/lib/system/*.dylib $out/lib/
-
-      # Resolv is actually a link to another package, so let's copy it properly
-      rm $out/lib/libresolv.9.dylib
-      cp -L ${darwin.Libsystem}/lib/libresolv.9.dylib $out/lib
-
-      cp -rL ${darwin.Libsystem}/include $out
-      chmod -R u+w $out/include
-      cp -rL ${icu}/include*             $out/include
-      cp -rL ${libiconv}/include/*       $out/include
-      cp -rL ${gnugrep.pcre}/include/*   $out/include
-      mv $out/include $out/include-Libsystem
-
-      # Copy coreutils, bash, etc.
-      cp ${coreutils_}/bin/* $out/bin
-      (cd $out/bin && rm vdir dir sha*sum pinky factor pathchk runcon shuf who whoami shred users)
-
-      cp ${bash}/bin/bash $out/bin
-      cp ${findutils}/bin/find $out/bin
-      cp ${findutils}/bin/xargs $out/bin
-      cp -d ${diffutils}/bin/* $out/bin
-      cp -d ${gnused}/bin/* $out/bin
-      cp -d ${gnugrep}/bin/grep $out/bin
-      cp ${gawk}/bin/gawk $out/bin
-      cp -d ${gawk}/bin/awk $out/bin
-      cp ${gnutar}/bin/tar $out/bin
-      cp ${gzip}/bin/gzip $out/bin
-      cp ${bzip2}/bin/bzip2 $out/bin
-      cp -d ${gnumake}/bin/* $out/bin
-      cp -d ${patch}/bin/* $out/bin
-      cp -d ${xz}/bin/xz $out/bin
-
-      # This used to be in-nixpkgs, but now is in the bundle
-      # because I can't be bothered to make it partially static
-      cp ${curl}/bin/curl $out/bin
-      cp -d ${curl}/lib/libcurl*.dylib $out/lib
-      cp -d ${libssh2}/lib/libssh*.dylib $out/lib
-      cp -d ${openssl}/lib/*.dylib $out/lib
-
-      cp -d ${gnugrep.pcre}/lib/libpcre*.dylib $out/lib
-      cp -d ${libiconv}/lib/lib*.dylib $out/lib
-      cp -d ${gettext}/lib/libintl*.dylib $out/lib
-      chmod +x $out/lib/libintl*.dylib
-      cp -d ${ncurses}/lib/libncurses*.dylib $out/lib
-
-      # Copy what we need of clang
-      cp -d ${llvmPackages.clang-unwrapped}/bin/clang $out/bin
-      cp -d ${llvmPackages.clang-unwrapped}/bin/clang++ $out/bin
-      cp -d ${llvmPackages.clang-unwrapped}/bin/clang-[0-9].[0-9] $out/bin
-
-      cp -rL ${llvmPackages.clang-unwrapped}/lib/clang $out/lib
-
-      cp -d ${libcxx}/lib/libc++*.dylib $out/lib
-      cp -d ${libcxxabi}/lib/libc++abi*.dylib $out/lib
-
-      mkdir $out/include
-      cp -rd ${libcxx}/include/c++     $out/include
-
-      cp -d ${icu}/lib/libicu*.dylib $out/lib
-      cp -d ${zlib}/lib/libz.*       $out/lib
-      cp -d ${gmpxx}/lib/libgmp*.*   $out/lib
-      cp -d ${xz}/lib/liblzma*.*     $out/lib
-
-      # Copy binutils.
-      for i in as ld ar ranlib nm strip otool install_name_tool dsymutil; do
-        cp ${darwin.cctools}/bin/$i $out/bin
-      done
-
-      cp -rd ${pkgs.darwin.CF}/Library $out
-
-      chmod -R u+w $out
-
-      nuke-refs $out/bin/*
-
-      rpathify() {
-        local libs=$(${darwin.cctools}/bin/otool -L "$1" | tail -n +2 | grep -o "$NIX_STORE.*-\S*") || true
-        for lib in $libs; do
-          ${darwin.cctools}/bin/install_name_tool -change $lib "@rpath/$(basename $lib)" "$1"
-        done
-      }
-
-      fix_dyld() {
-        # This is clearly a hack. Once we have an install_name_tool-alike that can patch dyld, this will be nicer.
-        ${perl}/bin/perl -i -0777 -pe 's/\/nix\/store\/eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee-dyld-239\.4\/lib\/dyld/\/usr\/lib\/dyld\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00/sg' "$1"
-      }
-
-      # Strip executables even further
-      for i in $out/bin/*; do
-        if test -x $i -a ! -L $i; then
-          chmod +w $i
-
-          fix_dyld $i
-          strip $i || true
-        fi
-      done
-
-      for i in $out/bin/* $out/lib/*.dylib $out/lib/clang/*/lib/darwin/*.dylib $out/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation; do
-        if test -x $i -a ! -L $i; then
-          echo "Adding rpath to $i"
-          rpathify $i
-        fi
-      done
-
-      nuke-refs $out/lib/*
-      nuke-refs $out/lib/clang/*/lib/darwin/*
-      nuke-refs $out/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation
-
-      set -x
-      mkdir $out/.pack
-      mv $out/* $out/.pack
-      mv $out/.pack $out/pack
-
-      mkdir $out/on-server
-      cp ${stdenv.shell} $out/on-server/sh
-      cp ${cpio}/bin/cpio $out/on-server
-      cp ${coreutils_}/bin/mkdir $out/on-server
-      cp ${bzip2}/bin/bzip2 $out/on-server
-
-      chmod u+w $out/on-server/*
-      strip $out/on-server/*
-      nuke-refs $out/on-server/*
-
-      for i in $out/on-server/*; do
-        fix_dyld $i
-      done
-
-      (cd $out/pack && (find | cpio -o -H newc)) | bzip2 > $out/on-server/bootstrap-tools.cpio.bz2
-    '';
-
-    allowedReferences = [];
-
-    meta = {
-      maintainers = [ stdenv.lib.maintainers.copumpkin ];
-    };
-  };
-
-  dist = stdenv.mkDerivation {
-    name = "stdenv-bootstrap-tools";
-
-    buildCommand = ''
-      mkdir -p $out/nix-support
-      echo "file tarball ${build}/on-server/bootstrap-tools.cpio.bz2" >> $out/nix-support/hydra-build-products
-      echo "file sh ${build}/on-server/sh" >> $out/nix-support/hydra-build-products
-      echo "file cpio ${build}/on-server/cpio" >> $out/nix-support/hydra-build-products
-      echo "file mkdir ${build}/on-server/mkdir" >> $out/nix-support/hydra-build-products
-      echo "file bzip2 ${build}/on-server/bzip2" >> $out/nix-support/hydra-build-products
-    '';
-  };
-
-  unpack = stdenv.mkDerivation {
-    name = "unpack";
-
-    # This is by necessity a near-duplicate of unpack-bootstrap-tools.sh. If we refer to it directly,
-    # we can't make any changes to it due to our testing stdenv depending on it. Think of this as the
-    # unpack-bootstrap-tools.sh for the next round of bootstrap tools.
-    # TODO: think through alternate designs, such as hosting this script as an output of the process.
-    buildCommand = ''
-      # Unpack the bootstrap tools tarball.
-      echo Unpacking the bootstrap tools...
-      $mkdir $out
-      $bzip2 -d < $tarball | (cd $out && $cpio -i)
-
-      # Set the ELF interpreter / RPATH in the bootstrap binaries.
-      echo Patching the tools...
-
-      export PATH=$out/bin
-
-      for i in $out/bin/*; do
-        if ! test -L $i; then
-          echo patching $i
-          install_name_tool -add_rpath $out/lib $i || true
-        fi
-      done
-
-      for i in $out/lib/*.dylib $out/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation; do
-        if ! test -L $i; then
-          echo patching $i
-
-          id=$(otool -D "$i" | tail -n 1)
-          install_name_tool -id "$(dirname $i)/$(basename $id)" $i
-
-          libs=$(otool -L "$i" | tail -n +2 | grep -v Libsystem | cat)
-          if [ -n "$libs" ]; then
-            install_name_tool -add_rpath $out/lib $i
-          fi
-        fi
-      done
-
-      ln -s bash $out/bin/sh
-      ln -s bzip2 $out/bin/bunzip2
-
-      cat >$out/bin/dsymutil << EOF
-      #!$out/bin/sh
-      EOF
-    '';
-
-    tarball = "${build}/on-server/bootstrap-tools.cpio.bz2";
-
-    mkdir = "${build}/on-server/mkdir";
-    bzip2 = "${build}/on-server/bzip2";
-    cpio  = "${build}/on-server/cpio";
-
-    allowedReferences = [ "out" ];
-  };
-
-  test = stdenv.mkDerivation {
-    name = "test";
-
-    realBuilder = "${unpack}/bin/bash";
-
-    buildCommand = ''
-      export PATH=${unpack}/bin
-      ls -l
-      mkdir $out
-      mkdir $out/bin
-      sed --version
-      find --version
-      diff --version
-      patch --version
-      make --version
-      awk --version
-      grep --version
-      clang --version
-      xz --version
-
-      # The grep will return a nonzero exit code if there is no match, and we want to assert that we have
-      # an SSL-capable curl
-      curl --version | grep SSL
-
-      ${build}/on-server/sh -c 'echo Hello World'
-
-      export flags="-idirafter ${unpack}/include-Libsystem --sysroot=${unpack} -L${unpack}/lib"
-
-      export CPP="clang -E $flags"
-      export CC="clang $flags -Wl,-rpath,${unpack}/lib -Wl,-v"
-      export CXX="clang++ $flags --stdlib=libc++ -lc++abi -isystem${unpack}/include/c++/v1 -Wl,-rpath,${unpack}/lib -Wl,-v"
-
-      echo '#include <stdio.h>' >> foo.c
-      echo '#include <float.h>' >> foo.c
-      echo '#include <limits.h>' >> foo.c
-      echo 'int main() { printf("Hello World\n"); return 0; }' >> foo.c
-      $CC -o $out/bin/foo foo.c
-      $out/bin/foo
-
-      echo '#include <CoreFoundation/CoreFoundation.h>' >> bar.c
-      echo 'int main() { CFShow(CFSTR("Hullo")); return 0; }' >> bar.c
-      $CC -F${unpack}/Library/Frameworks -framework CoreFoundation -o $out/bin/bar bar.c
-      $out/bin/bar
-
-      echo '#include <iostream>' >> bar.cc
-      echo 'int main() { std::cout << "Hello World\n"; }' >> bar.cc
-      $CXX -v -o $out/bin/bar bar.cc
-      $out/bin/bar
-
-      tar xvf ${hello.src}
-      cd hello-*
-      ./configure --prefix=$out
-      make
-      make install
-
-      $out/bin/hello
-    '';
-  };
-}

pkgs/stdenv/pure-darwin/trivial-bootstrap.sh

···
-
-# Building bootstrap tools
-echo Building the trivial bootstrap environment...
-$mkdir -p $out/bin
-
-$ln -s $ln $out/bin/ln
-
-PATH=$out/bin/
-
-cd $out/bin
-
-ln -s $mkdir
-ln -s /bin/sh
-ln -s /bin/cp
-ln -s /bin/mv
-ln -s /bin/rm
-ln -s /bin/ls
-ln -s /bin/ps
-ln -s /bin/cat
-ln -s /bin/bash
-ln -s /bin/echo
-ln -s /bin/expr
-ln -s /bin/test
-ln -s /bin/date
-ln -s /bin/chmod
-ln -s /bin/rmdir
-ln -s /bin/sleep
-ln -s /bin/hostname
-
-ln -s /usr/bin/id
-ln -s /usr/bin/od
-ln -s /usr/bin/tr
-ln -s /usr/bin/wc
-ln -s /usr/bin/cut
-ln -s /usr/bin/cmp
-ln -s /usr/bin/sed
-ln -s /usr/bin/tar
-ln -s /usr/bin/xar
-ln -s /usr/bin/awk
-ln -s /usr/bin/env
-ln -s /usr/bin/tee
-ln -s /usr/bin/comm
-ln -s /usr/bin/cpio
-ln -s /usr/bin/curl
-ln -s /usr/bin/find
-ln -s /usr/bin/grep
-ln -s /usr/bin/gzip
-ln -s /usr/bin/head
-ln -s /usr/bin/tail
-ln -s /usr/bin/sort
-ln -s /usr/bin/uniq
-ln -s /usr/bin/less
-ln -s /usr/bin/true
-ln -s /usr/bin/diff
-ln -s /usr/bin/egrep
-ln -s /usr/bin/fgrep
-ln -s /usr/bin/patch
-ln -s /usr/bin/uname
-ln -s /usr/bin/touch
-ln -s /usr/bin/split
-ln -s /usr/bin/xargs
-ln -s /usr/bin/which
-ln -s /usr/bin/install
-ln -s /usr/bin/basename
-ln -s /usr/bin/dirname
-ln -s /usr/bin/readlink

pkgs/stdenv/pure-darwin/unpack-bootstrap-tools.sh

···
-set -e
-
-# Unpack the bootstrap tools tarball.
-echo Unpacking the bootstrap tools...
-$mkdir $out
-$bzip2 -d < $tarball | (cd $out && $cpio -i)
-
-# Set the ELF interpreter / RPATH in the bootstrap binaries.
-echo Patching the tools...
-
-export PATH=$out/bin
-
-for i in $out/bin/*; do
-  if ! test -L $i; then
-    echo patching $i
-    install_name_tool -add_rpath $out/lib $i || true
-  fi
-done
-
-for i in $out/lib/*.dylib $out/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation; do
-  if ! test -L $i; then
-    echo patching $i
-
-    id=$(otool -D "$i" | tail -n 1)
-    install_name_tool -id "$(dirname $i)/$(basename $id)" $i
-
-    libs=$(otool -L "$i" | tail -n +2 | grep -v libSystem | cat)
-    if [ -n "$libs" ]; then
-      install_name_tool -add_rpath $out/lib $i
-    fi
-  fi
-done
-
-ln -s bash $out/bin/sh
-ln -s bzip2 $out/bin/bunzip2
-
-# Provide a gunzip script.
-cat > $out/bin/gunzip <<EOF
-#!$out/bin/sh
-exec $out/bin/gzip -d "\$@"
-EOF
-chmod +x $out/bin/gunzip
-
-# Provide fgrep/egrep.
-echo "#! $out/bin/sh" > $out/bin/egrep
-echo "exec $out/bin/grep -E \"\$@\"" >> $out/bin/egrep
-echo "#! $out/bin/sh" > $out/bin/fgrep
-echo "exec $out/bin/grep -F \"\$@\"" >> $out/bin/fgrep
-
-cat >$out/bin/dsymutil << EOF
-#!$out/bin/sh
-EOF
-
-chmod +x $out/bin/egrep $out/bin/fgrep $out/bin/dsymutil

pkgs/tools/archivers/unrar/default.nix

···
   meta = with stdenv.lib; {
     description = "Utility for RAR archives";
     homepage = http://www.rarlab.com/;
-    license = licenses.gpl2;
+    license = licenses.unfreeRedistributable;
     maintainers = [ maintainers.ehmry ];
     platforms = platforms.all;
   };

pkgs/tools/cd-dvd/mkcue/default.nix

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  name = "mkcue-1";
+  name = "mkcue-${version}";
+  version = "1";
 
   src = fetchurl {
-    url = "https://diplodocus.org/dist/audio/${name}.tar.bz2";
-    sha256 = "08md7si3frb8sjfqf3pm7qbrcvkbd10mzszlbydkxnyxdb530b04";
+    url = "http://http.debian.net/debian/pool/main/m/mkcue/mkcue_${version}.orig.tar.gz";
+    sha256 = "0rs897wp08z4hd904bjb5sl4lb8qxj82x5ayklr28bhg9pd5gbra";
   };
 
   preInstall = "mkdir -pv $out/bin";
   postInstall = "chmod -v +w $out/bin/mkcue";
+
+  meta = with stdenv.lib; {
+    description = "Generates CUE sheets from a CD TOC";
+    license = licenses.lgpl2Plus;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ pSub ];
+  };
 }

pkgs/tools/compression/zopfli/default.nix

···
-{ stdenv, fetchFromGitHub }:
+{ stdenv, fetchFromGitHub, fetchpatch }:
 
+let version = "1.0.1"; in
 stdenv.mkDerivation rec {
   name = "zopfli-${version}";
-  version = "1.0.0";
 
   src = fetchFromGitHub {
     owner = "google";
     repo = "zopfli";
     rev = name;
     name = "${name}-src";
-    sha256 = "0r2k3md24y5laslzsph7kh4synm5az4ppv64idrvjk5yh2qwwb62";
+    sha256 = "1dclll3b5azy79jfb8vhb21drivi7vaay5iw0lzs4lrh6dgyvg6y";
   };
 
+  patches = [
+    (fetchpatch {
+      sha256 = "07z6df1ahx40hnsrcs5mx3fc58rqv8fm0pvyc7gb7kc5mwwghvvp";
+      name = "Fix-invalid-read-outside-allocated-memory.patch";
+      url = "https://github.com/google/zopfli/commit/9429e20de3885c0e0d9beac23f703fce58461021.patch";
+    })
+    (fetchpatch {
+      sha256 = "07m8q5kipr84cg8i1l4zd22ai9bmdrblpdrsc96llg7cm51vqdqy";
+      name = "zopfli-bug-and-typo-fixes.patch";
+      url = "https://github.com/google/zopfli/commit/7190e08ecac2446c7c9157cfbdb7157b18912a92.patch";
+    })
+  ];
+
+  enableParallelBuilding = true;
+  buildFlags = [
+    "zopfli"
+    "libzopfli"
+    "zopflipng"
+    "libzopflipng"
+  ];
+
   installPhase = ''
-    install -D zopfli $out/bin/zopfli
+    mkdir -p $out/bin
+    install -m755 zopfli{,png} $out/bin
+
+    mkdir -p $out/lib
+    install -m755 libzopfli{,png}.so* $out/lib
+
+    mkdir -p $out/share/doc/zopfli
+    install -m644 README* $out/share/doc/zopfli
   '';
 
   meta = with stdenv.lib; {
-    homepage = https://github.com/google/zopfli;
-    description = "A compression tool to perform very good, but slow, deflate or zlib compression";
-    longDescription =
-      ''Zopfli Compression Algorithm is a compression library programmed
-        in C to perform very good, but slow, deflate or zlib compression.
+    inherit version;
+    inherit (src.meta) homepage;
+    description = "Very good, but slow, deflate or zlib compression";
+    longDescription = ''
+      Zopfli Compression Algorithm is a compression library programmed
+      in C to perform very good, but slow, deflate or zlib compression.
 
-        This library can only compress, not decompress. Existing zlib or
-        deflate libraries can decompress the data.
-      '';
-    platforms = stdenv.lib.platforms.linux;
-    license = stdenv.lib.licenses.asl20;
-    maintainers = with maintainers; [ bobvanderlinden ];
+      This library can only compress, not decompress. Existing zlib or
+      deflate libraries can decompress the data.
+    '';
+    platforms = platforms.linux;
+    license = licenses.asl20;
+    maintainers = with maintainers; [ bobvanderlinden nckx ];
   };
 }

pkgs/tools/filesystems/disorderfs/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "disorderfs-${version}";
-  version = "0.4.1";
+  version = "0.4.2";
 
   src = fetchurl {
     url = "http://http.debian.net/debian/pool/main/d/disorderfs/disorderfs_${version}.orig.tar.gz";
-    sha256 = "1kiih49l3wi8nhybzrb0kn4aidhpy23s5h2grjwx8rwla5b4cja6";
+    sha256 = "1qr52lzynd5b5ancrn0g1ah95w7iikxgqsmixlacn2vlh8n9jym5";
   };
 
   nativeBuildInputs = [ pkgconfig asciidoc ];

pkgs/tools/filesystems/f2fs-tools/default.nix

···
-{ stdenv, fetchgit, autoconf, automake, libtool, pkgconfig, libuuid }:
+{ stdenv, fetchurl, autoreconfHook, libuuid }:
 
 stdenv.mkDerivation rec {
   name = "f2fs-tools-${version}";
-  version = "1.4.1";
+  version = "1.5.0";
 
-  src = fetchgit {
-    url = git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs-tools.git;
-    rev = "refs/tags/v${version}";
-    sha256 = "16i74r2656q6x4gg5kgjy2fxipr5czbm10r66s34pi2lfczbwhjr";
+  src = fetchurl {
+    url = "http://git.kernel.org/cgit/linux/kernel/git/jaegeuk/f2fs-tools.git/snapshot/${name}.tar.gz";
+    sha256 = "1pdgl78xkagxlmavy6x118wjzz8yvl8n08fc1m6wah9bf93qlhdf";
   };
 
-  buildInputs = [ autoconf automake libtool pkgconfig libuuid ];
-
-  preConfigure = ''
-    sed -i '/AC_SUBST/d' configure.ac
-    autoreconf --install
-  '';
+  nativeBuildInputs = [ autoreconfHook ];
+  buildInputs = [ libuuid ];
 
   meta = with stdenv.lib; {
     homepage = "http://git.kernel.org/cgit/linux/kernel/git/jaegeuk/f2fs-tools.git/";

pkgs/tools/filesystems/zfstools/default.nix

···
 { stdenv, fetchFromGitHub, ruby, zfs }:
 
+let version = "0.3.3"; in
 stdenv.mkDerivation rec {
   name = "zfstools-${version}";
-
-  version = "0.3.2";
 
   src = fetchFromGitHub {
-    sha256 = "1dzfir9413qrmx9kqpndi3l2m09f6l1wspnwn84lm3n1g9cr46nd";
+    sha256 = "1gj6jksc9crmjvhsx8yp3l06b5vcm415l0bmdjcil7jjbfhwwp2k";
     rev = "v${version}";
     repo = "zfstools";
     owner = "bdrewery";
···
     sed -e 's|cmd.*=.*"zfs |cmd = "${zfs}/sbin/zfs |g' -i $out/lib/zfstools/{dataset,snapshot}.rb
   '';
 
-  meta = {
+  meta = with stdenv.lib; {
     inherit version;
-    homepage = https://github.com/bdrewery/zfstools;
-    description = "OpenSolaris-like and compatible auto snapshotting script for ZFS";
+    inherit (src.meta) homepage;
+    description = "OpenSolaris-compatible auto-snapshotting script for ZFS";
     longDescription = ''
       zfstools is an OpenSolaris-like and compatible auto snapshotting script
       for ZFS, which also supports auto snapshotting mysql databases.
     '';
-
-    license = stdenv.lib.licenses.bsd2;
+    license = licenses.bsd2;
   };
 }

pkgs/tools/inputmethods/fcitx/fcitx-configtool.nix

···
-{ stdenv, fetchurl, pkgconfig, cmake, fcitx, gtk3, isocodes }:
+{ stdenv, fetchurl, makeWrapper, pkgconfig, cmake, fcitx, gtk3, isocodes, gnome3 }:
 
 stdenv.mkDerivation rec {
   name = "fcitx-configtool-0.4.8";
···
     sha256 = "1vaim0namw58bfafbvws1vgd4010p19zwqfbx6bd1zi5sgchdg0f";
   };
 
-  buildInputs = [ fcitx cmake isocodes pkgconfig gtk3 ];
+  buildInputs = [ makeWrapper fcitx cmake isocodes pkgconfig gtk3
+    gnome3.defaultIconTheme ];
+
+  preFixup = ''
+    wrapProgram $out/bin/fcitx-config-gtk3 \
+      --prefix XDG_DATA_DIRS : "$XDG_ICON_DIRS";
+  '';
 }
 

pkgs/tools/misc/colord/default.nix

···
   configureFlags = [
     "--with-udevrulesdir=$out/lib/udev/rules.d"
     "--with-systemdsystemunitdir=$(out)/etc/systemd/system"
+    "--localstatedir=/var"
     "--disable-bash-completion"
   ];
 
+  # don't touch /var at install time, colord creates what it needs at runtime
+  postPatch = ''
+    sed -i -e "s|if test -w .*;|if false;|" src/Makefile.in
+    sed -i -e "s|if test -w .*;|if false;|" src/Makefile.am
+  '';
+
   buildInputs = [ glib polkit pkgconfig intltool gusb libusb1 lcms2 sqlite systemd dbus gobjectIntrospection
                   bashCompletion argyllcms automake autoconf libgudev ];
 
   postInstall = ''
-    rm -fr $out/var/lib/colord
     mkdir -p $out/etc/bash_completion.d
     cp -v data/colormgr $out/etc/bash_completion.d
   '';

pkgs/tools/misc/parallel/default.nix

···
 { fetchurl, stdenv, perl, makeWrapper, procps }:
 
 stdenv.mkDerivation rec {
-  name = "parallel-20151122";
+  name = "parallel-20151222";
 
   src = fetchurl {
     url = "mirror://gnu/parallel/${name}.tar.bz2";
-    sha256 = "0phn9dlkqlq3cq468ypxbbn78bsjcin743pyvf8ip4qg6jz662jm";
+    sha256 = "03czpnsj77xxzqxzzr1b39ym9acn94hknzbilbh28v5q1wk7r4mf";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/tools/misc/snapper/default.nix

···
-{ stdenv, fetchgit, autoconf, automake, boost, pkgconfig, libtool, acl, libxml2, btrfsProgs, dbus_libs, docbook_xsl, libxslt, docbook_xml_dtd_45,  diffutils, pam, utillinux, attr, gettext }:
+{ stdenv, fetchgit, autoconf, automake, boost, pkgconfig, libtool, acl, libxml2, btrfs-progs, dbus_libs, docbook_xsl, libxslt, docbook_xml_dtd_45,  diffutils, pam, utillinux, attr, gettext }:
 
 stdenv.mkDerivation rec {
   name = "snapper-0.2.4";
···
     sha256 = "ec4b829430bd7181995e66a26ac86e8ac71c27e77faf8eb06db71d645c6f859b";
   };
 
-  buildInputs = [ autoconf automake boost pkgconfig libtool acl libxml2 btrfsProgs dbus_libs docbook_xsl libxslt docbook_xml_dtd_45 diffutils pam utillinux attr gettext ];
+  buildInputs = [ autoconf automake boost pkgconfig libtool acl libxml2 btrfs-progs dbus_libs docbook_xsl libxslt docbook_xml_dtd_45 diffutils pam utillinux attr gettext ];
 
   patchPhase = ''
     # work around missing btrfs/version.h; otherwise, use "-DHAVE_BTRFS_VERSION_H"

pkgs/tools/misc/system-config-printer/default.nix

···
       ( cd $out/share/system-config-printer/troubleshoot
         mv .__init__.py-wrapped __init__.py
       )
+
+      # Upstream issue: https://github.com/twaugh/system-config-printer/issues/28
+      sed -i -e "s|/usr/bin|$out/bin|" "$out/share/dbus-1/services/org.fedoraproject.Config.Printing.service"
     '';
 
   meta = {
     homepage = http://cyberelk.net/tim/software/system-config-printer/;
+    platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/tools/misc/tldr/default.nix

···
+{stdenv, clang, fetchurl, curl}:
+
+with stdenv.lib;
+
+let version = "1.0"; in
+stdenv.mkDerivation {
+  name = "tldr-${version}";
+
+  src = fetchurl {
+    url = "https://github.com/tldr-pages/tldr-cpp-client/archive/v${version}.tar.gz";
+    sha256 = "11k2pc4vfhx9q3cfd1145sdwhis9g0zhw4qnrv7s7mqnslzrrkgw";
+  };
+
+  meta = {
+    inherit version;
+    description = "Simplified and community-driven man pages";
+    longDescription = ''
+      tldr pages gives common use cases for commands, so you don't need to hunt through a man page for the correct flags.
+    '';
+    homepage = http://tldr-pages.github.io;
+    license = licenses.mit;
+    maintainers = [maintainers.taeer];
+    platforms = platforms.linux;
+
+  };
+
+  buildInputs = [curl clang];
+
+  preBuild = ''
+    cd src
+  '';
+
+  installPhase = ''
+    install -d $prefix/bin
+    install tldr $prefix/bin
+  '';
+}

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

···
 
   src = fetchurl {
     url = "http://yt-dl.org/downloads/${meta.version}/${name}.tar.gz";
-    sha256 = "cceeb606e723c0291de85eecb9a551ca887f3be4db786ad621011a9201a482b1";
+    sha256 = "0b0pk8h2iswdiyf65c0zcwcad9dm2hid67fnfafj7d3ikp4kfbvk";
   };
 
   buildInputs = [ makeWrapper zip pandoc ];
···
     ''wrapProgram $out/bin/youtube-dl --prefix PATH : "${ffmpeg}/bin"'';
 
   meta = with stdenv.lib; {
-    version = "2015.11.24";
+    version = "2016.01.01";
     homepage = http://rg3.github.io/youtube-dl/;
     repositories.git = https://github.com/rg3/youtube-dl.git;
     description = "Command-line tool to download videos from YouTube.com and other sites";

pkgs/tools/networking/babeld/default.nix

···
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  name = "babeld-1.5.1";
+  name = "babeld-1.6.1";
 
   src = fetchurl {
     url = "http://www.pps.univ-paris-diderot.fr/~jch/software/files/${name}.tar.gz";
-    sha256 = "1ch9nn2jmmpyq6c7106lzd3cfnxq4ychjx0pvwn960kssn2cgakk";
+    sha256 = "1d45f12mhlxsf8jlpgb1gig5bjg5izdkfk173rd9a1wi7s82pisl";
   };
 
   preBuild = ''

pkgs/tools/networking/connman/default.nix

···
 { stdenv, fetchgit, autoconf, automake, libtool, pkgconfig, openconnect, file,
-  openvpn, vpnc, glib, dbus, iptables, gnutls, policykit, polkit,
+  openvpn, vpnc, glib, dbus, iptables, gnutls, polkit,
   wpa_supplicant, readline6, pptp, ppp, tree }:
 
 stdenv.mkDerivation rec {
···
   };
 
   buildInputs = [ autoconf automake libtool pkgconfig openconnect polkit
-                  file openvpn vpnc glib dbus iptables gnutls policykit
+                  file openvpn vpnc glib dbus iptables gnutls
                   wpa_supplicant readline6 pptp ppp tree ];
 
   preConfigure = ''
···
     cp ./client/connmanctl $out/sbin/connmanctl
   '';
 
-  meta = {
+  meta = with stdenv.lib; {
     description = "Provides a daemon for managing internet connections";
     homepage = "https://connman.net/";
-    maintainers = [ stdenv.lib.maintainers.matejc ];
+    maintainers = [ maintainers.matejc ];
     # tested only on linux, might work on others also
-    platforms = stdenv.lib.platforms.linux;
-    license = stdenv.lib.licenses.gpl2;
+    platforms = platforms.linux;
+    license = licenses.gpl2;
   };
 }

pkgs/tools/networking/dhcping/default.nix

···
+{ stdenv, fetchurl }:
+
+let version = "1.2"; in
+stdenv.mkDerivation {
+  name = "dhcping-${version}";
+
+  src = fetchurl {
+    sha256 = "0sk4sg3hn88n44dxikipf3ggfj3ixrp22asb7nry9p0bkfaqdvrj";
+    url = "http://www.mavetju.org/download/dhcping-${version}.tar.gz";
+  };
+
+  enableParallelBuilding = true;
+
+  doCheck = true;
+
+  meta = with stdenv.lib; {
+    inherit version;
+    description = "Send DHCP request to find out if a DHCP server is running";
+    longDescription = ''
+      dhcping sends either a DHCPREQUEST or DHCPINFORM packet to the server
+      and waits for an answer. Then, if a DHCPREQUEST was send, it will send
+      a DHCPRELEASE back to the server.
+
+      This program should be installed setuid root or ran by root only, as it
+      requires the privileges to bind itself to port 68 (bootpc). Root
+      privileges are dropped as soon as the program has bound itself to that
+      port.
+    '';
+    homepage = http://www.mavetju.org/unix/general.php;
+    license = licenses.bsd2;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ nckx ];
+  };
+ }

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

···
-{fetchurl, stdenv, gupnp, gssdp, pkgconfig, gtk3, libuuid, intltool, gupnp_av, gnome3, makeWrapper}:
+{fetchurl, stdenv, gupnp, gssdp, pkgconfig, gtk3, libuuid, intltool, gupnp_av, gnome3, gnome2, makeWrapper}:
 
 stdenv.mkDerivation rec {
   name = "gupnp-tools-${version}";
···
     sha256 = "160dgh9pmlb85qfavwqz46lqawpshs8514bx2b57f9rbiny8kbij";
   };
 
-  buildInputs = [gupnp libuuid gssdp pkgconfig gtk3 intltool gupnp_av 
-                 gnome3.defaultIconTheme gnome3.gnome_themes_standard makeWrapper];
+  buildInputs = [gupnp libuuid gssdp pkgconfig gtk3 intltool gupnp_av
+                 gnome2.gnome_icon_theme makeWrapper];
 
   postInstall = ''
-    wrapProgram "$out/bin/gupnp-av-cp" --prefix XDG_DATA_DIRS : "${gtk3}/share:${gnome3.gnome_themes_standard}/share:${gnome3.defaultIconTheme}/share:$out/share"
-    wrapProgram "$out/bin/gupnp-universal-cp" --prefix XDG_DATA_DIRS : "${gtk3}/share:${gnome3.gnome_themes_standard}/share:${gnome3.defaultIconTheme}/share:$out/share"
+    for program in gupnp-av-cp gupnp-universal-cp; do
+      wrapProgram "$out/bin/$program" \
+        --prefix XDG_DATA_DIRS : "${gtk3}/share:${gnome3.gnome_themes_standard}/share:${gnome2.gnome_icon_theme}/share:$out/share"
+    done
   '';
+
+  meta = {
+    platforms = stdenv.lib.platforms.linux;
+  };
 }

pkgs/tools/networking/netcat/default.nix

···
-{stdenv, fetchurl}:
+{ stdenv, fetchurl }:
 
 stdenv.mkDerivation {
   name = "netcat-gnu-0.7.1";
+
   src = fetchurl {
     url = mirror://sourceforge/netcat/netcat-0.7.1.tar.bz2;
     sha256 = "1frjcdkhkpzk0f84hx6hmw5l0ynpmji8vcbaxg8h5k2svyxz0nmm";
+  };
+
+  meta = with stdenv.lib; {
+    description = "Utility which reads and writes data across network connections";
+    homepage = http://netcat.sourceforge.net/;
+    license = licenses.gpl2Plus;
   };
 }

pkgs/tools/networking/network-manager/default.nix

···
 
   preConfigure = ''
     substituteInPlace tools/glib-mkenums --replace /usr/bin/perl ${perl}/bin/perl
-    substituteInPlace src/ppp-manager/nm-ppp-manager.c --replace /sbin/modprobe /run/current-system/sw/sbin/modprobe
-    substituteInPlace src/devices/nm-device.c --replace /sbin/modprobe /run/current-system/sw/sbin/modprobe
+    substituteInPlace src/NetworkManagerUtils.c --replace /sbin/modprobe /run/current-system/sw/sbin/modprobe
     substituteInPlace data/85-nm-unmanaged.rules \
       --replace /bin/sh ${stdenv.shell} \
       --replace /usr/sbin/ethtool ${ethtool}/sbin/ethtool \

pkgs/tools/networking/offlineimap/default.nix

···
-{ pkgs, fetchurl, buildPythonPackage, sqlite3 }:
+{ stdenv, fetchFromGitHub, buildPythonPackage, sqlite3 }:
 
 buildPythonPackage rec {
-  version = "6.6.0";
+  version = "6.6.1";
   name = "offlineimap-${version}";
   namePrefix = "";
 
-  src = fetchurl {
-    url = "https://github.com/OfflineIMAP/offlineimap/archive/v${version}.tar.gz";
-    sha256 = "1x33zxjm3y2p54lbcsgflrs6v2zq785y2k0xi6xia6akrvjmh4n4";
+  src = fetchFromGitHub {
+    owner = "OfflineIMAP";
+    repo = "offlineimap";
+    rev = "v${version}";
+    sha256 = "0nn1qkxqy84h0a2acd1yx861wslh2fjfznkcq15856npbd34yqy5";
   };
 
   doCheck = false;
···
   meta = {
     description = "Synchronize emails between two repositories, so that you can read the same mailbox from multiple computers";
     homepage = "http://offlineimap.org";
-    license = pkgs.lib.licenses.gpl2Plus;
-    maintainers = [ pkgs.lib.maintainers.garbas ];
+    license = stdenv.lib.licenses.gpl2Plus;
+    maintainers = [ stdenv.lib.maintainers.garbas ];
   };
 }

pkgs/tools/networking/pcapc/default.nix

···
+{ stdenv, fetchFromGitHub, libpcap }:
+
+let version = "2015-03-06"; in
+stdenv.mkDerivation rec {
+  name = "pcapc-${version}";
+
+  src = fetchFromGitHub {
+    sha256 = "02j45wmxy8qcji0giwx3364pbqb6849s8y0xfvzx40g98mssl027";
+    rev = "9dddf52e65c8cff72c7c11758a951b31bf083436";
+    repo = "pcapc";
+    owner = "pfactum";
+  };
+
+  buildInputs = [ libpcap ];
+
+  makeFlags = [ "PREFIX=$(out)" ];
+
+  enableParallelBuilding = true;
+
+  doCheck = false;
+
+  postInstall = ''
+    install -Dm644 {.,$out/share/doc/pcapc}/README.md
+  '';
+
+  meta = with stdenv.lib; {
+    inherit version;
+    inherit (src.meta) homepage;
+    description = "Compile libpcap filter expressions into BPF opcodes";
+    license = licenses.gpl3;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ nckx ];
+  };
+}

pkgs/tools/networking/pingtcp/default.nix

···
+{ stdenv, fetchgit, cmake }:
+
+let version = "0.0.3"; in
+stdenv.mkDerivation {
+  name = "pingtcp-${version}";
+
+  # This project uses git submodules, which fetchFromGitHub doesn't support:
+  src = fetchgit {
+    sha256 = "0an4dbwcp2qv1n068q0s34lz88vl1z2rqfh3j9apbq7bislsrwdd";
+    rev = "refs/tags/v${version}";
+    url = "https://github.com/LanetNetwork/pingtcp.git";
+  };
+
+  nativeBuildInputs = [ cmake ];
+
+  postPatch = ''
+    substituteInPlace {.,pfcquirks}/CMakeLists.txt \
+      --replace "-march=native" ""
+  '';
+
+  enableParallelBuilding = true;
+
+  doCheck = false;
+
+  postInstall = ''
+    install -Dm644 {..,$out/share/doc/pingtcp}/README.md
+  '';
+
+  meta = with stdenv.lib; {
+    inherit version;
+    description = "Measure TCP handshake time";
+    homepage = https://github.com/LanetNetwork/pingtcp;
+    license = licenses.gpl3;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ nckx ];
+  };
+}

pkgs/tools/networking/wget/default.nix

···
 { stdenv, fetchurl, gettext, libidn, pkgconfig
 , perl, perlPackages, LWP, python3
-, libiconv, libpsl, openssl ? null }:
+, libiconv, libpsl ? null, openssl ? null }:
 
 stdenv.mkDerivation rec {
   name = "wget-1.17.1";

pkgs/tools/security/pass/default.nix

···
 
   meta = with stdenv.lib; {
     description = "Stores, retrieves, generates, and synchronizes passwords securely";
-    homepage    = http://zx2c4.com/projects/password-store/;
+    homepage    = http://www.passwordstore.org/;
     license     = licenses.gpl2Plus;
     maintainers = with maintainers; [ lovek323 the-kenny ];
     platforms   = platforms.unix;

pkgs/tools/security/sudo/default.nix

···
     "--with-rundir=/run/sudo"
     "--with-vardir=/var/db/sudo"
     "--with-logpath=/var/log/sudo.log"
+    "--with-iologdir=/var/log/sudo-io"
     "--with-sendmail=${sendmailPath}"
   ] ++ stdenv.lib.optional withInsults [
     "--with-insults"

pkgs/tools/system/facter/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "facter-${version}";
-  version = "3.0.2";
+  version = "3.1.3";
   src = fetchurl {
     url = "https://downloads.puppetlabs.com/facter/${name}.tar.gz";
-    sha256 = "1myf1r827bh3n0snkzwj2jnc0sax9bq6z1vv9gr90rqr73lixvig";
+    sha256 = "1ngp3xjdh6x1w7lsi4lji2xzqp0x950jngcdlq11lcr0wfnzwyxj";
   };
 
   libyamlcpp_ = libyamlcpp.override { makePIC = true; };

pkgs/tools/text/a2ps/default.nix

···
+{ stdenv, fetchurl, libpaper, gperf, file }:
+
+stdenv.mkDerivation rec {
+  name = "a2ps-4.14";
+  src = fetchurl {
+    url = "mirror://gnu/a2ps/${name}.tar.gz";
+    sha256 = "195k78m1h03m961qn7jr120z815iyb93gwi159p1p9348lyqvbpk";
+  };
+
+  postPatch = ''
+    substituteInPlace afm/make_fonts_map.sh --replace "/bin/rm" "rm"
+    substituteInPlace tests/defs.in --replace "/bin/rm" "rm"
+  '';
+
+  buildInputs = [ libpaper gperf file ];
+
+  meta = with stdenv.lib; {
+    description = "An Anyithing to PostScript converter and pretty-printer";
+    longDescription = ''
+      GNU a2ps converts files into PostScript for printing or viewing. It uses a nice default format,
+      usually two pages on each physical page, borders surrounding pages, headers with useful information
+      (page number, printing date, file name or supplied header), line numbering, symbol substitution as
+      well as pretty printing for a wide range of programming languages.
+    '';
+    homepage = http://www.inf.enst.fr/~demaille/a2ps/index.html;
+    license = licenses.gpl3Plus;
+    maintainers = [ maintainers.bennofs ];
+    platforms = platforms.linux;
+
+  };
+}

pkgs/top-level/all-packages.nix

···
 
   buildMaven = callPackage ../build-support/build-maven.nix {};
 
+  cmark = callPackage ../development/libraries/cmark { };
+
   dotnetenv = callPackage ../build-support/dotnetenv {
     dotnetfx = dotnetfx40;
   };
···
   "3dfsb" = callPackage ../applications/misc/3dfsb {
     glibc = glibc.override { debugSymbols = true; };
   };
+
+  a2ps = callPackage ../tools/text/a2ps { };
 
   abduco = callPackage ../tools/misc/abduco { };
 
···
 
   inherit (androidenv) androidsdk_4_4 androidndk;
 
+  androidsdk = androidenv.androidsdk_6_0;
+
   arc-gtk-theme = callPackage ../misc/themes/arc { };
 
   aria2 = callPackage ../tools/networking/aria2 {
···
 
   bsod = callPackage ../misc/emulators/bsod { };
 
-  btrfsProgs = callPackage ../tools/filesystems/btrfsprogs { };
+  btrfs-progs = callPackage ../tools/filesystems/btrfs-progs { };
 
   bwm_ng = callPackage ../tools/networking/bwm-ng { };
 
···
   dhcpdump = callPackage ../tools/networking/dhcpdump { };
 
   dhcpcd = callPackage ../tools/networking/dhcpcd { };
+
+  dhcping = callPackage ../tools/networking/dhcping { };
 
   di = callPackage ../tools/system/di { };
 
···
 
   gupnp_igd = callPackage ../development/libraries/gupnp-igd {};
 
-  gupnptools = callPackage ../tools/networking/gupnp-tools {};
+  gupnp-tools = callPackage ../tools/networking/gupnp-tools {};
 
   gvpe = callPackage ../tools/networking/gvpe { };
 
···
 
   bully = callPackage ../tools/networking/bully { };
 
+  pcapc = callPackage ../tools/networking/pcapc { };
+
   pdnsd = callPackage ../tools/networking/pdnsd { };
 
   peco = callPackage ../tools/text/peco { };
···
   pinentry_qt5 = qt5.callPackage ../tools/security/pinentry/qt5.nix {
     libcap = if stdenv.isDarwin then null else libcap;
   };
+
+  pingtcp = callPackage ../tools/networking/pingtcp { };
 
   pius = callPackage ../tools/security/pius { };
 
···
 
   sysbench = callPackage ../development/tools/misc/sysbench {};
 
-  system_config_printer = callPackage ../tools/misc/system-config-printer {
+  system-config-printer = callPackage ../tools/misc/system-config-printer {
     libxml2 = libxml2Python;
    };
 
···
   tiny8086 = callPackage ../applications/virtualization/8086tiny { };
 
   tlsdate = callPackage ../tools/networking/tlsdate { };
+
+  tldr = callPackage ../tools/misc/tldr { };
 
   tmate = callPackage ../tools/misc/tmate { };
 
···
   xsensors = callPackage ../os-specific/linux/xsensors { };
 
   xcruiser = callPackage ../applications/misc/xcruiser { };
+
+  xxkb = callPackage ../applications/misc/xxkb { };
 
   unarj = callPackage ../tools/archivers/unarj { };
 
···
 
   polkit_qt4 = callPackage ../development/libraries/polkit-qt-1 { };
 
-  policykit = callPackage ../development/libraries/policykit { };
-
   poppler = callPackage ../development/libraries/poppler { lcms = lcms2; };
 
   poppler_min = poppler.override { # TODO: maybe reduce even more
···
     libdrm = if stdenv.isLinux then libdrm else null;
   } // { inherit xlibsWrapper; } );
 
-  xorgReplacements = callPackage ../servers/x11/xorg/replacements.nix { };
-
   xorgVideoUnichrome = callPackage ../servers/x11/xorg/unichrome/default.nix { };
 
   xwayland = callPackage ../servers/x11/xorg/xwayland.nix { };
···
 
   subunit = callPackage ../development/libraries/subunit { };
 
-  surf = callPackage ../applications/misc/surf {
+  surf = callPackage ../applications/networking/browsers/surf {
     webkit = webkitgtk2;
   };
 
···
   xvidcap = callPackage ../applications/video/xvidcap {
     inherit (gnome) scrollkeeper libglade;
   };
+
+  xzgv = callPackage ../applications/graphics/xzgv { };
 
   yate = callPackage ../applications/misc/yate { };
 
···
 
   cups_filters = callPackage ../misc/cups/filters.nix { };
 
+  cups-pk-helper = callPackage ../misc/cups/cups-pk-helper.nix { };
+
   crashplan = callPackage ../applications/backup/crashplan { };
 
   gutenprint = callPackage ../misc/drivers/gutenprint { };
 
   gutenprintBin = callPackage ../misc/drivers/gutenprint/bin.nix { };
 
-  cupsBjnp = callPackage ../misc/cups/drivers/cups-bjnp { };
+  cups-bjnp = callPackage ../misc/cups/drivers/cups-bjnp { };
 
   darcnes = callPackage ../misc/emulators/darcnes { };
 
···
     };
   };
 
-  saneBackends = callPackage ../applications/graphics/sane/backends {
+  sane-backends = callPackage ../applications/graphics/sane/backends {
     gt68xxFirmware = config.sane.gt68xxFirmware or null;
     snapscanFirmware = config.sane.snapscanFirmware or null;
   };
 
-  saneBackendsGit = callPackage ../applications/graphics/sane/backends/git.nix {
+  sane-backends-git = callPackage ../applications/graphics/sane/backends/git.nix {
     gt68xxFirmware = config.sane.gt68xxFirmware or null;
     snapscanFirmware = config.sane.snapscanFirmware or null;
   };
 
   mkSaneConfig = callPackage ../applications/graphics/sane/config.nix { };
 
-  saneFrontends = callPackage ../applications/graphics/sane/frontends.nix { };
+  sane-frontends = callPackage ../applications/graphics/sane/frontends.nix { };
 
   sct = callPackage ../tools/X11/sct {};
 
···
   wine = callPackage ../misc/emulators/wine {
     wineRelease = config.wine.release or "stable";
     wineBuild = config.wine.build or "wine32";
+    pulseaudioSupport = config.pulseaudio or stdenv.isLinux;
   };
   wineStable = wine.override { wineRelease = "stable"; };
   wineUnstable = lowPrio (wine.override { wineRelease = "unstable"; });
···
 
   xsane = callPackage ../applications/graphics/sane/xsane.nix {
     libpng = libpng12;
-    saneBackends = saneBackends;
   };
 
   xwiimote = callPackage ../misc/drivers/xwiimote {
···
   cheetahTemplate = pythonPackages.cheetah; # 2015-06-15
   clangAnalyzer = clang-analyzer;  # added 2015-02-20
   cool-old-term = cool-retro-term; # added 2015-01-31
+  cupsBjnp = cups-bjnp; # added 2016-01-02
   cv = progress; # added 2015-09-06
   enblendenfuse = enblend-enfuse;	# 2015-09-30
   exfat-utils = exfat;                  # 2015-09-11
   firefoxWrapper = firefox-wrapper;
   fuse_exfat = exfat;                   # 2015-09-11
   grantlee5 = qt5.grantlee;  # added 2015-12-19
+  gupnptools = gupnp-tools;  # added 2015-12-19
   htmlTidy = html-tidy;  # added 2014-12-06
   inherit (haskell.compiler) jhc uhc;   # 2015-05-15
   inotifyTools = inotify-tools;
···
   signon = qt5.signon;  # added 2015-12-19
   speedtest_cli = speedtest-cli;  # added 2015-02-17
   sqliteInteractive = sqlite-interactive;  # added 2014-12-06
+  system_config_printer = system-config-printer;  # added 2016-01-03
   telepathy_qt5 = qt5.telepathy;  # added 2015-12-19
   x11 = xlibsWrapper; # added 2015-09
   xf86_video_nouveau = xorg.xf86videonouveau; # added 2015-09
···
   manpages = man-pages; # added 2015-12-06
   mssys = ms-sys; # added 2015-12-13
   virtviewer = virt-viewer; # added 2015-12-24
+  saneBackends = sane-backends; # added 2016-01-02
+  saneBackendsGit = sane-backends-git; # added 2016-01-02
+  saneFrontends = sane-frontends; # added 2016-01-02
+  btrfsProgs = btrfs-progs; # added 2016-01-03
 };
 
 tweakAlias = _n: alias: with lib;

pkgs/top-level/emacs-packages.nix

···
     };
   };
 
-  async = melpaBuild rec {
-    pname   = "async";
-    version = "1.5";
-    src = fetchFromGitHub {
-      owner  = "jwiegley";
-      repo   = "emacs-async";
-      rev    = "v${version}";
-      sha256 = "1yq1aby4n5k3caasynhxhakng01qp4099zjbsm633d351ib3h20g";
-    };
-    meta = {
-      description = "Asynchronous processing in Emacs";
-      license = gpl3Plus;
-    };
-  };
-
   auctex = melpaBuild rec {
     pname   = "auctex";
     version = "11.87.7";
···
     meta = {
       description = "Extensible package for writing and formatting TeX files in GNU Emacs and XEmacs";
       homepage = https://www.gnu.org/software/auctex/;
-      license = gpl3Plus;
-    };
-  };
-
-  auto-complete = melpaBuild rec {
-    pname = "auto-complete";
-    version = "1.4.0";
-    src = fetchFromGitHub {
-      owner = pname;
-      repo  = pname;
-      rev   = "v${version}";
-      sha256 = "050lb8qjq7ra35mqp6j6qkwbvq5zj3yhz73aym5kf1vjd42rmjcw";
-    };
-    packageRequires = [ popup ];
-    meta = {
-      description = "Auto-complete extension for Emacs";
-      homepage = http://cx4a.org/software/auto-complete/;
       license = gpl3Plus;
     };
   };
···
     fileSpecs = [ "Documentation/with-editor.texi" "lisp/with-editor.el" ];
     meta = magit.meta // {
       description = "Use the Emacsclient as EDITOR of child processes library for Emacs";
-    };
-  };
-
-  markdown-mode = melpaBuild rec {
-    pname   = "markdown-mode";
-    version = "2.0";
-    src = fetchFromGitHub {
-      owner  = "defunkt";
-      repo   = pname;
-      rev    = "v${version}";
-      sha256 = "1l2w0j9xl8pipz61426s79jq2yns42vjvysc6yjc29kbsnhalj29";
-    };
-    meta = {
-      description = "Major mode for editing markdown files in Emacs";
-      license = gpl3Plus;
     };
   };
 

pkgs/top-level/perl-packages.nix

···
   };
 
   URI = buildPerlPackage {
-    name = "URI-1.68";
+    name = "URI-1.69";
     src = fetchurl {
-      url = mirror://cpan/authors/id/E/ET/ETHER/URI-1.68.tar.gz;
-      sha256 = "c840d30f7657bfd4b2acbb311bd764232911cd3dc97e92415fbd0a242185c358";
+      url = mirror://cpan/authors/id/E/ET/ETHER/URI-1.69.tar.gz;
+      sha256 = "0bdlk1cn7ipy4kdylrn73yz9i2k39ikm1cqvh9hq0vvbcbm1cjxp";
     };
     meta = {
       description = "Uniform Resource Identifiers (absolute and relative)";

pkgs/top-level/python-packages.nix

···
       sha256 = "e61768fa19934bd176799f90bda3ea9f49a5def21fa2523a8e47df8a48e730e9";
     };
 
-    buildInputs = with self; [ pkgs.btrfsProgs ];
+    buildInputs = with self; [ pkgs.btrfs-progs ];
     propagatedBuildInputs = with self; [ contextlib2 pyxdg pycparser alembic ]
       ++ optionals (!isPyPy) [ cffi ];
 
···
 
   decorator = buildPythonPackage rec {
     name = "decorator-${version}";
-    version = "4.0.4";
+    version = "4.0.6";
 
     src = pkgs.fetchurl {
       url = "http://pypi.python.org/packages/source/d/decorator/${name}.tar.gz";
-      sha256 = "1qf3iiv401vhsdmf4bd08fwb3fq4xq769q2yl7zqqr1iml7w3l2s";
+      sha256 = "1c6254597777fd003da2e8fb503c3dbf3d9e8f8d55f054709c0e65be3467209c";
     };
-
-    # no idea what that file is doing there (probably bad release)
-    preCheck = ''
-      rm src/tests/x.py
-    '';
 
     meta = {
       homepage = http://pypi.python.org/pypi/decorator;
···
     };
   };
 
+  git-sweep = buildPythonPackage rec {
+    name = "git-sweep-0.1.1";
+
+    src = pkgs.fetchurl {
+      url = "https://pypi.python.org/packages/source/g/git-sweep/${name}.tar.gz";
+      sha256 = "1csp0zd049d643d409rfivbswwzrayb4i6gkypp5mc27fb1z2afd";
+    };
+
+    propagatedBuildInputs = with self; [ GitPython ];
+
+    meta = {
+      description = "A command-line tool that helps you clean up Git branches";
+      homepage = http://lab.arc90.com/2012/04/03/git-sweep/;
+      license = licenses.mit;
+      maintainers = with maintainers; [ pSub ];
+    };
+  };
+
   glances = buildPythonPackage rec {
     name = "glances-${version}";
     version = "2.4.2";
···
     # failed tests: https://code.google.com/p/psutil/issues/detail?id=434
     doCheck = false;
 
+    buildInputs = optional stdenv.isDarwin pkgs.darwin.IOKit;
+
     meta = {
       description = "Process and system utilization information interface for python";
       homepage = http://code.google.com/p/psutil/;
···
     buildInputs = with self; [ nose coverage pkgs.glibcLocales flake8 ];
     propagatedBuildInputs = with self; [ matplotlib pandas ];
 
+    # Performance test fails
+    prePatch = ''
+      rm tqdm/tests/tests_perf.py
+    '';
+
     preBuild = ''
       export LC_ALL="en_US.UTF-8"
     '';
-
-    doCheck = !(isPy27); # Performance test fails
 
     meta = {
       description = "A Fast, Extensible Progress Meter";
···
   };
 
   libvirt = let
-    version = "1.2.19";
+    version = "1.3.0";
   in assert version == pkgs.libvirt.version; pkgs.stdenv.mkDerivation rec {
     name = "libvirt-python-${version}";
 
     src = pkgs.fetchurl {
       url = "http://libvirt.org/sources/python/${name}.tar.gz";
-      sha256 = "0jgcggrwaz9512wzlkgxirq56cr7zq2ihmg8qv95nhryqnq67aw8";
+      sha256 = "0z7w79mkx7w322d2mf9d4bz56mmfic3nx0q4bc6fa063aay42z89";
     };
 
     buildInputs = with self; [ python pkgs.pkgconfig pkgs.libvirt lxml ];

pkgs/top-level/release-small.nix

···
   perl = all;
   pkgconfig = all;
   pmccabe = linux;
-  policykit = linux;
   portmap = linux;
   procps = linux;
   python = allBut cygwin;

pkgs/top-level/release.nix

···
         { inherit (import ../stdenv/linux/make-bootstrap-tools.nix { system = "x86_64-linux"; }) dist test; };
 
       stdenvBootstrapTools.x86_64-darwin =
-        { inherit (import ../stdenv/pure-darwin/make-bootstrap-tools.nix) dist test; };
+        { inherit (import ../stdenv/darwin/make-bootstrap-tools.nix { system = "x86_64-darwin"; }) dist test; };
 
     } // (mapTestOn ((packagePlatforms pkgs) // rec {