Merge remote-tracking branch 'origin/master'

doc/default.nix

···
   + ''
     echo ${nixpkgsVersion} > .version
 
-    xmllint --noout --nonet --xinclude --noxincludenode \
-      --relaxng ${docbook5}/xml/rng/docbook/docbook.rng \
-      manual.xml
+    # validate against relaxng schema
+    xmllint --nonet --xinclude --noxincludenode manual.xml --output manual-full.xml
+    ${jing}/bin/jing ${docbook5}/xml/rng/docbook/docbook.rng manual-full.xml
 
     dst=$out/share/doc/nixpkgs
     mkdir -p $dst

nixos/lib/make-disk-image.nix

···
   postVM ? ""
 
 , name ? "nixos-disk-image"
+
+, format ? "raw"
 }:
 
 with lib;
···
     { preVM =
         ''
           mkdir $out
-          diskImage=$out/nixos.img
-          ${pkgs.vmTools.qemu}/bin/qemu-img create -f raw $diskImage "${toString diskSize}M"
+          diskImage=$out/nixos.${if format == "qcow2" then "qcow2" else "img"}
+          ${pkgs.vmTools.qemu}/bin/qemu-img create -f ${format} $diskImage "${toString diskSize}M"
           mv closure xchg/
         '';
       buildInputs = [ pkgs.utillinux pkgs.perl pkgs.e2fsprogs pkgs.parted ];

nixos/maintainers/scripts/ec2/amazon-image.nix

···
     ];
 
   system.build.amazonImage = import ../../../lib/make-disk-image.nix {
-    inherit pkgs lib config;
+    inherit lib config;
+    pkgs = import ../../../.. { inherit (pkgs) system; }; # ensure we use the regular qemu-kvm package
     partitioned = config.ec2.hvm;
     diskSize = if config.ec2.hvm then 2048 else 8192;
+    format = "qcow2";
     configFile = pkgs.writeText "configuration.nix"
       ''
         {

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

···
 prebuiltNix() {
     machine="$1"
     if [ "$machine" = x86_64 ]; then
-        return /nix/store/xryr9g56h8yjddp89d6dw12anyb4ch7c-nix-1.10
+        echo /nix/store/xryr9g56h8yjddp89d6dw12anyb4ch7c-nix-1.10
     elif [[ "$machine" =~ i.86 ]]; then
-        return /nix/store/2w92k5wlpspf0q2k9mnf2z42prx3bwmv-nix-1.10
+        echo /nix/store/2w92k5wlpspf0q2k9mnf2z42prx3bwmv-nix-1.10
     else
         echo "$0: unsupported platform"
         exit 1

nixos/modules/profiles/headless.nix

···
 
   # Don't allow emergency mode, because we don't have a console.
   systemd.enableEmergencyMode = false;
+
+  # Being headless, we don't need a GRUB splash image.
+  boot.loader.grub.splashImage = null;
 }

nixos/modules/virtualisation/amazon-grow-partition.nix

···
 
 { config, lib, pkgs, ... }:
 
-with lib;
-
-let
-
-  growpart = pkgs.stdenv.mkDerivation {
-    name = "growpart";
-    src = pkgs.fetchurl {
-      url = "https://launchpad.net/cloud-utils/trunk/0.27/+download/cloud-utils-0.27.tar.gz";
-      sha256 = "16shlmg36lidp614km41y6qk3xccil02f5n3r4wf6d1zr5n4v8vd";
-    };
-    patches = [ ./growpart-util-linux-2.26.patch ];
-    buildPhase = ''
-      cp bin/growpart $out
-      sed -i 's|awk|gawk|' $out
-      sed -i 's|sed|gnused|' $out
-    '';
-    dontInstall = true;
-    dontPatchShebangs = true;
-  };
-
-in
-
 {
-
-  config = mkIf config.ec2.hvm {
-
+  config = lib.mkIf config.ec2.hvm {
     boot.initrd.extraUtilsCommands = ''
       copy_bin_and_libs ${pkgs.gawk}/bin/gawk
       copy_bin_and_libs ${pkgs.gnused}/bin/sed
       copy_bin_and_libs ${pkgs.utillinux}/sbin/sfdisk
-      cp -v ${growpart} $out/bin/growpart
+      cp -v ${pkgs.cloud-utils}/bin/growpart $out/bin/growpart
       ln -s sed $out/bin/gnused
     '';
 
···
         udevadm settle
       fi
     '';
-
   };
-
 }

nixos/modules/virtualisation/amazon-image.nix

···
         fi
 
         if ! [ -e "$metaDir/user-data" ]; then
-          wget -q -O "$metaDir/user-data" http://169.254.169.254/1.0/user-data
-          chmod 600 "$metaDir/user-data"
+          wget -q -O "$metaDir/user-data" http://169.254.169.254/1.0/user-data && chmod 600 "$metaDir/user-data"
         fi
 
         if ! [ -e "$metaDir/hostname" ]; then

nixos/release.nix

···
   tests.ipv6 = callTest tests/ipv6.nix {};
   tests.jenkins = callTest tests/jenkins.nix {};
   tests.kde4 = callTest tests/kde4.nix {};
+  tests.keymap = callSubTests tests/keymap.nix {};
   tests.initrdNetwork = callTest tests/initrd-network.nix {};
   tests.kubernetes = hydraJob (import tests/kubernetes.nix { system = "x86_64-linux"; });
   tests.latestKernel.login = callTest tests/login.nix { latestKernel = true; };

nixos/tests/ec2.nix

···
       modules = [
         ../maintainers/scripts/ec2/amazon-image.nix
         ../modules/testing/test-instrumentation.nix
-        ../modules/profiles/minimal.nix
         ../modules/profiles/qemu-guest.nix
         { ec2.hvm = true;
 
···
               ln -s vda /dev/xvda
               ln -s vda1 /dev/xvda1
             '';
+
+          # Needed by nixos-rebuild due to the lack of network
+          # access. Mostly copied from
+          # modules/profiles/installation-device.nix.
+          system.extraDependencies =
+            [ pkgs.stdenv pkgs.busybox pkgs.perlPackages.ArchiveCpio
+              pkgs.unionfs-fuse pkgs.mkinitcpio-nfs-utils
+            ];
         }
       ];
     }).config.system.build.amazonImage;
···
       metaData = pkgs.stdenv.mkDerivation {
         name = "metadata";
         buildCommand = ''
-          mkdir -p $out/2011-01-01
-          ln -s ${pkgs.writeText "userData" userData} $out/2011-01-01/user-data
           mkdir -p $out/1.0/meta-data
+          ln -s ${pkgs.writeText "userData" userData} $out/1.0/user-data
           echo "${hostname}" > $out/1.0/meta-data/hostname
           echo "(unknown)" > $out/1.0/meta-data/ami-manifest-path
         '' + optionalString (sshPublicKey != null) ''
···
           my $imageDir = ($ENV{'TMPDIR'} // "/tmp") . "/vm-state-machine";
           mkdir $imageDir, 0700;
           my $diskImage = "$imageDir/machine.qcow2";
-          system("qemu-img create -f qcow2 -o backing_file=${image}/nixos.img $diskImage") == 0 or die;
+          system("qemu-img create -f qcow2 -o backing_file=${image}/nixos.qcow2 $diskImage") == 0 or die;
           system("qemu-img resize $diskImage 10G") == 0 or die;
 
           # Note: we use net=169.0.0.0/8 rather than
···
     '';
     script = ''
       $machine->start;
-      $machine->waitForFile("/root/user-data");
+      $machine->waitForFile("/etc/ec2-metadata/user-data");
       $machine->waitForUnit("sshd.service");
 
       $machine->succeed("grep unknown /etc/ec2-metadata/ami-manifest-path");
···
       # Just to make sure resizing is idempotent.
       $machine->shutdown;
       $machine->start;
-      $machine->waitForFile("/root/user-data");
+      $machine->waitForFile("/etc/ec2-metadata/user-data");
     '';
   };
 
···
         imports = [
           <nixpkgs/nixos/modules/virtualisation/amazon-image.nix>
           <nixpkgs/nixos/modules/testing/test-instrumentation.nix>
+          <nixpkgs/nixos/modules/profiles/qemu-guest.nix>
         ];
         environment.etc.testFile = {
           text = "whoa";

nixos/tests/keymap.nix

···
+{ system ? builtins.currentSystem }:
+
+with import ../lib/testing.nix { inherit system; };
+
+let
+  testReader = pkgs.writeScript "test-input-reader" ''
+    #!${pkgs.stdenv.shell}
+    readInput() {
+      touch /tmp/reader.ready
+      echo "Waiting for '$1' to be typed"
+      read -r -n1 c
+      if [ "$c" = "$2" ]; then
+        echo "SUCCESS: Got back '$c' as expected."
+        echo 0 >&2
+      else
+        echo "FAIL: Expected '$2' but got '$c' instead."
+        echo 1 >&2
+      fi
+    }
+
+    main() {
+      error=0
+      while [ $# -gt 0 ]; do
+        ret="$((readInput "$2" "$3" | systemd-cat -t "$1") 2>&1)"
+        if [ $ret -ne 0 ]; then error=1; fi
+        shift 3
+      done
+      return $error
+    }
+
+    main "$@"; echo -n $? > /tmp/reader.exit
+  '';
+
+  mkReaderInput = testname: { qwerty, expect }: with pkgs.lib; let
+    lq = length qwerty;
+    le = length expect;
+    msg = "`qwerty' (${lq}) and `expect' (${le}) lists"
+        + " need to be of the same length!";
+    result = flatten (zipListsWith (a: b: [testname a b]) qwerty expect);
+  in if lq != le then throw msg else result;
+
+  mkKeyboardTest = layout: { extraConfig ? {}, tests }: with pkgs.lib; let
+    readerInput = flatten (mapAttrsToList mkReaderInput tests);
+    perlStr = val: "'${escape ["'" "\\"] val}'";
+    perlReaderInput = concatMapStringsSep ", " perlStr readerInput;
+  in makeTest {
+    name = "keymap-${layout}";
+
+    machine.i18n.consoleKeyMap = mkOverride 900 layout;
+    machine.services.xserver.layout = mkOverride 900 layout;
+    machine.imports = [ ./common/x11.nix extraConfig ];
+
+    testScript = ''
+      sub waitCatAndDelete ($) {
+        return $machine->succeed(
+          "for i in \$(seq 600); do if [ -e '$_[0]' ]; then ".
+          "cat '$_[0]' && rm -f '$_[0]' && exit 0; ".
+          "fi; sleep 0.1; done; echo timed out after 60 seconds >&2; exit 1"
+        );
+      };
+
+      sub mkTest ($$) {
+        my ($desc, $cmd) = @_;
+
+        my @testdata = (${perlReaderInput});
+        my $shellTestdata = join ' ', map { "'".s/'/'\\'''/gr."'" } @testdata;
+
+        subtest $desc, sub {
+          $machine->succeed("$cmd ${testReader} $shellTestdata &");
+          while (my ($testname, $qwerty, $expect) = splice(@testdata, 0, 3)) {
+            waitCatAndDelete "/tmp/reader.ready";
+            $machine->sendKeys($qwerty);
+          };
+          my $exitcode = waitCatAndDelete "/tmp/reader.exit";
+          die "tests for $desc failed" if $exitcode ne 0;
+        };
+      }
+
+      $machine->waitForX;
+
+      mkTest "VT keymap", "openvt -sw --";
+      mkTest "Xorg keymap", "DISPLAY=:0 xterm -fullscreen -e";
+    '';
+  };
+
+in pkgs.lib.mapAttrs mkKeyboardTest {
+  azerty = {
+    tests = {
+      azqw.qwerty = [ "q" "w" ];
+      azqw.expect = [ "a" "z" ];
+      altgr.qwerty = [ "alt_r-2" "alt_r-3" "alt_r-4" "alt_r-5" "alt_r-6" ];
+      altgr.expect = [ "~"       "#"       "{"       "["       "|"       ];
+    };
+
+    extraConfig.i18n.consoleKeyMap = "azerty/fr";
+    extraConfig.services.xserver.layout = "fr";
+  };
+
+  colemak = {
+    tests = {
+      homerow.qwerty = [ "a" "s" "d" "f" "j" "k" "l" "semicolon" ];
+      homerow.expect = [ "a" "r" "s" "t" "n" "e" "i" "o"         ];
+    };
+
+    extraConfig.i18n.consoleKeyMap = "en-latin9";
+    extraConfig.services.xserver.layout = "us";
+    extraConfig.services.xserver.xkbVariant = "colemak";
+  };
+
+  dvorak = {
+    tests = {
+      homerow.qwerty = [ "a" "s" "d" "f" "j" "k" "l" "semicolon" ];
+      homerow.expect = [ "a" "o" "e" "u" "h" "t" "n" "s"         ];
+      symbols.qwerty = [ "q" "w" "e" "minus" "equal" ];
+      symbols.expect = [ "'" "," "." "["     "]"     ];
+    };
+  };
+
+  dvp = {
+    tests = {
+      homerow.qwerty = [ "a" "s" "d" "f" "j" "k" "l" "semicolon" ];
+      homerow.expect = [ "a" "o" "e" "u" "h" "t" "n" "s"         ];
+      numbers.qwerty = map (x: "shift-${x}")
+                       [ "1" "2" "3" "4" "5" "6" "7" "8" "9" "0" "minus" ];
+      numbers.expect = [ "%" "7" "5" "3" "1" "9" "0" "2" "4" "6" "8" ];
+      symbols.qwerty = [ "1" "2" "3" "4" "5" "6" "7" "8" "9" "0" "minus" ];
+      symbols.expect = [ "&" "[" "{" "}" "(" "=" "*" ")" "+" "]" "!" ];
+    };
+
+    extraConfig.services.xserver.layout = "us";
+    extraConfig.services.xserver.xkbVariant = "dvp";
+  };
+
+  neo = {
+    tests = {
+      layer1.qwerty = [ "f"           "j"                     ];
+      layer1.expect = [ "e"           "n"                     ];
+      layer2.qwerty = [ "shift-f"     "shift-j"     "shift-6" ];
+      layer2.expect = [ "E"           "N"           "$"       ];
+      layer3.qwerty = [ "caps_lock-d" "caps_lock-f"           ];
+      layer3.expect = [ "{"           "}"                     ];
+    };
+
+    extraConfig.services.xserver.layout = "de";
+    extraConfig.services.xserver.xkbVariant = "neo";
+  };
+
+  qwertz = {
+    tests = {
+      zy.qwerty = [ "z" "y" ];
+      zy.expect = [ "y" "z" ];
+      altgr.qwerty = map (x: "alt_r-${x}")
+                     [ "q" "less" "7" "8" "9" "0" ];
+      altgr.expect = [ "@" "|"    "{" "[" "]" "}" ];
+    };
+
+    extraConfig.i18n.consoleKeyMap = "de";
+    extraConfig.services.xserver.layout = "de";
+  };
+}

pkgs/applications/editors/idea/default.nix

···
     };
   };
 
+  idea15-ultimate = buildIdea rec {
+    name = "idea-ultimate-${version}";
+    version = "15.0.5";
+    build = "IU-143.2332.3";
+    description = "Integrated Development Environment (IDE) by Jetbrains, requires paid license";
+    license = stdenv.lib.licenses.unfree;
+    src = fetchurl {
+      url = "https://download.jetbrains.com/idea/ideaIU-${version}.tar.gz";
+      sha256 = "1hvc5cmbfpp0qad0236ffh3g7zwfk64rh5bkkb750h3387jz7nr2";
+    };
+  };
+
   idea-ultimate = buildIdea rec {
     name = "idea-ultimate-${version}";
     version = "2016.1";

pkgs/applications/misc/cbatticon/default.nix

···
-{ stdenv, fetchzip, gtk, libnotify, unzip, glib, pkgconfig }:
+{ stdenv, fetchFromGitHub, pkgconfig, gettext, glib, gtk3, libnotify }:
 
 stdenv.mkDerivation rec {
 
   name = "cbatticon-${version}";
-  version = "1.4.2";
+  version = "1.6.4";
 
-  src = fetchzip {
-    url = "https://github.com/valr/cbatticon/archive/${version}.zip";
-    sha256 = "0ixkxvlrn84b8nh75c9s2gvxnycis89mf047iz8j38814979di5l";
+  src = fetchFromGitHub {
+    owner = "valr";
+    repo = "cbatticon";
+    rev = version;
+    sha256 = "0m3bj408mbini97kq0cdf048lnfkdn7bd8ikbfijd7dwfdzv27i5";
   };
 
   makeFlags = "PREFIX=$(out)";
 
-  buildInputs =  [ gtk libnotify unzip glib pkgconfig ];
+  nativeBuildInputs = [ pkgconfig gettext ];
+
+  buildInputs =  [ glib gtk3 libnotify ];
 
   meta = with stdenv.lib; {
-    description = "A lightweight and fast battery icon that sits in your system tray";
+    description = "Lightweight and fast battery icon that sits in the system tray";
     homepage = https://github.com/valr/cbatticon;
     license = licenses.gpl2;
     maintainers = [ maintainers.iElectric ];

pkgs/applications/misc/librecad/default.nix

···
 { stdenv, fetchurl, qt4, muparser, which, boost, pkgconfig }:
 
 stdenv.mkDerivation rec {
-  version = "2.0.8";
+  version = "2.0.9";
   name = "librecad-${version}";
 
   src = fetchurl {
     url = "https://github.com/LibreCAD/LibreCAD/tarball/${version}";
     name = name + ".tar.gz";
-    sha256 = "110vn1rvzidg8k6ifz1zws2wsn4cd05xl5ha0hbff2ln7izy84zc";
+    sha256 = "0npr2nxwmx1qil7lqhkh6yvkw7dwym0nfashxjglxspjallqjya7";
   };
 
   patchPhase = ''

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

···
 , libevent, expat, libjpeg, snappy
 , libpng, libxml2, libxslt, libcap
 , xdg_utils, yasm, minizip, libwebp
-, libusb1, libexif, pciutils, nss
+, libusb1, pciutils, nss
 
 , python, pythonPackages, perl, pkgconfig
 , nspr, udev, kerberos
···
 
 # optional dependencies
 , libgcrypt ? null # gnomeSupport || cupsSupport
+, libexif ? null # only needed for Chromium before version 51
 
 # package customization
 , enableSELinux ? false, libselinux ? null
···
     use_system_flac = true;
     use_system_libevent = true;
     use_system_libexpat = true;
-    use_system_libexif = true;
     use_system_libjpeg = true;
-    use_system_libpng = true;
+    use_system_libpng = versionOlder upstream-info.version "51.0.0.0";
     use_system_libwebp = true;
     use_system_libxml = true;
     use_system_opus = true;
···
     libevent expat libjpeg snappy
     libpng libxml2 libxslt libcap
     xdg_utils yasm minizip libwebp
-    libusb1 libexif
+    libusb1
   ];
 
   # build paths and release info
···
       ++ optionals gnomeSupport [ gnome.GConf libgcrypt ]
       ++ optional enableSELinux libselinux
       ++ optionals cupsSupport [ libgcrypt cups ]
-      ++ optional pulseSupport libpulseaudio;
+      ++ optional pulseSupport libpulseaudio
+      ++ optional (versionOlder version "51.0.0.0") libexif;
 
     patches = [
       ./patches/build_fixes_46.patch
···
         -e "/python_arch/s/: *'[^']*'/: '""'/" \
         build/common.gypi chrome/chrome_tests.gypi
 
-      sed -i -e '/module_path *=.*libexif.so/ {
-        s|= [^;]*|= base::FilePath().AppendASCII("${libexif}/lib/libexif.so")|
-      }' chrome/utility/media_galleries/image_metadata_extractor.cc
+      ${optionalString (versionOlder version "51.0.0.0") ''
+        sed -i -e '/module_path *=.*libexif.so/ {
+          s|= [^;]*|= base::FilePath().AppendASCII("${libexif}/lib/libexif.so")|
+        }' chrome/utility/media_galleries/image_metadata_extractor.cc
+      ''}
 
       sed -i -e '/lib_loader.*Load/s!"\(libudev\.so\)!"${udev}/lib/\1!' \
         device/udev_linux/udev?_loader.cc
 
       sed -i -e '/libpci_loader.*Load/s!"\(libpci\.so\)!"${pciutils}/lib/\1!' \
         gpu/config/gpu_info_collector_linux.cc
+    '' + optionalString (!versionOlder version "51.0.0.0") ''
+      sed -i -re 's/([^:])\<(isnan *\()/\1std::\2/g' \
+        chrome/browser/ui/webui/engagement/site_engagement_ui.cc
     '';
 
     gypFlags = mkGypFlags (gypFlagsUseSystemLibs // {
···
       google_default_client_id = "404761575300.apps.googleusercontent.com";
       google_default_client_secret = "9rIFQjfnkykEmqb6FfjJQD1D";
 
+    } // optionalAttrs (versionOlder version "51.0.0.0") {
+      use_system_libexif = true;
     } // optionalAttrs proprietaryCodecs {
       # enable support for the H.264 codec
       proprietary_codecs = true;

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

···
 # This file is autogenerated from update.sh in the same directory.
 {
   beta = {
-    sha256 = "1lgpjnjhy3idha5b6wp31kdk6knic96dmajyrgn1701q3mq81g1i";
-    sha256bin64 = "1yb3rk38zfgjzka0aim1xc4r0qaz2qkwaq06mjifpkszmfffhyd0";
-    version = "50.0.2661.26";
+    sha256 = "1jwk0x5hjpah0bl4dpirxwyfxv0d0wnkvfgyja91kkbh8471gzmk";
+    sha256bin64 = "10sl3ddd77i1gl3l4yvhkpavfq2bygv7gwql0jnhchmrvyax1cjh";
+    version = "50.0.2661.49";
   };
   dev = {
-    sha256 = "0z9m1mv6pv43y3ccd0nzqg5f9q8qxc8mlmy9y3dc9kqpvmqggnvp";
-    sha256bin64 = "0khsxci970vclfg24b7m8w1jqfkv5rzswgwa62b4r7jzrglx1azj";
-    version = "50.0.2661.18";
+    sha256 = "042h6klyijnhkb4m9lsnfi3qss6pbs4p4981rm4cbc86rsyppkhl";
+    sha256bin64 = "1p6lhd3n9q93fkydxksgfv68vz26yj8i2zx1kqby2z9yc0pdcniq";
+    version = "51.0.2693.2";
   };
   stable = {
-    sha256 = "0kbph3l964bh7cb9yf8nydjaxa20yf8ls5a2vzsj8phz7n20z3f9";
-    sha256bin64 = "1k6nhccdqzzzicwi07nldqfsdlic65i2xfyb7dbasbbg9zl3s9yw";
-    version = "49.0.2623.87";
+    sha256 = "1lmv6nmbqhxmr4340s5i4ypgz2b7vkh0wy5x9v75b5bnscjhk121";
+    sha256bin64 = "1djd2i9phym1d8afv4vfajb7l1bz0ny2wmihwi6jaz712vil4a13";
+    version = "49.0.2623.110";
   };
 }

pkgs/applications/networking/instant-messengers/telegram/tdesktop/default.nix

···
+{ stdenv, lib, fetchFromGitHub, fetchgit, qtbase, qtimageformats
+, breakpad, ffmpeg, openalSoft, openssl, zlib, libexif, lzma, libopus
+, gtk2, glib, cairo, pango, gdk_pixbuf, atk, libappindicator-gtk2
+, libunity, dee, libdbusmenu-glib, libva
+
+, pkgconfig, libxcb, xcbutilwm, xcbutilimage, xcbutilkeysyms
+, libxkbcommon, libpng, libjpeg, freetype, harfbuzz, pcre16
+, xproto, libX11, inputproto, sqlite, dbus
+}:
+
+let
+  system-x86_64 = lib.elem stdenv.system lib.platforms.x86_64;
+in stdenv.mkDerivation rec {
+  name = "telegram-desktop-${version}";
+  version = "0.9.33";
+  qtVersion = lib.replaceStrings ["."] ["_"] qtbase.version;
+
+  src = fetchFromGitHub {
+    owner = "telegramdesktop";
+    repo = "tdesktop";
+    rev = "v${version}";
+    sha256 = "020vwm7h22951v9zh457d82qy5ifp746vwishkvb16h1vwr1qx4s";
+  };
+
+  tgaur = fetchgit {
+    url = "https://aur.archlinux.org/telegram-desktop.git";
+    rev = "df47a864282959b103a08b65844e9088e012fdb3";
+    sha256 = "1v1dbi8yiaf2hgghniykm5qbnda456xj3zfjnbqysn41f5cn40h4";
+  };
+
+  buildInputs = [
+    breakpad ffmpeg openalSoft openssl zlib libexif lzma libopus
+    gtk2 glib libappindicator-gtk2 libunity cairo pango gdk_pixbuf atk
+    dee libdbusmenu-glib libva
+    # Qt dependencies
+    libxcb xcbutilwm xcbutilimage xcbutilkeysyms libxkbcommon
+    libpng libjpeg freetype harfbuzz pcre16 xproto libX11
+    inputproto sqlite dbus
+  ];
+
+  nativeBuildInputs = [ pkgconfig ];
+
+  enableParallelBuilding = true;
+
+  qmakeFlags = [
+    "CONFIG+=release"
+    "DEFINES+=TDESKTOP_DISABLE_AUTOUPDATE"
+    "DEFINES+=TDESKTOP_DISABLE_REGISTER_CUSTOM_SCHEME"
+    "INCLUDEPATH+=${gtk2}/include/gtk-2.0"
+    "INCLUDEPATH+=${glib}/include/glib-2.0"
+    "INCLUDEPATH+=${glib}/lib/glib-2.0/include"
+    "INCLUDEPATH+=${cairo}/include/cairo"
+    "INCLUDEPATH+=${pango}/include/pango-1.0"
+    "INCLUDEPATH+=${gtk2}/lib/gtk-2.0/include"
+    "INCLUDEPATH+=${gdk_pixbuf}/include/gdk-pixbuf-2.0"
+    "INCLUDEPATH+=${atk}/include/atk-1.0"
+    "INCLUDEPATH+=${libappindicator-gtk2}/include/libappindicator-0.1"
+    "INCLUDEPATH+=${libunity}/include/unity"
+    "INCLUDEPATH+=${dee}/include/dee-1.0"
+    "INCLUDEPATH+=${libdbusmenu-glib}/include/libdbusmenu-glib-0.4"
+    "INCLUDEPATH+=${breakpad}/include/breakpad"
+    "LIBS+=-lcrypto"
+    "LIBS+=-lssl"
+    "LIBS+=-lz"
+    "LIBS+=-lgobject-2.0"
+    "LIBS+=-lxkbcommon"
+    "LIBS+=-lX11"
+    "LIBS+=${breakpad}/lib/libbreakpad_client.a"
+    "LIBS+=./../../../Libraries/QtStatic/qtbase/plugins/platforms/libqxcb.a"
+    "LIBS+=./../../../Libraries/QtStatic/qtimageformats/plugins/imageformats/libqwebp.a"
+  ];
+
+  qtSrcs = qtbase.srcs ++ [ qtimageformats.src ];
+  qtPatches = qtbase.patches;
+
+  buildCommand = ''
+    # We don't use nativeBuildInputs to avoid adding system Qt 5 libraries to various paths.
+    export PATH="${qtbase}/bin:$PATH"
+
+    unpackPhase
+    cd "$sourceRoot"
+    patchPhase
+    sed -i 'Telegram/Telegram.pro' \
+      -e 's/CUSTOM_API_ID//g' \
+      -e 's,/usr,/does-not-exist,g' \
+      -e '/LIBS += .*libxkbcommon.a/d' \
+      -e '/LIBS += .*libz.a/d' \
+      -e '/LIBS += .*libbreakpad_client.a/d' \
+      -e 's,-flto ,,g'
+    echo "Q_IMPORT_PLUGIN(QXcbIntegrationPlugin)" >> Telegram/SourceFiles/stdafx.cpp
+
+    ( mkdir -p ../Libraries
+      cd ../Libraries
+      for i in $qtSrcs; do
+        tar -xaf $i
+      done
+      mv qt-everywhere-opensource-src-* QtStatic
+      mv qtbase-opensource-src-* ./QtStatic/qtbase
+      mv qtimageformats-opensource-src-* ./QtStatic/qtimageformats
+      cd QtStatic/qtbase
+      patch -p1 < ../../../$sourceRoot/Telegram/_qtbase_${qtVersion}_patch.diff
+      cd ..
+      for i in $qtPatches; do
+        patch -p1 < $i
+      done
+      ${qtbase.postPatch}
+
+      export configureFlags="-prefix "../../qt" -release -opensource -confirm-license -system-zlib \
+        -system-libpng -system-libjpeg -system-freetype -system-harfbuzz -system-pcre -system-xcb \
+        -system-xkbcommon-x11 -no-opengl -static -nomake examples -nomake tests \
+        -openssl-linked -dbus-linked -system-sqlite -verbose \
+        ${lib.optionalString (!system-x86_64) "-no-sse2"} -no-sse3 -no-ssse3 \
+        -no-sse4.1 -no-sse4.2 -no-avx -no-avx2 -no-mips_dsp -no-mips_dspr2"
+      export dontAddPrefix=1
+      export buildFlags="module-qtbase module-qtimageformats"
+      export installFlags="module-qtbase-install_subtargets module-qtimageformats-install_subtargets"
+
+      ( export MAKEFLAGS=-j$NIX_BUILD_CORES
+        configurePhase
+      )
+      buildPhase
+      installPhase
+    )
+
+    ( mkdir -p Linux/DebugIntermediateStyle
+      cd Linux/DebugIntermediateStyle
+      qmake CONFIG+=debug ../../Telegram/MetaStyle.pro
+      buildPhase
+    )
+    ( mkdir -p Linux/DebugIntermediateLang
+      cd Linux/DebugIntermediateLang
+      qmake CONFIG+=debug ../../Telegram/MetaLang.pro
+      buildPhase
+    )
+
+    ( mkdir -p Linux/ReleaseIntermediate
+      cd Linux/ReleaseIntermediate
+      qmake $qmakeFlags ../../Telegram/Telegram.pro
+      pattern="^PRE_TARGETDEPS +="
+      grep "$pattern" "../../Telegram/Telegram.pro" | sed "s/$pattern//g" | xargs make
+
+      qmake $qmakeFlags ../../Telegram/Telegram.pro
+      buildPhase
+    )
+
+    install -Dm755 Linux/Release/Telegram $out/bin/telegram-desktop
+    mkdir -p $out/share/applications $out/share/kde4/services
+    sed "s,/usr/bin,$out/bin,g" $tgaur/telegramdesktop.desktop > $out/share/applications/telegramdesktop.desktop
+    sed "s,/usr/bin,$out/bin,g" $tgaur/tg.protocol > $out/share/kde4/services/tg.protocol
+    for icon_size in 16 32 48 64 128 256 512; do
+      install -Dm644 "Telegram/SourceFiles/art/icon''${icon_size}.png" "$out/share/icons/hicolor/''${icon_size}x''${icon_size}/apps/telegram-desktop.png"
+    done
+
+    fixupPhase
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Telegram Desktop messaging app";
+    license = licenses.gpl3;
+    platforms = platforms.linux;
+    homepage = "https://desktop.telegram.org/";
+    maintainers = with maintainers; [ abbradar ];
+  };
+}

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

···
   enableOfficialBranding ? false
 }:
 
-let version = "38.7.0"; in
+let version = "38.7.1"; in
 let verName = "${version}"; in
 
 stdenv.mkDerivation rec {
···
 
   src = fetchurl {
     url = "http://archive.mozilla.org/pub/thunderbird/releases/${verName}/source/thunderbird-${verName}.source.tar.bz2";
-    sha256 = "1wbkj8a0p62mcbxlq8yyzrx51xi65qm8f2ccqiv5pb6qd51b5d0v";
+    sha256 = "0a4kbmas0a6wavp8dxkva0fl1y1qrx6b7l3xdjdan7qx7ysmm626";
   };
 
   buildInputs = # from firefox30Pkgs.xulrunner, but without gstreamer and libvpx

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

···
 
 stdenv.mkDerivation rec {
   name = "x2goclient-${version}";
-  version = "4.0.5.0";
+  version = "4.0.5.1";
 
   src = fetchurl {
     url = "http://code.x2go.org/releases/source/x2goclient/${name}.tar.gz";
-    sha256 = "18a2pszh0nq2ir64a1ah1mlzddn4qcd12b339bv30n0y1ir92bi4";
+    sha256 = "04gdccqywas029a76k3r9zhr2mfn385i9r06cmi8mznxpczrhkl4";
   };
 
   buildInputs = [ cups libssh libXpm nxproxy openldap qt4 ];

pkgs/applications/science/logic/cvc4/default.nix

···
   };
 
   buildInputs = [ gmp libantlr3c boost autoreconfHook ];
-  preConfigure = "patchShebangs ./src/";
+  preConfigure = ''
+    patchShebangs ./src/
+    OLD_CPPFLAGS="$CPPFLAGS"
+    export CPPFLAGS="$CPPFLAGS -P"
+  '';
+  postConfigure = ''CPPFLAGS="$OLD_CPPFLAGS"'';
   doChecks = true;
 
   meta = with stdenv.lib; {

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

···
+{ callPackage, fetchgit, lua } :
+let
+  src = fetchgit {
+    url = "https://github.com/grwlf/torch-distro";
+    rev = "f972c4253b14b95b53aefe7b24efa496223e73f2";
+    sha256 = "1lhjhivhyypaic33vj1nsghshsajf7vi6gwsclaf3nqdl27d1h1s";
+  };
+
+in
+  callPackage (import ./torch-distro.nix) { inherit lua src; }

pkgs/applications/science/machine-learning/torch/torch-distro.nix

···
+{ luarocks, lib , stdenv,  writeText , readline,  makeWrapper,
+  less, ncurses, cmake, openblas, coreutils, fetchgit, libuuid, czmq, openssl,
+  gnuplot, fetchurl, lua, src, libjpeg, libpng
+} :
+
+let
+
+  common_meta = {
+    homepage = http://torch.ch;
+    license = stdenv.lib.licenses.bsd3;
+    maintainers = with stdenv.lib.maintainers; [ smironov ];
+    platforms = stdenv.lib.platforms.gnu;
+  };
+
+  distro_src = src;
+
+  default_luarocks = luarocks;
+
+  pkgs_gnuplot = gnuplot;
+
+  luapkgs = rec {
+
+    luarocks = default_luarocks.override {
+      inherit lua;
+    };
+
+    buildLuaRocks = { rockspec ? "", luadeps ? [] , buildInputs ? []
+                    , preBuild ? "" , postInstall ? ""
+                    , runtimeDeps ? [] ,  ... }@args :
+      let
+
+        luadeps_ =
+          luadeps ++
+          (lib.concatMap (d : if d ? luadeps then d.luadeps else []) luadeps);
+
+        runtimeDeps_ =
+          runtimeDeps ++
+          (lib.concatMap (d : if d ? runtimeDeps then d.runtimeDeps else []) luadeps) ++
+          [ lua coreutils ];
+
+        mkcfg = ''
+          export LUAROCKS_CONFIG=config.lua
+          cat >config.lua <<EOF
+            rocks_trees = {
+                 { name = [[system]], root = [[${luarocks}]] }
+               ${lib.concatImapStrings (i : dep :  ", { name = [[dep${toString i}]], root = [[${dep}]] }") luadeps_}
+            };
+
+            variables = {
+              LUA_BINDIR = "$out/bin";
+              LUA_INCDIR = "$out/include";
+              LUA_LIBDIR = "$out/lib/lua/${lua.luaversion}";
+            };
+          EOF
+        '';
+
+      in
+      stdenv.mkDerivation (args // {
+
+        inherit preBuild postInstall;
+
+        inherit luadeps runtimeDeps;
+
+        phases = [ "unpackPhase" "patchPhase" "buildPhase"];
+
+        buildInputs = runtimeDeps ++ buildInputs ++ [ makeWrapper lua ];
+
+        buildPhase = ''
+          eval "$preBuild"
+          ${mkcfg}
+          eval "`${luarocks}/bin/luarocks --deps-mode=all --tree=$out path`"
+          ${luarocks}/bin/luarocks make --deps-mode=all --tree=$out ${rockspec}
+
+          for p in $out/bin/*; do
+            wrapProgram $p \
+              --suffix LD_LIBRARY_PATH ';' "${lib.makeSearchPath "lib" runtimeDeps_}" \
+              --suffix PATH ';' "${lib.makeSearchPath "bin" runtimeDeps_}" \
+              --suffix LUA_PATH ';' "\"$LUA_PATH\"" \
+              --suffix LUA_PATH ';' "\"$out/share/lua/${lua.luaversion}/?.lua;$out/share/lua/${lua.luaversion}/?/init.lua\"" \
+              --suffix LUA_CPATH ';' "\"$LUA_CPATH\"" \
+              --suffix LUA_CPATH ';' "\"$out/lib/lua/${lua.luaversion}/?.so;$out/lib/lua/${lua.luaversion}/?/init.so\""
+          done
+
+          eval "$postInstall"
+        '';
+      });
+
+    # FIXME: doesn't installs lua-files for some reason
+    # lua-cjson = buildLuaPackage {
+    #   name = "lua-cjson";
+    #   src = ./extra/lua-cjson;
+    #   rockspec = "lua-cjson-2.1devel-1.rockspec";
+    # };
+
+    lua-cjson = stdenv.mkDerivation rec {
+      name = "lua-cjson";
+      src = "${distro_src}/extra/lua-cjson";
+
+      preConfigure = ''
+        makeFlags="PREFIX=$out LUA_LIBRARY=$out/lib/lua"
+      '';
+
+      buildInputs = [lua];
+
+      installPhase = ''
+        make install-extra $makeFlags
+      '';
+    };
+
+    luafilesystem = buildLuaRocks {
+      name = "filesystem";
+      src = "${distro_src}/extra/luafilesystem";
+      luadeps = [lua-cjson];
+      rockspec = "rockspecs/luafilesystem-1.6.3-1.rockspec";
+    };
+
+    penlight = buildLuaRocks {
+      name = "penlight";
+      src = "${distro_src}/extra/penlight";
+      luadeps = [luafilesystem];
+    };
+
+    luaffifb = buildLuaRocks {
+      name = "luaffifb";
+      src = "${distro_src}/extra/luaffifb";
+    };
+
+    sundown = buildLuaRocks rec {
+      name = "sundown";
+      src = "${distro_src}/pkg/sundown";
+      rockspec = "rocks/${name}-scm-1.rockspec";
+    };
+
+    cwrap = buildLuaRocks rec {
+      name = "cwrap";
+      src = "${distro_src}/pkg/cwrap";
+      rockspec = "rocks/${name}-scm-1.rockspec";
+    };
+
+    paths = buildLuaRocks rec {
+      name = "paths";
+      src = "${distro_src}/pkg/paths";
+      buildInputs = [cmake];
+      rockspec = "rocks/${name}-scm-1.rockspec";
+    };
+
+    torch = buildLuaRocks rec {
+      name = "torch";
+      src = "${distro_src}/pkg/torch";
+      luadeps = [ paths cwrap ];
+      buildInputs = [ cmake ];
+      rockspec = "rocks/torch-scm-1.rockspec";
+      preBuild = ''
+        substituteInPlace ${rockspec} \
+          --replace '"sys >= 1.0"' ' '
+        export LUA_PATH="$src/?.lua;$LUA_PATH"
+      '';
+      meta = common_meta // {
+        description = "Torch is a machine-learning library";
+        longDescription = ''
+          Torch is the main package in [Torch7](http://torch.ch) where data
+          structures for multi-dimensional tensors and mathematical operations
+          over these are defined. Additionally, it provides many utilities for
+          accessing files, serializing objects of arbitrary types and other
+          useful utilities.
+        '';
+      };
+    };
+
+    dok = buildLuaRocks rec {
+      name = "dok";
+      src = "${distro_src}/pkg/dok";
+      luadeps = [sundown];
+      rockspec = "rocks/${name}-scm-1.rockspec";
+    };
+
+    sys = buildLuaRocks rec {
+      name = "sys";
+      luadeps = [torch];
+      buildInputs = [readline cmake];
+      src = "${distro_src}/pkg/sys";
+      rockspec = "sys-1.1-0.rockspec";
+      preBuild = ''
+        export Torch_DIR=${torch}/share/cmake/torch
+      '';
+    };
+
+    xlua = buildLuaRocks rec {
+      name = "xlua";
+      luadeps = [torch sys];
+      src = "${distro_src}/pkg/xlua";
+      rockspec = "xlua-1.0-0.rockspec";
+    };
+
+    nn = buildLuaRocks rec {
+      name = "nn";
+      luadeps = [torch luaffifb];
+      buildInputs = [cmake];
+      src = "${distro_src}/extra/nn";
+      rockspec = "rocks/nn-scm-1.rockspec";
+      preBuild = ''
+        export Torch_DIR=${torch}/share/cmake/torch
+      '';
+    };
+
+    graph = buildLuaRocks rec {
+      name = "graph";
+      luadeps = [ torch ];
+      buildInputs = [cmake];
+      src = "${distro_src}/extra/graph";
+      rockspec = "rocks/graph-scm-1.rockspec";
+      preBuild = ''
+        export Torch_DIR=${torch}/share/cmake/torch
+      '';
+    };
+
+    nngraph = buildLuaRocks rec {
+      name = "nngraph";
+      luadeps = [ torch nn graph ];
+      buildInputs = [cmake];
+      src = "${distro_src}/extra/nngraph";
+      preBuild = ''
+        export Torch_DIR=${torch}/share/cmake/torch
+      '';
+    };
+
+    image = buildLuaRocks rec {
+      name = "image";
+      luadeps = [ torch dok sys xlua ];
+      buildInputs = [cmake libjpeg libpng];
+      src = "${distro_src}/pkg/image";
+      rockspec = "image-1.1.alpha-0.rockspec";
+      preBuild = ''
+        export Torch_DIR=${torch}/share/cmake/torch
+      '';
+    };
+
+    optim = buildLuaRocks rec {
+      name = "optim";
+      luadeps = [ torch ];
+      buildInputs = [cmake];
+      src = "${distro_src}/pkg/optim";
+      rockspec = "optim-1.0.5-0.rockspec";
+      preBuild = ''
+        export Torch_DIR=${torch}/share/cmake/torch
+      '';
+    };
+
+    gnuplot = buildLuaRocks rec {
+      name = "gnuplot";
+      luadeps = [ torch paths ];
+      runtimeDeps = [ pkgs_gnuplot less ];
+      src = "${distro_src}/pkg/gnuplot";
+      rockspec = "rocks/gnuplot-scm-1.rockspec";
+    };
+
+    unsup = buildLuaRocks rec {
+      name = "unsup";
+      luadeps = [ torch xlua optim ];
+      buildInputs = [ cmake ];
+      src = fetchgit {
+        url = "https://github.com/koraykv/unsup";
+        rev = "1d4632e716dc3c82feecc7dd4b22549df442859f";
+        sha256 = "0npjq3y1cfmk026sdijcw3f766innrmb3qggnxsz62grczhfvgls";
+      };
+      rockspec = "unsup-0.1-0.rockspec";
+      preBuild = ''
+        export Torch_DIR=${torch}/share/cmake/torch
+      '';
+    };
+
+    trepl = buildLuaRocks rec {
+      name = "trepl";
+      luadeps = [torch gnuplot paths penlight graph nn nngraph image gnuplot optim sys dok unsup];
+      runtimeDeps = [ ncurses readline ];
+      src = "${distro_src}/exe/trepl";
+      meta = common_meta // {
+        description = "A pure Lua REPL for Lua(JIT), with heavy support for Torch types.";
+      };
+    };
+
+    lbase64 = buildLuaRocks rec {
+      name = "lbase64";
+      src = fetchgit {
+        url = "https://github.com/LuaDist2/lbase64";
+        rev = "1e9e4f1e0bf589a0ed39f58acc185ec5e213d207";
+        sha256 = "1i1fpy9v6r4w3lrmz7bmf5ppq65925rv90gx39b3pykfmn0hcb9c";
+      };
+    };
+
+    luuid = stdenv.mkDerivation rec {
+      name = "luuid";
+      src = fetchgit {
+        url = "https://github.com/LuaDist/luuid";
+        sha256 = "062gdf1rild11jg46vry93hcbb36b4527pf1dy7q9fv89f7m2nav";
+      };
+
+      preConfigure = ''
+        cmakeFlags="-DLUA_LIBRARY=${lua}/lib/lua/${lua.luaversion} -DINSTALL_CMOD=$out/lib/lua/${lua.luaversion} -DINSTALL_MOD=$out/lib/lua/${lua.luaversion}"
+      '';
+
+      buildInputs = [cmake libuuid lua];
+      meta = {
+        # FIXME: set the exact revision for src
+        broken = true;
+      };
+    };
+
+    # Doesn't work due to missing deps (according to luarocs).
+    itorch = buildLuaRocks rec {
+      name = "itorch";
+      luadeps = [torch gnuplot paths penlight graph nn nngraph image gnuplot
+                  optim sys dok lbase64 lua-cjson luuid];
+      buildInputs = [czmq openssl];
+      src = "${distro_src}/extra/iTorch";
+      meta = {
+        # FIXME: figure out whats wrong with deps
+        broken = true;
+      };
+    };
+
+
+  };
+
+in
+
+luapkgs
+
+

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

···
   gitBase = lib.makeOverridable (import ./git) {
     inherit fetchurl stdenv curl openssl zlib expat perl python gettext gnugrep
       asciidoc xmlto docbook2x docbook_xsl docbook_xml_dtd_45 libxslt cpio tcl
-      tk makeWrapper subversionClient gzip libiconv;
+      tk makeWrapper subversionClient gzip openssh libiconv;
     texinfo = texinfo5;
     svnSupport = false;         # for git-svn support
     guiSupport = false;         # requires tcl/tk

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

···
 
 pythonPackages.buildPythonApplication rec {
   name = "git-cola-${version}";
-  version = "2.2.1";
+  version = "2.5";
 
   src = fetchurl {
     url = "https://github.com/git-cola/git-cola/archive/v${version}.tar.gz";
-    sha256 = "1v1s9gx16xihdcck4qp92bdci8zc6pb5a3z3y8k9jqj97hfkw2nz";
+    sha256 = "0ybjmlwm1plnvqi20y91ci7sgldzwlwn86vyyn9a157h7lf4ngb8";
   };
 
   buildInputs = [ makeWrapper gettext ];

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

···
-{ fetchurl, stdenv, curl, openssl, zlib, expat, perl, python, gettext, cpio, gnugrep, gzip
+{ fetchurl, stdenv, curl, openssl, zlib, expat, perl, python, gettext, cpio
+, gnugrep, gzip, openssh
 , asciidoc, texinfo, xmlto, docbook2x, docbook_xsl, docbook_xml_dtd_45
 , libxslt, tcl, tk, makeWrapper, libiconv
 , svnSupport, subversionClient, perlLibs, smtpPerlLibs
···
     ./docbook2texi.patch
     ./symlinks-in-bin.patch
     ./git-sh-i18n.patch
+    ./ssh-path.patch
   ];
+
+  postPatch = ''
+    for x in connect.c git-gui/lib/remote_add.tcl ; do
+      substituteInPlace "$x" \
+        --subst-var-by ssh "${openssh}/bin/ssh"
+    done
+  '';
 
   buildInputs = [curl openssl zlib expat gettext cpio makeWrapper libiconv]
     ++ stdenv.lib.optionals withManual [ asciidoc texinfo xmlto docbook2x

pkgs/applications/version-management/git-and-tools/git/ssh-path.patch

···
+diff --git a/connect.c b/connect.c
+index fd7ffe1..20cd992 100644
+--- a/connect.c
++++ b/connect.c
+@@ -768,7 +768,7 @@ struct child_process *git_connect(int fd[2], const char *url,
+ 
+ 				ssh = getenv("GIT_SSH");
+ 				if (!ssh)
+-					ssh = "ssh";
++					ssh = "@ssh@";
+ 
+ 				ssh_dup = xstrdup(ssh);
+ 				base = basename(ssh_dup);
+diff --git a/git-gui/lib/remote_add.tcl b/git-gui/lib/remote_add.tcl
+index 50029d0..17b9594 100644
+--- a/git-gui/lib/remote_add.tcl
++++ b/git-gui/lib/remote_add.tcl
+@@ -139,7 +139,7 @@ method _add {} {
+ 		# Parse the location
+ 		if { [regexp {(?:git\+)?ssh://([^/]+)(/.+)} $location xx host path]
+ 		     || [regexp {([^:][^:]+):(.+)} $location xx host path]} {
+-			set ssh ssh
++			set ssh @ssh@
+ 			if {[info exists env(GIT_SSH)]} {
+ 				set ssh $env(GIT_SSH)
+ 			}

pkgs/applications/virtualization/qemu/default.nix

···
 
 with stdenv.lib;
 let
-  version = "2.5.0";
+  version = "2.5.1";
   audio = optionalString (hasSuffix "linux" stdenv.system) "alsa,"
     + optionalString pulseSupport "pa,"
     + optionalString sdlSupport "sdl,";
···
 
   src = fetchurl {
     url = "http://wiki.qemu.org/download/qemu-${version}.tar.bz2";
-    sha256 = "1m3j6xl7msrniidkvr5pw9d44yba5m7hm42xz8xy77v105s8hhrl";
+    sha256 = "0b2xa8604absdmzpcyjs7fix19y5blqmgflnwjzsp1mp7g1m51q2";
   };
 
   buildInputs =

pkgs/build-support/vm/default.nix

···
       mknod -m 666 ${dev}/random  c 1 8
       mknod -m 666 ${dev}/urandom c 1 9
       mknod -m 666 ${dev}/tty     c 5 0
+      mknod -m 666 ${dev}/ttyS0   c 4 64
       mknod ${dev}/rtc     c 254 0
       . /sys/class/block/${hd}/uevent
       mknod ${dev}/${hd} b $MAJOR $MINOR
···
       export PATH=/bin:/usr/bin:${coreutils}/bin
       echo "Starting interactive shell..."
       echo "(To run the original builder: \$origBuilder \$origArgs)"
-      exec ${bash}/bin/sh
+      exec ${busybox}/bin/setsid ${bashInteractive}/bin/bash < /dev/ttyS0 &> /dev/ttyS0
     fi
   '';
 
···
       -nographic -no-reboot \
       -virtfs local,path=/nix/store,security_model=none,mount_tag=store \
       -virtfs local,path=$TMPDIR/xchg,security_model=none,mount_tag=xchg \
-      -drive file=$diskImage,if=virtio,cache=writeback,werror=report \
+      -drive file=$diskImage,if=virtio,cache=unsafe,werror=report \
       -kernel ${kernel}/${img} \
       -initrd ${initrd}/initrd \
       -append "console=ttyS0 panic=1 command=${stage2Init} out=$out mountDisk=$mountDisk loglevel=4" \

pkgs/data/misc/tzdata/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "tzdata-${version}";
-  version = "2016b";
+  version = "2016c";
 
   srcs =
     [ (fetchurl {
         url = "http://www.iana.org/time-zones/repository/releases/tzdata${version}.tar.gz";
-        sha256 = "6392091d92556a32de488ea06a055c51bc46b7d8046c8a677f0ccfe286b3dbdc";
+        sha256 = "0j1dk830rkr1pijfac5wkdifi47k28mmvfys6z07l07jws0xj047";
       })
       (fetchurl {
         url = "http://www.iana.org/time-zones/repository/releases/tzcode${version}.tar.gz";
-        sha256 = "e935c4fe78b5c5da3791f58f3ab7f07fb059a7c71d6b62b69ef345211ae5dfa7";
+        sha256 = "05m4ql1x3b4bmlg0vv1ibz2128mkk4xxnixagcmwlnwkhva1njrl";
       })
     ];
 

pkgs/development/compilers/hhvm/default.nix

···
       gmp libyaml libedit libvpx imagemagick fribidi gperf
     ];
 
-  enableParallelBuilding = true;
+  enableParallelBuilding = false; # occasional build problems;
   dontUseCmakeBuildDir = true;
   NIX_LDFLAGS = "-lpam -L${pam}/lib";
   MYSQL_INCLUDE_DIR="${mariadb}/include/mysql";

pkgs/development/compilers/ios-cross-compile/9.2.nix

···
     description =
     "Provides an iOS cross compiler from 7.1 up to iOS-${version} and ldid";
     platforms = stdenv.lib.platforms.linux;
+    hydraPlatforms = [];
     maintainers = with stdenv.lib.maintainers; [ fxfactorial ];
     license = stdenv.lib.licenses.gpl2;
   };

pkgs/development/compilers/tinycc/default.nix

···
-{ stdenv, fetchurl, perl, texinfo }:
+{ stdenv, fetchurl, fetchgit, perl, texinfo }:
 
 assert stdenv ? glibc;
 
 stdenv.mkDerivation rec {
-  name = "tcc-0.9.26";
+  #name = "tcc-0.9.26";
+  name = "tcc-git-0.9.27pre-20160328";
 
-  src = fetchurl {
-    url = "mirror://savannah/tinycc/${name}.tar.bz2";
-    sha256 = "0wbdbdq6090ayw8bxnbikiv989kykff3m5rzbia05hrnwhd707jj";
+  #src = fetchurl {
+  #  url = "mirror://savannah/tinycc/${name}.tar.bz2";
+  #  sha256 = "0wbdbdq6090ayw8bxnbikiv989kykff3m5rzbia05hrnwhd707jj";
+  #};
+  src = fetchgit {
+    url = "git://repo.or.cz/tinycc.git";
+    rev = "80343ab7d829c21c65f8f9a14dd20158d028549f";
+    sha256 = "1bz75aj93ivb2d8hfk2bczsrwa56lv7vprvdi8c1r5phjvawbshy";
   };
 
   nativeBuildInputs = [ perl texinfo ];

pkgs/development/interpreters/luajit/default.nix

···
 
 stdenv.mkDerivation rec {
   name    = "luajit-${version}";
-  version = "2.0.4";
+  version = "2.1.0-beta1";
+  luaversion = "5.1";
 
   src = fetchurl {
     url    = "http://luajit.org/download/LuaJIT-${version}.tar.gz";
-    sha256 = "0zc0y7p6nx1c0pp4nhgbdgjljpfxsb5kgwp4ysz22l1p2bms83v2";
+    sha256 = "06170d38387c59d1292001a166e7f5524f5c5deafa8705a49a46fa42905668dd";
   };
 
   enableParallelBuilding = true;
···
 
   configurePhase = false;
   buildFlags     = [ "amalg" ]; # Build highly optimized version
-  installPhase   = "make install PREFIX=$out";
+  installPhase   = ''
+    make install INSTALL_INC=$out/include PREFIX=$out
+    ln -s $out/bin/luajit* $out/bin/lua
+    ln -s $out/bin/luajit* $out/bin/luajit
+  '';
 
   meta = with stdenv.lib; {
     description = "high-performance JIT compiler for Lua 5.1";
     homepage    = http://luajit.org;
     license     = licenses.mit;
     platforms   = platforms.linux ++ platforms.darwin;
-    maintainers = [ maintainers.thoughtpolice ];
+    maintainers = with maintainers ; [ thoughtpolice smironov ];
   };
 }

pkgs/development/libraries/breakpad/default.nix

···
+{ stdenv, fetchgit }:
+
+stdenv.mkDerivation {
+  name = "breakpad-2016-03-28";
+  
+  src = fetchgit {
+    url = "https://chromium.googlesource.com/breakpad/breakpad";
+    rev = "512cac3a1b69721ab727f3079f4d29e4580467b1";
+    sha256 = "0v7k7racdl2f16mbi3r0vkbkagh0gf6ksnpf3ri28b9pjfngkl5s";
+  };
+
+  breakpad_lss = fetchgit {
+    url = "https://chromium.googlesource.com/linux-syscall-support";
+    rev = "08056836f2b4a5747daff75435d10d649bed22f6";
+    sha256 = "1ryshs2nyxwa0kn3rlbnd5b3fhna9vqm560yviddcfgdm2jyg0hz";
+  };
+
+  enableParallelBuilding = true;
+
+  prePatch = ''
+    cp -r $breakpad_lss src/third_party/lss
+    chmod +w -R src/third_party/lss
+  '';
+}

pkgs/development/libraries/dee/default.nix

···
+{ stdenv, fetchurl, python, pkgconfig
+, glib, icu, gobjectIntrospection }:
+
+stdenv.mkDerivation rec {
+  name = "dee-${version}";
+  version = "1.2.7";
+
+  src = fetchurl {
+    url = "https://launchpad.net/dee/1.0/${version}/+download/${name}.tar.gz";
+    sha256 = "12mzffk0lyd566y46x57jlvb9af152b4dqpasr40zal4wrn37w0v";
+  };
+
+  buildInputs = [ glib gobjectIntrospection icu ];
+  nativeBuildInputs = [ python pkgconfig ];
+
+  enableParallelBuilding = true;
+
+  meta = with stdenv.lib; {
+    description = "A library that uses DBus to provide objects allowing you to create Model-View-Controller type programs across DBus";
+    homepage = "https://launchpad.net/dee";
+    license = licenses.lgpl3;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ abbradar ];
+  };
+}

pkgs/development/libraries/glib/default.nix

···
        substituteInPlace gio/tests/desktop-files/home/applications/epiphany-weather-for-toronto-island-9c6a4e022b17686306243dada811d550d25eb1fb.desktop --replace "Exec=/bin/true" "Exec=${coreutils}/bin/true"
        # Needs machine-id, comment the test
        sed -e '/\/gdbus\/codegen-peer-to-peer/ s/^\/*/\/\//' -i gio/tests/gdbus-peer.c
+       sed -e '/g_test_add_func/ s/^\/*/\/\//' -i gio/tests/gdbus-unix-addresses.c
        # All gschemas fail to pass the test, upstream bug?
        sed -e '/g_test_add_data_func/ s/^\/*/\/\//' -i gio/tests/gschema-compile.c
        # Cannot reproduce the failing test_associations on hydra

pkgs/development/libraries/libgee/0.6.nix

···
+{ stdenv, fetchurl, pkgconfig, glib }:
+
+let
+  ver_maj = "0.6";
+  ver_min = "8";
+in
+stdenv.mkDerivation rec {
+  name = "libgee-${ver_maj}.${ver_min}";
+
+  src = fetchurl {
+    url = "https://download.gnome.org/sources/libgee/${ver_maj}/${name}.tar.xz";
+    sha256 = "1lzmxgz1bcs14ghfp8qqzarhn7s64ayx8c508ihizm3kc5wqs7x6";
+  };
+
+  buildInputs = [ glib ];
+  nativeBuildInputs = [ pkgconfig ];
+
+  doCheck = true;
+
+  meta = with stdenv.lib; {
+    description = "Utility library providing GObject-based interfaces and classes for commonly used data structures";
+    license = licenses.lgpl21Plus;
+    platforms = platforms.linux;
+    homepage = "http://live.gnome.org/Libgee";
+    maintainers = with maintainers; [ abbradar ];
+  };
+}

pkgs/development/libraries/libiberty/default.nix

···
-{ stdenv, fetchurl }:
+{ stdenv, fetchurl, staticBuild ? false }:
 
 stdenv.mkDerivation rec {
   version = "4.9.3";
···
 
   postUnpack = "sourceRoot=\${sourceRoot}/libiberty";
 
-  enable_shared = 1;
+  enable_shared = !staticBuild;
 
   installPhase = ''
-    mkdir -p $out/lib
-    cp pic/libiberty.a $out/lib/libiberty_pic.a
+    mkdir -p $out/lib $out/include
+    cp ../include/libiberty.h $out/include/
+    if [ -z "$enabled_shared" ]; then
+      cp libiberty.a $out/lib/libiberty.a
+    else
+      cp pic/libiberty.a $out/lib/libiberty_pic.a
+    fi
   '';
 
   meta = with stdenv.lib; {

pkgs/development/libraries/libpsl/default.nix

···
 
 let
 
-  listVersion = "2016-03-10";
+  listVersion = "2016-03-30";
   listSources = fetchFromGitHub {
-    sha256 = "10kc0b41y5cn0cnqvalz9i14j1dj6b9wgr21zz3ngqf943q6z5r9";
-    rev = "1e52b7efc42b1505f9580ec15a1d692523db4a3b";
+    sha256 = "0433ck6ykcq6pc48mvgif9f785q0ndprk77jsk58gb5289b87yns";
+    rev = "6ec573d549e25fc89d930bb64939d947bae38f68";
     repo = "list";
     owner = "publicsuffix";
   };

pkgs/development/libraries/libunity/default.nix

···
+{ stdenv, fetchurl, vala, python, intltool, pkgconfig
+, glib, libgee_0_6, gtk3, dee, libdbusmenu-glib
+}:
+
+stdenv.mkDerivation rec {
+  name = "libunity-${version}";
+  version = "6.12.0";
+
+  src = fetchurl {
+    url = "https://launchpad.net/libunity/6.0/${version}/+download/${name}.tar.gz";
+    sha256 = "1nadapl3390x98q1wv2yarh60hzi7ck0d1s8zz9xsiq3zz6msbjd";
+  };
+
+  buildInputs = [ glib libgee_0_6 gtk3 ];
+  propagatedBuildInputs = [ dee libdbusmenu-glib ];
+  nativeBuildInputs = [ vala python intltool pkgconfig ];
+
+  enableParallelBuilding = true;
+
+  meta = with stdenv.lib; {
+    description = "A library for instrumenting- and integrating with all aspects of the Unity shell";
+    homepage = "https://launchpad.net/libunity";
+    license = licenses.lgpl3;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ abbradar ];
+  };
+}

pkgs/development/libraries/pcre/default.nix

···
-{ stdenv, fetchurl, unicodeSupport ? true, cplusplusSupport ? true
+{ stdenv, lib, fetchurl, unicodeSupport ? true, cplusplusSupport ? true
 , windows ? null
+, withCharSize ? 8
 }:
 
 with stdenv.lib;
 
-stdenv.mkDerivation rec {
-  name = "pcre-8.38";
+assert withCharSize != 8 -> !cplusplusSupport;
+
+let
+  charFlags = if withCharSize == 8 then [ ]
+              else if withCharSize == 16 then [ "--enable-pcre16" "--disable-pcre8" ]
+              else if withCharSize == 32 then [ "--enable-pcre32" "--disable-pcre8" ]
+              else abort "Invalid character size";
+
+in stdenv.mkDerivation rec {
+  name = "pcre${lib.optionalString (withCharSize != 8) (toString withCharSize)}-8.38";
+  # FIXME: add "version" attribute and use it in URL
 
   src = fetchurl {
-    url = "ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/${name}.tar.bz2";
+    url = "ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre-8.38.tar.bz2";
     sha256 = "1pvra19ljkr5ky35y2iywjnsckrs9ch2anrf5b0dc91hw8v2vq5r";
   };
 
···
 
   outputs = [ "out" "doc" "man" ];
 
+  # FIXME: Refactor into list!
   configureFlags = ''
     --enable-jit
-    ${if unicodeSupport then "--enable-unicode-properties" else ""}
-    ${if !cplusplusSupport then "--disable-cpp" else ""}
-  '';
+    ${lib.optionalString unicodeSupport "--enable-unicode-properties"}
+    ${lib.optionalString (!cplusplusSupport) "--disable-cpp"}
+  '' + lib.optionalString (charFlags != []) " ${toString charFlags}";
 
   doCheck = with stdenv; !(isCygwin || isFreeBSD);
     # XXX: test failure on Cygwin

pkgs/development/libraries/science/math/openblas/default.nix

···
       optionals (hasAttr "target" config.openblas) [ "TARGET=${config.openblas.target}" ];
     blas64 = if blas64_ != null then blas64_ else hasPrefix "x86_64" stdenv.system;
 
-    version = "0.2.15";
+    version = "0.2.17";
 in
 stdenv.mkDerivation {
   name = "openblas-${version}";
   src = fetchurl {
     url = "https://github.com/xianyi/OpenBLAS/archive/v${version}.tar.gz";
-    sha256 = "0i4hrjx622vw5ff35wm6cnga3ic8hcfa88p1wlj24a3qb770mi3k";
+    sha256 = "1gqdrxgc7qmr3xqq4wqcysjhv7ix4ar7ymn3vk5g97r1xvgkds0g";
     name = "openblas-${version}.tar.gz";
   };
 

pkgs/development/perl-modules/Unicode-String-perl-5-22.patch

···
+diff -ru libunicode-string-perl-2.09.pristine/lib/Unicode/CharName.pm libunicode-string-perl-2.09/lib/Unicode/CharName.pm
+--- libunicode-string-perl-2.09.pristine/lib/Unicode/CharName.pm	2005-10-25 19:11:00.000000000 +0100
++++ libunicode-string-perl-2.09/lib/Unicode/CharName.pm	2012-01-24 12:56:59.730653088 +0000
+@@ -77,7 +77,7 @@
+ 	    return join("", "HANGUL SYLLABLE ", @s)
+ 	}
+     }
+-    _init_names() unless defined %NAMES;
++    _init_names() unless %NAMES;
+     $NAMES{sprintf("%04X",$code)}
+ }

pkgs/development/tools/continuous-integration/jenkins/default.nix

···
     maintainers = [ maintainers.coconnor ];
   };
 
-  buildCommand = "ln -s $src $out";
+  buildCommand = "cp $src $out";
 }

pkgs/development/tools/profiling/oprofile/default.nix

···
 { stdenv, fetchurl, binutils, popt, zlib, pkgconfig, linuxHeaders
-, withGUI ? false , qt4 ? null}:
+, libiberty_static, withGUI ? false , qt4 ? null}:
 
 # libX11 is needed because the Qt build stuff automatically adds `-lX11'.
 assert withGUI -> qt4 != null;
···
     sha256 = "0v1nn38h227bgxjwqf22rjp2iqgjm4ls3gckzifks0x6w5nrlxfg";
   };
 
-  buildInputs = [ binutils zlib popt pkgconfig linuxHeaders ]
+  buildInputs = [ binutils zlib popt pkgconfig linuxHeaders libiberty_static ]
     ++ stdenv.lib.optionals withGUI [ qt4 ];
 
   configureFlags = [

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

···
+{ stdenv, fetchurl, libv4l, gd }:
+
+stdenv.mkDerivation rec {
+  name = "fswebcam-20140113";
+
+  src = fetchurl {
+    url = "http://www.sanslogic.co.uk/fswebcam/files/${name}.tar.gz";
+    sha256 = "3ee389f72a7737700d22e0c954720b1e3bbadc8a0daad6426c25489ba9dc3199";
+  };
+
+  buildInputs =
+    [ libv4l gd ];
+
+  meta = {
+    description = "neat and simple webcam app";
+    homepage = http://www.sanslogic.co.uk/fswebcam;
+    platforms = stdenv.lib.platforms.linux;
+    license = stdenv.lib.licenses.gpl2;
+  };
+}

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

···
 stdenv.mkDerivation rec {
   name = "spl-${configFile}-${version}${optionalString buildKernel "-${kernel.version}"}";
 
-  version = "0.6.5.5";
+  version = "0.6.5.6";
 
   src = fetchFromGitHub {
     owner = "zfsonlinux";
     repo = "spl";
     rev = "spl-${version}";
-    sha256 = "1f49qv648klg2sn1v1wzwd6ls1njjj0hrazz7msd74ayhwm0zcw7";
+    sha256 = "08lbfwsd368sk7dgydabzkyyn2l2n82ifcqakra3xknwgg1ka9bn";
   };
 
   patches = [ ./const.patch ./install_prefix.patch ];

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

···
 stdenv.mkDerivation rec {
   name = "zfs-${configFile}-${version}${optionalString buildKernel "-${kernel.version}"}";
 
-  version = "0.6.5.5";
+  version = "0.6.5.6";
 
   src = fetchFromGitHub {
     owner = "zfsonlinux";
     repo = "zfs";
     rev = "zfs-${version}";
-    sha256 = "0np03p5zkx87a0a5rw629f9m4wp5gd01c1jkh5p7h63mmvaxfdda";
+    sha256 = "0lsb93y5zbwc8fafxzm9vyfpr6fmvl8h86ny4llbd2xy2hnfwk2i";
   };
 
   patches = [ ./nix-build.patch ];

pkgs/servers/identd/oidentd/default.nix

···
 stdenv.mkDerivation rec {
   name = "oidentd-2.0.8";
 
+  CFLAGS = [ "--std=gnu89" ];
+
   src = fetchurl {
     url = "mirror://sourceforge/ojnk/${name}.tar.gz";
     sha256 = "0vzv2086rrxcaavrm3js7aqvyc0grgaqy78x61d8s7r8hz8vwk55";

pkgs/tools/filesystems/ntfs-3g/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "ntfs-3g";
-  version = "2015.3.14";
+  version = "2016.2.22";
   name = "${pname}-${version}";
 
   buildInputs = [ libuuid ] ++ stdenv.lib.optionals crypto [ gnutls libgcrypt ];
···
 
   src = fetchurl {
     url = "http://tuxera.com/opensource/ntfs-3g_ntfsprogs-${version}.tgz";
-    sha256 = "1wiqcmy07y02k3iqq56cscnhg5syisbjj9mxfaid85l3bl0rdycp";
+    sha256 = "180y5y09h30ryf2vim8j30a2npwz1iv9ly5yjmh3wjdkwh2jrdyp";
   };
 
   patchPhase = ''
···
     '';
 
   meta = with stdenv.lib; {
-    homepage = http://www.tuxera.com/community/;
+    homepage = http://www.tuxera.com/community/open-source-ntfs-3g/;
     description = "FUSE-based NTFS driver with full write support";
-    maintainers = [ maintainers.urkud ];
+    maintainers = with maintainers; [ urkud dezgeg ];
     platforms = platforms.linux;
     license = licenses.gpl2Plus; # and (lib)fuse-lite under LGPL2+
   };

pkgs/tools/graphics/enblend-enfuse/default.nix

···
 { stdenv, fetchurl
-, boost, freeglut, glew, gsl, lcms2, libpng, libtiff, libxmi, mesa, vigra
-, help2man, pkgconfig, perl }:
+, boost, freeglut, glew, gsl, lcms2, libpng, libtiff, mesa, vigra
+, help2man, pkgconfig, perl, tetex }:
 
-let version = "4.1.5"; in
 stdenv.mkDerivation rec {
   name = "enblend-enfuse-${version}";
+  version = "4.2";
 
   src = fetchurl {
     url = "mirror://sourceforge/enblend/${name}.tar.gz";
-    sha256 = "08dz73jgrwfhz0kh57kz048qy1c6a35ckqn9xs5rajm449vnw0pg";
+    sha256 = "0j5x011ilalb47ssah50ag0a4phgh1b0wdgxdbbp1gcyjcjf60w7";
   };
 
-  buildInputs = [ boost freeglut glew gsl lcms2 libpng libtiff libxmi mesa vigra ];
+  buildInputs = [ boost freeglut glew gsl lcms2 libpng libtiff mesa vigra ];
 
-  nativeBuildInputs = [ help2man perl pkgconfig ];
+  nativeBuildInputs = [ help2man perl pkgconfig tetex ];
+
+  preConfigure = ''
+    patchShebangs src/embrace
+  '';
 
   enableParallelBuilding = true;
 
-  meta = {
-    inherit version;
+  meta = with stdenv.lib; {
     homepage = http://enblend.sourceforge.net/;
     description = "Blends away the seams in a panoramic image mosaic using a multiresolution spline";
-    license = stdenv.lib.licenses.gpl2;
+    license = licenses.gpl2;
+    maintainers = with maintainers; [ nckx ];
   };
 }

pkgs/tools/misc/cloud-utils/default.nix

···
+{ stdenv, fetchurl }:
+
+stdenv.mkDerivation {
+  name = "cloud-utils-0.27";
+  src = fetchurl {
+    url = "https://launchpad.net/cloud-utils/trunk/0.27/+download/cloud-utils-0.27.tar.gz";
+    sha256 = "16shlmg36lidp614km41y6qk3xccil02f5n3r4wf6d1zr5n4v8vd";
+  };
+  patches = [ ./growpart-util-linux-2.26.patch ];
+  buildPhase = ''
+    mkdir -p $out/bin
+    cp bin/growpart $out/bin/growpart
+    sed -i 's|awk|gawk|' $out/bin/growpart
+    sed -i 's|sed|gnused|' $out/bin/growpart
+  '';
+  dontInstall = true;
+  dontPatchShebangs = true;
+}

pkgs/tools/networking/dhcpcd/default.nix

···
 { stdenv, fetchurl, pkgconfig, udev }:
 
 stdenv.mkDerivation rec {
-  name = "dhcpcd-6.9.4";
+  name = "dhcpcd-6.10.1";
 
   src = fetchurl {
     url = "mirror://roy/dhcpcd/${name}.tar.xz";
-    sha256 = "184vpid8m5175xa2nkh6mmvk8b6z4isfm6nvf4g8l5ggfdsgzwy3";
+    sha256 = "0yxfx3r6ik47rsv1f8q7siw0vas6jcsrbjpaqnx0nn707f6byji8";
   };
 
   buildInputs = [ pkgconfig udev ];
···
     description = "A client for the Dynamic Host Configuration Protocol (DHCP)";
     homepage = http://roy.marples.name/projects/dhcpcd;
     platforms = stdenv.lib.platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.eelco ];
+    maintainers = with stdenv.lib.maintainers; [ eelco fpletz ];
   };
 }

pkgs/tools/system/hwinfo/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "hwinfo-${version}";
-  version = "21.12";
+  version = "21.23";
 
   src = fetchurl {
     url = "https://github.com/opensuse/hwinfo/archive/${version}.tar.gz";
-    sha256 = "01y5jk2jns0a3mgsgmvmpvi5yyc0df7b3yqsg32hn5r2nv17i47p";
+    sha256 = "1a8815zp3a7n2jx0cn0hcr69rfr6vmw8r8grbn5mv61g90bbcj6p";
   };
 
   patchPhase = ''

pkgs/tools/text/namazu/default.nix

···
 
     platforms = stdenv.lib.platforms.gnu;  # arbitrary choice
     maintainers = [ ];
+    broken = true; # File-MMagic is not compatible with our Perl version
   };
 }

pkgs/top-level/all-packages.nix

···
 
   cloogppl = callPackage ../development/libraries/cloog-ppl { };
 
+  cloud-utils = callPackage ../tools/misc/cloud-utils { };
+
   compass = callPackage ../development/tools/compass { };
 
   convmv = callPackage ../tools/misc/convmv { };
···
   ftop = callPackage ../os-specific/linux/ftop { };
 
   fsfs = callPackage ../tools/filesystems/fsfs { };
+
+  fswebcam = callPackage ../os-specific/linux/fswebcam { };
 
   fuseiso = callPackage ../tools/filesystems/fuseiso { };
 
···
   libtorrent = callPackage ../tools/networking/p2p/libtorrent { };
 
   libiberty = callPackage ../development/libraries/libiberty { };
+
+  libiberty_static = callPackage ../development/libraries/libiberty { staticBuild = true; };
 
   libibverbs = callPackage ../development/libraries/libibverbs { };
 
···
 
   clooj = callPackage ../development/interpreters/clojure/clooj.nix { };
 
-  erlangR14 = callPackage ../development/interpreters/erlang/R14.nix { };
   erlangR16 = callPackage ../development/interpreters/erlang/R16.nix { };
   erlangR16_odbc = callPackage ../development/interpreters/erlang/R16.nix { odbcSupport = true; };
   erlangR17 = callPackage ../development/interpreters/erlang/R17.nix { };
···
 
   box2d = callPackage ../development/libraries/box2d { };
   box2d_2_0_1 = callPackage ../development/libraries/box2d/2.0.1.nix { };
+
+  breakpad = callPackage ../development/libraries/breakpad { };
 
   buddy = callPackage ../development/libraries/buddy { };
 
···
   dbus_libs = pkgs.dbus.libs;
   dbus_daemon = pkgs.dbus.daemon;
 
+  dee = callPackage ../development/libraries/dee { };
+
   dhex = callPackage ../applications/editors/dhex { };
 
   double_conversion = callPackage ../development/libraries/double-conversion { };
···
   libgadu = callPackage ../development/libraries/libgadu { };
 
   libgdata = gnome3.libgdata;
+
+  libgee_0_6 = callPackage ../development/libraries/libgee/0.6.nix { };
 
   libgig = callPackage ../development/libraries/libgig { };
 
···
 
   libu2f-server = callPackage ../development/libraries/libu2f-server { };
 
+  libunity = callPackage ../development/libraries/libunity { };
+
   libunistring = callPackage ../development/libraries/libunistring { };
 
   libupnp = callPackage ../development/libraries/pupnp { };
···
   pcre = callPackage ../development/libraries/pcre {
     unicodeSupport = config.pcre.unicode or true;
   };
+  pcre16 = pcre.override {
+    cplusplusSupport = false;
+    withCharSize = 16;
+  };
+  pcre32 = pcre.override {
+    cplusplusSupport = false;
+    withCharSize = 32;
+  };
 
   pcre2 = callPackage ../development/libraries/pcre2 { };
 
···
 
   taskserver = callPackage ../servers/misc/taskserver { };
 
-  telegram-cli = callPackage ../applications/networking/instant-messengers/telegram/telegram-cli/default.nix { };
+  tdesktop = qt55.callPackage ../applications/networking/instant-messengers/telegram/tdesktop { };
+
+  telegram-cli = callPackage ../applications/networking/instant-messengers/telegram/telegram-cli { };
 
   telepathy_gabble = callPackage ../applications/networking/instant-messengers/telepathy/gabble { };
 
···
     enableTelepathy = config.tomahawk.enableTelepathy or false;
     quazip = qt5.quazip.override { qt = qt4; };
   };
+
+  torchPackages = recurseIntoAttrs ( callPackage ../applications/science/machine-learning/torch {
+    lua = luajit ;
+  } );
+
+  torch-repl = lib.setName "torch-repl" torchPackages.trepl;
 
   torchat = callPackage ../applications/networking/instant-messengers/torchat {
     wrapPython = pythonPackages.wrapPython;

pkgs/top-level/perl-packages.nix

···
   };
 
   FinanceQuote = buildPerlPackage rec {
-    name = "Finance-Quote-1.37";
+    name = "Finance-Quote-1.38";
     src = fetchurl {
       url = "mirror://cpan/authors/id/E/EC/ECOCODE/${name}.tar.gz";
-      sha256 = "1b6pbh7f76fb5sa4f0lhx085xy55pprz5v7z7li7pqiyw7i4f4bf";
+      sha256 = "0zhqb27y4vdxn476s2kwm9zl2f970yjcyyybnjm9b406krr2fm59";
     };
-    propagatedBuildInputs = [ CryptSSLeay HTMLTableExtract HTMLTree HTTPMessage LWP DateCalc DateTime JSON ];
+    propagatedBuildInputs = [ CGI CryptSSLeay HTMLTableExtract HTMLTree HTTPMessage LWP DateCalc DateTime JSON ];
     meta = with stdenv.lib; {
       homepage = http://finance-quote.sourceforge.net/;
       description = "Get stock and mutual fund quotes from various exchanges";
···
 
   UnicodeString = buildPerlPackage rec {
     name = "Unicode-String-2.09";
+    patches = [
+      ../development/perl-modules/Unicode-String-perl-5-22.patch
+    ];
     src = fetchurl {
       url = "mirror://cpan/authors/id/G/GA/GAAS/${name}.tar.gz";
       sha256 = "1bgsaf3dgmlgyvi84r42ysc037mr5280amnypa4d98jfjpdvw5y8";

pkgs/top-level/python-packages.nix

···
     buildInputs = with self; [ mock freezegun coverage pkgs.glibcLocales ];
 
     LC_ALL="en_US.UTF-8";
-  };
 
-  meta = {
-    description = "A cli todo application compatible with the todo.txt format";
-    homepage = "https://github.com/bram85/topydo";
-    license = license.gpl3;
+    meta = {
+      description = "A cli todo application compatible with the todo.txt format";
+      homepage = "https://github.com/bram85/topydo";
+      license = licenses.gpl3;
+    };
   };
 
 }