Merge branch 'master' into staging

2024-11-10 08:39:08 +03:00 · 2016-02-17 10:06:31 +01:00 · 2016-02-17 10:06:31 +01:00 · e9520e81b3
commit e9520e81b3
parent ee994dfae6 2f3eae3a87
456 changed files with 22536 additions and 2438 deletions
--- a/doc/haskell-users-guide.md
+++ b/doc/haskell-users-guide.md
@ -234,7 +234,7 @@ library promises to give its users access to GHC's installation paths. Only,
 the library can't possible know that path when it's compiled, because the path
 GHC considers its own is determined only much later, when the user configures
 it through `ghcWithPackages`. So we [patched
-ghc-paths](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/haskell-modules/ghc-paths-nix.patch)
+ghc-paths](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/haskell-modules/patches/ghc-paths-nix.patch)
 to return the paths found in those environment variables at run-time rather
 than trying to guess them at compile-time.

--- a/lib/maintainers.nix
+++ b/lib/maintainers.nix
@ -69,12 +69,14 @@
  coconnor = "Corey O'Connor <coreyoconnor@gmail.com>";
  codsl = "codsl <codsl@riseup.net>";
  codyopel = "Cody Opel <codyopel@gmail.com>";
+  colemickens = "Cole Mickens <cole.mickens@gmail.com>";
  copumpkin = "Dan Peebles <pumpkingod@gmail.com>";
  coroa = "Jonas Hörsch <jonas@chaoflow.net>";
  couchemar = "Andrey Pavlov <couchemar@yandex.ru>";
  cstrahan = "Charles Strahan <charles.c.strahan@gmail.com>";
  cwoac = "Oliver Matthews <oliver@codersoffortune.net>";
  DamienCassou = "Damien Cassou <damien@cassou.me>";
+  dasuxullebt = "Christoph-Simon Senjak <christoph.senjak@googlemail.com>";
  davidak = "David Kleuker <post@davidak.de>";
  davidrusu = "David Rusu <davidrusu.me@gmail.com>";
  dbohdan = "Danyil Bohdan <danyil.bohdan@gmail.com>";
@ -94,10 +96,12 @@
  eduarrrd = "Eduard Bachmakov <e.bachmakov@gmail.com>";
  edwtjo = "Edward Tjörnhammar <ed@cflags.cc>";
  eelco = "Eelco Dolstra <eelco.dolstra@logicblox.com>";
+  ehegnes = "Eric Hegnes <eric.hegnes@gmail.com>";
+  ehmry = "Emery Hemingway <emery@vfemail.net>";
  eikek = "Eike Kettner <eike.kettner@posteo.de>";
  elasticdog = "Aaron Bull Schaefer <aaron@elasticdog.com>";
+  elitak = "Eric Litak <elitak@gmail.com>";
  ellis = "Ellis Whitehead <nixos@ellisw.net>";
-  ehmry = "Emery Hemingway <emery@vfemail.net>";
  epitrochoid = "Mabry Cervin <mpcervin@uncg.edu>";
  ericbmerritt = "Eric Merritt <eric@afiniate.com>";
  ericsagnes = "Eric Sagnes <eric.sagnes@gmail.com>";
@ -105,6 +109,7 @@
  ertes = "Ertugrul Söylemez <ertesx@gmx.de>";
  exi = "Reno Reckling <nixos@reckling.org>";
  exlevan = "Alexey Levan <exlevan@gmail.com>";
+  fadenb = "Tristan Helmich <tristan.helmich+nixos@gmail.com>";
  falsifian = "James Cook <james.cook@utoronto.ca>";
  flosse = "Markus Kohlhase <mail@markus-kohlhase.de>";
  fluffynukeit = "Daniel Austin <dan@fluffynukeit.com>";
@ -182,6 +187,7 @@
  lowfatcomputing = "Andreas Wagner <andreas.wagner@lowfatcomputing.org>";
  lsix = "Lancelot SIX <lsix@lancelotsix.com>";
  ludo = "Ludovic Courtès <ludo@gnu.org>";
+  lukasepple = "Lukas Epple <post@lukasepple.de>";
  lukego = "Luke Gorrie <luke@snabb.co>";
  luispedro = "Luis Pedro Coelho <luis@luispedro.org>";
  lw = "Sergey Sofeychuk <lw@fmap.me>";
@ -218,6 +224,7 @@
  nathan-gs = "Nathan Bijnens <nathan@nathan.gs>";
  nckx = "Tobias Geerinckx-Rice <tobias.geerinckx.rice@gmail.com>";
  nequissimus = "Tim Steinbach <tim@nequissimus.com>";
+  nfjinjing = "Jinjing Wang <nfjinjing@gmail.com>";
  nico202 = "Nicolò Balzarotti <anothersms@gmail.com>";
  notthemessiah = "Brian Cohen <brian.cohen.88@gmail.com>";
  np = "Nicolas Pouillard <np.nix@nicolaspouillard.fr>";
@ -274,6 +281,7 @@
  rushmorem = "Rushmore Mushambi <rushmore@webenchanter.com>";
  rvl = "Rodney Lorrimar <dev+nix@rodney.id.au>";
  rvlander = "Gaëtan André <rvlander@gaetanandre.eu>";
+  ryantm = "Ryan Mulligan <ryan@ryantm.com>";
  rycee = "Robert Helgesson <robert@rycee.net>";
  samuelrivas = "Samuel Rivas <samuelrivas@gmail.com>";
  sander = "Sander van der Burg <s.vanderburg@tudelft.nl>";
@ -289,6 +297,7 @@
  sjmackenzie = "Stewart Mackenzie <setori88@gmail.com>";
  sjourdois = "Stéphane ‘kwisatz’ Jourdois <sjourdois@gmail.com>";
  skeidel = "Sven Keidel <svenkeidel@gmail.com>";
+  sleexyz = "Sean Lee <freshdried@gmail.com>";
  smironov = "Sergey Mironov <ierton@gmail.com>";
  spacefrogg = "Michael Raitza <spacefrogg-nixos@meterriblecrew.net>";
  spencerjanssen = "Spencer Janssen <spencerjanssen@gmail.com>";
@ -322,6 +331,7 @@
  twey = "James ‘Twey’ Kay <twey@twey.co.uk>";
  urkud = "Yury G. Kudryashov <urkud+nix@ya.ru>";
  vandenoever = "Jos van den Oever <jos@vandenoever.info>";
+  vanzef = "Ivan Solyankin <vanzef@gmail.com>";
  vbgl = "Vincent Laporte <Vincent.Laporte@gmail.com>";
  vbmithr = "Vincent Bernardoff <vb@luminar.eu.org>";
  vcunat = "Vladimír Čunát <vcunat@gmail.com>";
--- a/lib/platforms.nix
+++ b/lib/platforms.nix
@ -13,7 +13,7 @@ rec {
  all = linux ++ darwin ++ cygwin ++ freebsd ++ openbsd ++ netbsd ++ illumos;
  none = [];
  allBut = platforms: lists.filter (x: !(builtins.elem x platforms)) all;
-  mesaPlatforms = ["i686-linux" "x86_64-linux" "x86_64-darwin" "armv5tel-linux" "armv6l-linux"];
+  mesaPlatforms = ["i686-linux" "x86_64-linux" "x86_64-darwin" "armv5tel-linux" "armv6l-linux" "armv7l-linux"];
  x86_64 = ["x86_64-linux" "x86_64-darwin" "x86_64-freebsd" "x86_64-openbsd" "x86_64-netbsd" "x86_64-cygwin"];
  i686 = ["i686-linux" "i686-freebsd" "i686-netbsd" "i686-cygwin"];
  arm = ["armv5tel-linux" "armv6l-linux" "armv7l-linux" ];
--- a/nixos/doc/manual/release-notes/rl-unstable.xml
+++ b/nixos/doc/manual/release-notes/rl-unstable.xml
@ -41,6 +41,7 @@ nixos.path = ./nixpkgs-unstable-2015-12-06/nixos;

  <itemizedlist>
    <listitem><para><literal>services/monitoring/longview.nix</literal></para></listitem>
+    <listitem><para><literal>services/networking/pdnsd.nix</literal></para></listitem>
    <listitem><para><literal>services/web-apps/pump.io.nix</literal></para></listitem>
    <listitem><para><literal>services/security/haka.nix</literal></para></listitem>
  </itemizedlist>
--- a/nixos/modules/hardware/all-firmware.nix
+++ b/nixos/modules/hardware/all-firmware.nix
@ -22,7 +22,7 @@ with lib;
  ###### implementation

  config = mkIf config.hardware.enableAllFirmware {
-    hardware.firmware = [ pkgs.firmwareLinuxNonfree ];
+    hardware.firmware = [ pkgs.firmwareLinuxNonfree pkgs.intel2200BGFirmware ];
  };

 }
--- a/nixos/modules/hardware/network/intel-2200bg.nix
+++ b/nixos/modules/hardware/network/intel-2200bg.nix
@ -23,7 +23,7 @@

  config = lib.mkIf config.networking.enableIntel2200BGFirmware {

-    hardware.enableAllFirmware = true;
+    hardware.firmware = [ pkgs.intel2200BGFirmware ];

  };

--- a/nixos/modules/hardware/video/webcam/facetimehd.nix
+++ b/nixos/modules/hardware/video/webcam/facetimehd.nix
@ -0,0 +1,45 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+
+  cfg = config.hardware.facetimehd;
+
+  kernelPackages = config.boot.kernelPackages;
+
+in
+
+{
+
+  options.hardware.facetimehd.enable = mkEnableOption "facetimehd kernel module";
+
+  config = mkIf cfg.enable {
+
+    assertions = singleton {
+      assertion = versionAtLeast kernelPackages.kernel.version "3.19";
+      message = "facetimehd is not supported for kernels older than 3.19";
+    };
+
+    boot.kernelModules = [ "facetimehd" ];
+
+    boot.blacklistedKernelModules = [ "bdc_pci" ];
+
+    boot.extraModulePackages = [ kernelPackages.facetimehd ];
+
+    hardware.firmware = [ pkgs.facetimehd-firmware ];
+
+    # unload module during suspend/hibernate as it crashes the whole system
+    powerManagement.powerDownCommands = ''
+      ${pkgs.module_init_tools}/bin/rmmod -f facetimehd
+    '';
+
+    # and load it back on resume
+    powerManagement.resumeCommands = ''
+      export MODULE_DIR=/run/current-system/kernel-modules/lib/modules
+      ${pkgs.module_init_tools}/bin/modprobe -v facetimehd
+    '';
+
+  };
+
+}
--- a/nixos/modules/installer/cd-dvd/sd-image-armv7l-multiplatform.nix
+++ b/nixos/modules/installer/cd-dvd/sd-image-armv7l-multiplatform.nix
@ -23,7 +23,7 @@ in
  boot.loader.generic-extlinux-compatible.enable = true;

  boot.kernelPackages = pkgs.linuxPackages_latest;
-  boot.kernelParams = ["console=ttyS0,115200n8" "console=ttyAMA0,115200n8" "console=tty0"];
+  boot.kernelParams = ["console=ttyS0,115200n8" "console=ttymxc0,115200n8" "console=ttyAMA0,115200n8" "console=tty0"];

  # FIXME: this probably should be in installation-device.nix
  users.extraUsers.root.initialHashedPassword = "";
--- a/nixos/modules/installer/cd-dvd/sd-image.nix
+++ b/nixos/modules/installer/cd-dvd/sd-image.nix
@ -30,7 +30,7 @@ in

    bootSize = mkOption {
      type = types.int;
-      default = 128;
+      default = 120;
      description = ''
        Size of the /boot partition, in megabytes.
      '';
@ -66,10 +66,10 @@ in
      buildInputs = with pkgs; [ dosfstools e2fsprogs mtools libfaketime utillinux ];

      buildCommand = ''
-        # Create the image file sized to fit /boot and /, plus 4M of slack
+        # Create the image file sized to fit /boot and /, plus 20M of slack
        rootSizeBlocks=$(du -B 512 --apparent-size ${rootfsImage} | awk '{ print $1 }')
        bootSizeBlocks=$((${toString config.sdImage.bootSize} * 1024 * 1024 / 512))
-        imageSize=$((rootSizeBlocks * 512 + bootSizeBlocks * 512 + 4096 * 1024))
+        imageSize=$((rootSizeBlocks * 512 + bootSizeBlocks * 512 + 20 * 1024 * 1024))
        truncate -s $imageSize $out

        # type=b is 'W95 FAT32', type=83 is 'Linux'.
@ -77,8 +77,8 @@ in
            label: dos
            label-id: 0x2178694e

-            start=1M, size=$bootSizeBlocks, type=b, bootable
-            type=83
+            start=8M, size=$bootSizeBlocks, type=b, bootable
+            start=${toString (8 + config.sdImage.bootSize)}M, type=83
        EOF

        # Copy the rootfs into the SD image
--- a/nixos/modules/installer/cd-dvd/system-tarball-sheevaplug.nix
+++ b/nixos/modules/installer/cd-dvd/system-tarball-sheevaplug.nix
@ -86,8 +86,7 @@ in
  system.boot.loader.kernelFile = "uImage";

  boot.initrd.availableKernelModules =
-    [ "mvsdio" "mmc_block" "reiserfs" "ext3" "ums-cypress" "rtc_mv"
-      "ext4" ];
+    [ "mvsdio" "reiserfs" "ext3" "ums-cypress" "rtc_mv" "ext4" ];

  boot.postBootCommands =
    ''
--- a/nixos/modules/installer/cd-dvd/system-tarball.nix
+++ b/nixos/modules/installer/cd-dvd/system-tarball.nix
@ -43,7 +43,7 @@ in
    # so that we don't need to know its device.
    fileSystems = [ ];

-    # boot.initrd.availableKernelModules = [ "mvsdio" "mmc_block" "reiserfs" "ext3" "ext4" ];
+    # boot.initrd.availableKernelModules = [ "mvsdio" "reiserfs" "ext3" "ext4" ];

    # boot.initrd.kernelModules = [ "rtc_mv" ];

--- a/nixos/modules/installer/tools/nixos-install.sh
+++ b/nixos/modules/installer/tools/nixos-install.sh
@ -73,11 +73,6 @@ if ! test -e "$mountPoint"; then
    exit 1
 fi

-if ! grep -F -q " $mountPoint " /proc/mounts; then
-    echo "$mountPoint doesn't appear to be a mount point"
-    exit 1
-fi
-

 # Mount some stuff in the target root directory.
 mkdir -m 0755 -p $mountPoint/dev $mountPoint/proc $mountPoint/sys $mountPoint/etc $mountPoint/run $mountPoint/home
--- a/nixos/modules/misc/ids.nix
+++ b/nixos/modules/misc/ids.nix
@ -248,6 +248,9 @@
      matrix-synapse = 224;
      rspamd = 225;
      rmilter = 226;
+      cfdyndns = 227;
+      gammu-smsd = 228;
+      pdnsd = 229;

      # When adding a uid, make sure it doesn't match an existing gid. And don't use uids above 399!

@ -473,6 +476,8 @@
      matrix-synapse = 224;
      rspamd = 225;
      rmilter = 226;
+      cfdyndns = 227;
+      pdnsd = 229;

      # When adding a gid, make sure it doesn't match an existing
      # uid. Users and groups with the same name should have equal
--- a/nixos/modules/module-list.nix
+++ b/nixos/modules/module-list.nix
@ -42,6 +42,7 @@
  ./hardware/video/bumblebee.nix
  ./hardware/video/nvidia.nix
  ./hardware/video/ati.nix
+  ./hardware/video/webcam/facetimehd.nix
  ./installer/tools/auto-upgrade.nix
  ./installer/tools/nixos-checkout.nix
  ./installer/tools/tools.nix
@ -200,6 +201,7 @@
  ./services/misc/bepasty.nix
  ./services/misc/canto-daemon.nix
  ./services/misc/calibre-server.nix
+  ./services/misc/cfdyndns.nix
  ./services/misc/cpuminer-cryptonight.nix
  ./services/misc/cgminer.nix
  ./services/misc/confd.nix
@ -210,6 +212,7 @@
  ./services/misc/etcd.nix
  ./services/misc/felix.nix
  ./services/misc/folding-at-home.nix
+  ./services/misc/gammu-smsd.nix
  #./services/misc/gitit.nix
  ./services/misc/gitlab.nix
  ./services/misc/gitolite.nix
@ -339,6 +342,7 @@
  ./services/networking/openntpd.nix
  ./services/networking/openvpn.nix
  ./services/networking/ostinato.nix
+  ./services/networking/pdnsd.nix
  ./services/networking/polipo.nix
  ./services/networking/prayer.nix
  ./services/networking/privoxy.nix
--- a/nixos/modules/security/acme.nix
+++ b/nixos/modules/security/acme.nix
@ -56,8 +56,8 @@ let

      plugins = mkOption {
        type = types.listOf (types.enum [
-          "cert.der" "cert.pem" "chain.der" "chain.pem" "external_pem.sh"
-          "fullchain.der" "fullchain.pem" "key.der" "key.pem" "account_key.json"
+          "cert.der" "cert.pem" "chain.pem" "external_pem.sh"
+          "fullchain.pem" "full.pem" "key.der" "key.pem" "account_key.json"
        ]);
        default = [ "fullchain.pem" "key.pem" "account_key.json" ];
        description = ''
--- a/nixos/modules/services/databases/postgresql.nix
+++ b/nixos/modules/services/databases/postgresql.nix
@ -158,7 +158,7 @@ in
      # Note: when changing the default, make it conditional on
      # ‘system.stateVersion’ to maintain compatibility with existing
      # systems!
-      mkDefault pkgs.postgresql94;
+      mkDefault (if versionAtLeast config.system.stateVersion "16.03" then pkgs.postgresql95 else pkgs.postgresql94);

    services.postgresql.authentication = mkAfter
      ''
@ -177,7 +177,7 @@ in

    users.extraGroups.postgres.gid = config.ids.gids.postgres;

-    environment.systemPackages = [postgresql];
+    environment.systemPackages = [ postgresql ];

    systemd.services.postgresql =
      { description = "PostgreSQL Server";
@ -187,35 +187,37 @@ in

        environment.PGDATA = cfg.dataDir;

-        path = [ pkgs.su postgresql ];
+        path = [ postgresql ];

        preStart =
+          ''
+            # Create data directory.
+            if ! test -e ${cfg.dataDir}/PG_VERSION; then
+              mkdir -m 0700 -p ${cfg.dataDir}
+              rm -f ${cfg.dataDir}/*.conf
+              chown -R postgres:postgres ${cfg.dataDir}
+            fi
+          ''; # */
+
+        script =
          ''
            # Initialise the database.
            if ! test -e ${cfg.dataDir}/PG_VERSION; then
-                mkdir -m 0700 -p ${cfg.dataDir}
-                rm -f ${cfg.dataDir}/*.conf
-                if [ "$(id -u)" = 0 ]; then
-                  chown -R postgres ${cfg.dataDir}
-                  su -s ${pkgs.stdenv.shell} postgres -c 'initdb -U root'
-                else
-                  # For non-root operation.
-                  initdb
-                fi
-                # See postStart!
-                touch "${cfg.dataDir}/.first_startup"
+              initdb -U root
+              # See postStart!
+              touch "${cfg.dataDir}/.first_startup"
            fi
-
            ln -sfn "${configFile}" "${cfg.dataDir}/postgresql.conf"
            ${optionalString (cfg.recoveryConfig != null) ''
              ln -sfn "${pkgs.writeText "recovery.conf" cfg.recoveryConfig}" \
                "${cfg.dataDir}/recovery.conf"
            ''}
-          ''; # */
+
+             exec postgres ${toString flags}
+          '';

        serviceConfig =
-          { ExecStart = "@${postgresql}/bin/postgres postgres ${toString flags}";
-            ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
+          { ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
            User = "postgres";
            Group = "postgres";
            PermissionsStartOnly = true;
--- a/nixos/modules/services/hardware/bluetooth.nix
+++ b/nixos/modules/services/hardware/bluetooth.nix
@ -1,6 +1,43 @@
 { config, lib, pkgs, ... }:

 with lib;
+let
+    bluez-bluetooth = if config.services.xserver.desktopManager.kde4.enable then pkgs.bluez else pkgs.bluez5;
+
+    configBluez = {
+        description = "Bluetooth Service";
+        serviceConfig = {
+          Type = "dbus";
+          BusName = "org.bluez";
+          ExecStart = "${bluez-bluetooth}/sbin/bluetoothd -n";
+        };
+        wantedBy = [ "bluetooth.target" ];
+    };
+
+    configBluez5 =  {
+        description = "Bluetooth Service";
+        serviceConfig = {
+          Type = "dbus";
+          BusName = "org.bluez";
+          ExecStart = "${bluez-bluetooth}/sbin/bluetoothd -n";
+          NotifyAccess="main";
+          CapabilityBoundingSet="CAP_NET_ADMIN CAP_NET_BIND_SERVICE";
+          LimitNPROC=1;
+        };
+        wantedBy = [ "bluetooth.target" ];
+    };
+
+    obexConfig = {
+        description = "Bluetooth OBEX service";
+        serviceConfig = {
+          Type = "dbus";
+          BusName = "org.bluez.obex";
+          ExecStart = "${bluez-bluetooth}/sbin/obexd";
+        };
+    };
+
+    bluezConfig = if config.services.xserver.desktopManager.kde4.enable then configBluez else configBluez5;
+in

 {

@ -16,26 +53,15 @@ with lib;

  };

-
  ###### implementation
-
+  
  config = mkIf config.hardware.bluetooth.enable {

-    environment.systemPackages = [ pkgs.bluez pkgs.openobex pkgs.obexftp ];
-
-    services.udev.packages = [ pkgs.bluez ];
-
-    services.dbus.packages = [ pkgs.bluez ];
-
-    systemd.services."dbus-org.bluez" = {
-      description = "Bluetooth Service";
-      serviceConfig = {
-        Type = "dbus";
-        BusName = "org.bluez";
-        ExecStart = "${pkgs.bluez}/sbin/bluetoothd -n";
-      };
-      wantedBy = [ "bluetooth.target" ];
-    };
+    environment.systemPackages = [ bluez-bluetooth pkgs.openobex pkgs.obexftp ];
+    services.udev.packages = [ bluez-bluetooth ];
+    services.dbus.packages = [ bluez-bluetooth ];
+    systemd.services."dbus-org.bluez" = bluezConfig;
+    systemd.services."dbus-org.bluez.obex" = obexConfig;

  };

--- a/nixos/modules/services/logging/logstash.nix
+++ b/nixos/modules/services/logging/logstash.nix
@ -85,7 +85,7 @@ in
        type = types.lines;
        default = ''stdin { type => "example" }'';
        description = "Logstash input configuration.";
-        example = ''
+        example = literalExample ''
          # Read from journal
          pipe {
            command => "''${pkgs.systemd}/bin/journalctl -f -o json"
@ -98,7 +98,7 @@ in
        type = types.lines;
        default = ''noop {}'';
        description = "logstash filter configuration.";
-        example = ''
+        example = literalExample ''
          if [type] == "syslog" {
            # Keep only relevant systemd fields
            # http://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html
@ -114,7 +114,7 @@ in

      outputConfig = mkOption {
        type = types.lines;
-        default = ''stdout { debug => true debug_format => "json"}'';
+        default = literalExample ''stdout { debug => true debug_format => "json"}'';
        description = "Logstash output configuration.";
        example = ''
          redis { host => "localhost" data_type => "list" key => "logstash" codec => json }
--- a/nixos/modules/services/mail/dovecot.nix
+++ b/nixos/modules/services/mail/dovecot.nix
@ -13,6 +13,7 @@ let
    ''
      base_dir = ${baseDir}
      protocols = ${concatStringsSep " " cfg.protocols}
+      sendmail_path = /var/setuid-wrappers/sendmail
    ''

    (if isNull cfg.sslServerCert then ''
--- a/nixos/modules/services/mail/dspam.nix
+++ b/nixos/modules/services/mail/dspam.nix
@ -19,7 +19,10 @@ let
    SystemLog on
    UserLog on

-    ${optionalString (cfg.domainSocket != null) ''ServerDomainSocketPath "${cfg.domainSocket}"''}
+    ${optionalString (cfg.domainSocket != null) ''
+      ServerDomainSocketPath "${cfg.domainSocket}"
+      ClientHost "${cfg.domainSocket}"
+    ''}

    ${cfg.extraConfig}
  '';
@ -108,7 +111,11 @@ in {
          User = cfg.user;
          Group = cfg.group;
          RuntimeDirectory = optional (cfg.domainSocket == defaultSock) "dspam";
+          RuntimeDirectoryMode = optional (cfg.domainSocket == defaultSock) "0750";
          PermissionsStartOnly = true;
+          # DSPAM segfaults on just about every error
+          Restart = "on-failure";
+          RestartSec = "1s";
        };

        preStart = ''
@ -136,7 +143,7 @@ in {
        restartTriggers = [ cfgfile ];

        serviceConfig = {
-          ExecStart = "${dspam}/bin/dspam_maintenance";
+          ExecStart = "${dspam}/bin/dspam_maintenance --verbose";
          Type = "oneshot";
          User = cfg.user;
          Group = cfg.group;
--- a/nixos/modules/services/mail/postfix.nix
+++ b/nixos/modules/services/mail/postfix.nix
@ -13,6 +13,18 @@ let
  haveTransport = cfg.transport != "";
  haveVirtual = cfg.virtual != "";

+  clientAccess =
+    if (cfg.dnsBlacklistOverrides != "")
+    then [ "check_client_access hash:/etc/postfix/client_access" ]
+    else [];
+
+  dnsBl =
+    if (cfg.dnsBlacklists != [])
+    then [ (concatStringsSep ", " (map (s: "reject_rbl_client " + s) cfg.dnsBlacklists)) ]
+    else [];
+
+  clientRestrictions = concatStringsSep ", " (clientAccess ++ dnsBl);
+
  mainCf =
    ''
      compatibility_level = 2
@ -104,6 +116,9 @@ let
    + optionalString haveVirtual ''
      virtual_alias_maps = hash:/etc/postfix/virtual
    ''
+    + optionalString (cfg.dnsBlacklists != []) ''
+      smtpd_client_restrictions = ${clientRestrictions}
+    ''
    + cfg.extraConfig;

  masterCf = ''
@ -161,6 +176,7 @@ let

  aliasesFile = pkgs.writeText "postfix-aliases" aliases;
  virtualFile = pkgs.writeText "postfix-virtual" cfg.virtual;
+  checkClientAccessFile = pkgs.writeText "postfix-check-client-access" cfg.dnsBlacklistOverrides;
  mainCfFile = pkgs.writeText "postfix-main.cf" mainCf;
  masterCfFile = pkgs.writeText "postfix-master.cf" masterCf;
  transportFile = pkgs.writeText "postfix-transport" cfg.transport;
@ -366,6 +382,17 @@ in
        ";
      };

+      dnsBlacklists = mkOption {
+        default = [];
+        type = with types; listOf string;
+        description = "dns blacklist servers to use with smtpd_client_restrictions";
+      };
+
+      dnsBlacklistOverrides = mkOption {
+        default = "";
+        description = "contents of check_client_access for overriding dnsBlacklists";
+      };
+
      extraMasterConf = mkOption {
        type = types.lines;
        default = "";
@ -461,7 +488,7 @@ in
            rm -rf /var/lib/postfix/conf
            mkdir -p /var/lib/postfix/conf
            chmod 0755 /var/lib/postfix/conf
-            ln -sf ${pkgs.postfix}/etc/postfix/postfix-files
+            ln -sf ${pkgs.postfix}/etc/postfix/postfix-files /var/lib/postfix/conf/postfix-files
            ln -sf ${mainCfFile} /var/lib/postfix/conf/main.cf
            ln -sf ${masterCfFile} /var/lib/postfix/conf/master.cf

@ -494,6 +521,9 @@ in
    (mkIf haveVirtual {
      services.postfix.mapFiles."virtual" = virtualFile;
    })
+    (mkIf (cfg.dnsBlacklists != []) {
+      services.postfix.mapFiles."client_access" = checkClientAccessFile;
+    })
  ]);

 }
--- a/nixos/modules/services/mail/postsrsd.nix
+++ b/nixos/modules/services/mail/postsrsd.nix
@ -95,7 +95,11 @@ in {
      preStart = ''
        if [ ! -e "${cfg.secretsFile}" ]; then
          echo "WARNING: secrets file not found, autogenerating!"
-          mkdir -p -m750 "$(dirname "${cfg.secretsFile}")"
+          DIR="$(dirname "${cfg.secretsFile}")"
+          if [ ! -d "$DIR" ]; then
+            mkdir -p -m750 "$DIR"
+            chown "${cfg.user}:${cfg.group}" "$DIR"
+          fi
          dd if=/dev/random bs=18 count=1 | base64 > "${cfg.secretsFile}"
          chmod 600 "${cfg.secretsFile}"
        fi
--- a/nixos/modules/services/misc/cfdyndns.nix
+++ b/nixos/modules/services/misc/cfdyndns.nix
@ -0,0 +1,70 @@
+{ config, pkgs, lib, ... }:
+
+with lib;
+
+let
+  cfg = config.services.cfdyndns;
+in
+{
+  options = {
+    services.cfdyndns = {
+      enable = mkEnableOption "Cloudflare Dynamic DNS Client";
+
+      email = mkOption {
+        type = types.str;
+        description = ''
+          The email address to use to authenticate to CloudFlare.
+        '';
+      };
+
+      apikey = mkOption {
+        type = types.str;
+        description = ''
+          The API Key to use to authenticate to CloudFlare.
+        '';
+      };
+
+      records = mkOption {
+        default = [];
+        example = [ "host.tld" ];
+        type = types.listOf types.str;
+        description = ''
+          The records to update in CloudFlare.
+        '';
+      };
+    };
+  };
+
+  config = mkIf cfg.enable {
+    systemd.services.cfdyndns = {
+      description = "CloudFlare Dynamic DNS Client";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      startAt = "5 minutes";
+      serviceConfig = {
+        Type = "simple";
+        User = config.ids.uids.cfdyndns;
+        Group = config.ids.gids.cfdyndns;
+        ExecStart = "/bin/sh -c '${pkgs.cfdyndns}/bin/cfdyndns'";
+      };
+      environment = {
+        CLOUDFLARE_EMAIL="${cfg.email}";
+        CLOUDFLARE_APIKEY="${cfg.apikey}";
+        CLOUDFLARE_RECORDS="${concatStringsSep "," cfg.records}";
+      };
+    };
+
+    users.extraUsers = {
+      cfdyndns = {
+        group = "cfdyndns";
+        uid = config.ids.uids.cfdyndns;
+      };
+    };
+
+    users.extraGroups = {
+      cfdyndns = {
+        gid = config.ids.gids.cfdyndns;
+      };
+    };
+  };
+}
--- a/nixos/modules/services/misc/gammu-smsd.nix
+++ b/nixos/modules/services/misc/gammu-smsd.nix
@ -0,0 +1,253 @@
+{ pkgs, lib, config, ... }:
+
+with lib;
+let
+  cfg = config.services.gammu-smsd;
+
+  configFile = pkgs.writeText "gammu-smsd.conf" ''
+    [gammu]
+    Device = ${cfg.device.path}
+    Connection = ${cfg.device.connection}
+    SynchronizeTime = ${if cfg.device.synchronizeTime then "yes" else "no"}
+    LogFormat = ${cfg.log.format}
+    ${if (cfg.device.pin != null) then "PIN = ${cfg.device.pin}" else ""}
+    ${cfg.extraConfig.gammu}
+
+
+    [smsd]
+    LogFile = ${cfg.log.file}
+    Service = ${cfg.backend.service}
+
+    ${optionalString (cfg.backend.service == "files") ''
+      InboxPath = ${cfg.backend.files.inboxPath}
+      OutboxPath = ${cfg.backend.files.outboxPath}
+      SentSMSPath = ${cfg.backend.files.sentSMSPath}
+      ErrorSMSPath = ${cfg.backend.files.errorSMSPath}
+    ''}
+
+    ${optionalString (cfg.backend.service == "sql" && cfg.backend.sql.driver == "sqlite") ''
+      Driver = ${cfg.backend.sql.driver}
+      DBDir = ${cfg.backend.sql.database}
+    ''}
+
+    ${optionalString (cfg.backend.service == "sql" && cfg.backend.sql.driver == "native_pgsql") (
+      with cfg.backend; ''
+        Driver = ${sql.driver}
+        ${if (sql.database!= null) then "Database = ${sql.database}" else ""}
+        ${if (sql.host != null) then "Host = ${sql.host}" else ""}
+        ${if (sql.user != null) then "User = ${sql.user}" else ""}
+        ${if (sql.password != null) then "Password = ${sql.password}" else ""}
+      '')}
+
+    ${cfg.extraConfig.smsd}
+  '';
+
+  initDBDir = "share/doc/gammu/examples/sql";
+
+  gammuPackage = with cfg.backend; (pkgs.gammu.override {
+    dbiSupport = (service == "sql" && sql.driver == "sqlite");
+    postgresSupport = (service == "sql" && sql.driver == "native_pgsql");
+  });
+
+in {
+  options = {
+    services.gammu-smsd = {
+
+      enable = mkEnableOption "gammu-smsd daemon";
+
+      user = mkOption {
+        type = types.str;
+        default = "smsd";
+        description = "User that has access to the device";
+      };
+
+      device = {
+        path = mkOption {
+          type = types.path;
+          description = "Device node or address of the phone";
+          example = "/dev/ttyUSB2";
+        };
+
+        group = mkOption {
+          type = types.str;
+          default = "root";
+          description = "Owner group of the device";
+          example = "dialout";
+        };
+
+        connection = mkOption {
+          type = types.str;
+          default = "at";
+          description = "Protocol which will be used to talk to the phone";
+        };
+
+        synchronizeTime = mkOption {
+          type = types.bool;
+          default = true;
+          description = "Whether to set time from computer to the phone during starting connection";
+        };
+
+        pin = mkOption {
+          type = types.nullOr types.str;
+          default = null;
+          description = "PIN code for the simcard";
+        };
+      };
+
+
+      log = {
+        file = mkOption {
+          type = types.str;
+          default = "syslog";
+          description = "Path to file where information about communication will be stored";
+        };
+
+        format = mkOption {
+          type = types.enum [ "nothing" "text" "textall" "textalldate" "errors" "errorsdate" "binary" ];
+          default = "errors";
+          description = "Determines what will be logged to the LogFile";
+        };
+      };
+
+
+      extraConfig = {
+        gammu = mkOption {
+          type = types.lines;
+          default = "";
+          description = "Extra config lines to be added into [gammu] section";
+        };
+
+
+        smsd = mkOption {
+          type = types.lines;
+          default = "";
+          description = "Extra config lines to be added into [smsd] section";
+        };
+      };
+
+
+      backend = {
+        service = mkOption {
+          type = types.enum [ "null" "files" "sql" ];
+          default = "null";
+          description = "Service to use to store sms data.";
+        };
+
+        files = {
+          inboxPath = mkOption {
+            type = types.path;
+            default = "/var/spool/sms/inbox/";
+            description = "Where the received SMSes are stored";
+          };
+
+          outboxPath = mkOption {
+            type = types.path;
+            default = "/var/spool/sms/outbox/";
+            description = "Where SMSes to be sent should be placed";
+          };
+
+          sentSMSPath = mkOption {
+            type = types.path;
+            default = "/var/spool/sms/sent/";
+            description = "Where the transmitted SMSes are placed";
+          };
+
+          errorSMSPath = mkOption {
+            type = types.path;
+            default = "/var/spool/sms/error/";
+            description = "Where SMSes with error in transmission is placed";
+          };
+        };
+
+        sql = {
+          driver = mkOption {
+            type = types.enum [ "native_mysql" "native_pgsql" "odbc" "dbi" ];
+            description = "DB driver to use";
+          };
+
+          sqlDialect = mkOption {
+            type = types.nullOr types.str;
+            default = null;
+            description = "SQL dialect to use (odbc driver only)";
+          };
+
+          database = mkOption {
+            type = types.str;
+            default = null;
+            description = "Database name to store sms data";
+          };
+
+          host = mkOption {
+            type = types.str;
+            default = "localhost";
+            description = "Database server address";
+          };
+
+          user = mkOption {
+            type = types.nullOr types.str;
+            default = null;
+            description = "User name used for connection to the database";
+          };
+
+          password = mkOption {
+            type = types.nullOr types.str;
+            default = null;
+            description = "User password used for connetion to the database";
+          };
+        };
+      };
+    };
+  };
+
+  config = mkIf cfg.enable {
+    users.extraUsers.${cfg.user} = {
+      description = "gammu-smsd user";
+      uid = config.ids.uids.gammu-smsd;
+      extraGroups = [ "${cfg.device.group}" ];
+    };
+
+    environment.systemPackages = with cfg.backend; [ gammuPackage ]
+    ++ optionals (service == "sql" && sql.driver == "sqlite")  [ pkgs.sqlite ];
+
+    systemd.services.gammu-smsd = {
+      description = "gammu-smsd daemon";
+
+      wantedBy = [ "multi-user.target" ];
+
+      wants = with cfg.backend; [ ]
+      ++ optionals (service == "sql" && sql.driver == "native_pgsql") [ "postgresql.service" ];
+
+      preStart = with cfg.backend;
+
+        optionalString (service == "files") (with files; ''
+          mkdir -m 755 -p ${inboxPath} ${outboxPath} ${sentSMSPath} ${errorSMSPath}
+          chown ${cfg.user} -R ${inboxPath}
+          chown ${cfg.user} -R ${outboxPath}
+          chown ${cfg.user} -R ${sentSMSPath}
+          chown ${cfg.user} -R ${errorSMSPath}
+        '')
+      + optionalString (service == "sql" && sql.driver == "sqlite") ''
+         cat "${gammuPackage}/${initDBDir}/sqlite.sql" \
+         | ${pkgs.sqlite}/bin/sqlite3 ${sql.database}
+        ''
+      + (let execPsql = extraArgs: concatStringsSep " " [
+          (optionalString (sql.password != null) "PGPASSWORD=${sql.password}")
+          "${config.services.postgresql.package}/bin/psql"
+          (optionalString (sql.host != null) "-h ${sql.host}")
+          (optionalString (sql.user != null) "-U ${sql.user}")
+          "$extraArgs"
+          "${sql.database}"
+        ]; in optionalString (service == "sql" && sql.driver == "native_pgsql") ''
+         echo '\i '"${gammuPackage}/${initDBDir}/pgsql.sql" | ${execPsql ""}
+       '');
+
+      serviceConfig = {
+        User = "${cfg.user}";
+        Group = "${cfg.device.group}";
+        PermissionsStartOnly = true;
+        ExecStart = "${gammuPackage}/bin/gammu-smsd -c ${configFile}";
+      };
+
+    };
+  };
+}
--- a/nixos/modules/services/misc/gitit.nix
+++ b/nixos/modules/services/misc/gitit.nix
@ -35,7 +35,6 @@ let
      };

      haskellPackages = mkOption {
-        type = types.attrsOf types.package;
        default = pkgs.haskellPackages;
        defaultText = "pkgs.haskellPackages";
        example = literalExample "pkgs.haskell.packages.ghc784";
--- a/nixos/modules/services/networking/i2pd.nix
+++ b/nixos/modules/services/networking/i2pd.nix
@ -12,21 +12,69 @@ let

  toOneZero = b: if b then "1" else "0";

+  mkEndpointOpt = name: addr: port: {
+    name = mkOption {
+      type = types.str;
+      default = name;
+      description = "The endpoint name.";
+    };
+    address = mkOption {
+      type = types.str;
+      default = addr;
+      description = "Bind address for ${name} endpoint. Default: " + addr;
+    };
+    port = mkOption {
+      type = types.int;
+      default = port;
+      description = "Bind port for ${name} endoint. Default: " + toString port;
+    };
+  };
+
+  commonTunOpts = let
+    i2cpOpts = {
+      length = mkOption {
+        type = types.int;
+        description = "Guaranteed minimum hops.";
+        default = 3;
+      };
+      quantity = mkOption {
+        type = types.int;
+        description = "Number of simultaneous tunnels.";
+        default = 5;
+      };
+    };
+  in name: {
+    outbound = i2cpOpts;
+    inbound = i2cpOpts;
+    crypto.tagsToSend = mkOption {
+      type = types.int;
+      description = "Number of ElGamal/AES tags to send.";
+      default = 40;
+    };
+   destination = mkOption {
+      type = types.str;
+      description = "Remote endpoint, I2P hostname or b32.i2p address.";
+    };
+    keys = mkOption {
+      type = types.str;
+      default = name + "-keys.dat";
+      description = "Keyset used for tunnel identity.";
+    };
+  } // mkEndpointOpt name "127.0.0.1" 0;
+
  i2pdConf = pkgs.writeText "i2pd.conf" ''
-      v6 = ${toOneZero cfg.enableIPv6}
-      unreachable = ${toOneZero cfg.unreachable}
+      ipv6 = ${toOneZero cfg.enableIPv6}
+      notransit = ${toOneZero cfg.notransit}
      floodfill = ${toOneZero cfg.floodfill}
      ${if isNull cfg.port then "" else "port = ${toString cfg.port}"}
-      httpproxyport = ${toString cfg.proxy.httpPort}
-      socksproxyport = ${toString cfg.proxy.socksPort}
-      ircaddress = ${cfg.irc.host}
-      ircport = ${toString cfg.irc.port}
-      ircdest = ${cfg.irc.dest}
-      irckeys = ${cfg.irc.keyFile}
-      eepport = ${toString cfg.eep.port}
-      ${if isNull cfg.sam.port then "" else "--samport=${toString cfg.sam.port}"}
-      eephost = ${cfg.eep.host}
-      eepkeys = ${cfg.eep.keyFile}
+      ${flip concatMapStrings
+        (collect (proto: proto ? port && proto ? address && proto ? name) cfg.proto)
+        (proto: let portStr = toString proto.port; in ''
+      [${proto.name}]
+      address = ${proto.address}
+      port = ${toString proto.port}
+      '')
+      }
  '';

  i2pdTunnelConf = pkgs.writeText "i2pd-tunnels.conf" ''
@ -39,10 +87,15 @@ let
  keys = ${tun.keys}
  address = ${tun.address}
  port = ${toString tun.port}
+  inbound.length = ${toString tun.inbound.length}
+  outbound.length = ${toString tun.outbound.length}
+  inbound.quantity = ${toString tun.inbound.quantity}
+  outbound.quantity = ${toString tun.outbound.quantity}
+  crypto.tagsToSend = ${toString tun.crypto.tagsToSend}
  '')
  }
  ${flip concatMapStrings
-    (collect (tun: tun ? port && tun ? host) cfg.outTunnels)
+    (collect (tun: tun ? port && tun ? host) cfg.inTunnels)
    (tun: let portStr = toString tun.port; in ''
  [${tun.name}]
  type = server
@ -59,10 +112,10 @@ let
  i2pdSh = pkgs.writeScriptBin "i2pd" ''
    #!/bin/sh
    ${if isNull cfg.extIp then extip else ""}
-    ${pkgs.i2pd}/bin/i2pd --log=1 --daemon=0 --service=0 \
+    ${pkgs.i2pd}/bin/i2pd --log=1 \
      --host=${if isNull cfg.extIp then "$EXTIP" else cfg.extIp} \
      --conf=${i2pdConf} \
-      --tunnelscfg=${i2pdTunnelConf}
+      --tunconf=${i2pdTunnelConf}
  '';

 in
@ -91,11 +144,11 @@ in
        '';
      };

-      unreachable = mkOption {
+      notransit = mkOption {
        type = types.bool;
        default = false;
        description = ''
-          If the router is declared to be unreachable and needs introduction nodes.
+          Tells the router to not accept transit tunnels during startup.
        '';
      };

@ -111,7 +164,7 @@ in
        type = with types; nullOr int;
        default = null;
        description = ''
-	        I2P listen port. If no one is given the router will pick between 9111 and 30777.
+          I2P listen port. If no one is given the router will pick between 9111 and 30777.
        '';
      };

@ -123,184 +176,53 @@ in
        '';
      };

-      http = {
-        port = mkOption {
-          type = types.int;
-          default = 7070;
-          description = ''
-            HTTP listen port.
-          '';
-        };
-      };
-
-      proxy = {
-        httpPort = mkOption {
-          type = types.int;
-          default = 4446;
-          description = ''
-            HTTP proxy listen port.
-          '';
-        };
-        socksPort = mkOption {
-          type = types.int;
-          default = 4447;
-          description = ''
-            SOCKS proxy listen port.
-          '';
-        };
-      };
-
-      irc = {
-        host = mkOption {
-          type = types.str;
-          default = "127.0.0.1";
-          description = ''
-            Address to forward incoming traffic to. 127.0.0.1 by default.
-          '';
-        };
-        dest = mkOption {
-          type = types.str;
-          default = "irc.postman.i2p";
-          description = ''
-            Destination I2P tunnel endpoint address of IRC server. irc.postman.i2p by default.
-          '';
-        };
-        port = mkOption {
-          type = types.int;
-          default = 6668;
-          description = ''
-            Local IRC tunnel endoint port to listen on. 6668 by default.
-          '';
-        };
-        keyFile = mkOption {
-          type = types.str;
-          default = "privKeys.dat";
-          description = ''
-            File name containing destination keys. privKeys.dat by default.
-          '';
-        };
-      };
-
-      eep = {
-        host = mkOption {
-          type = types.str;
-          default = "127.0.0.1";
-          description = ''
-            Address to forward incoming traffic to. 127.0.0.1 by default.
-          '';
-        };
-        port = mkOption {
-          type = types.int;
-          default = 80;
-          description = ''
-            Port to forward incoming traffic to. 80 by default.
-          '';
-        };
-        keyFile = mkOption {
-          type = types.str;
-          default = "privKeys.dat";
-          description = ''
-            File name containing destination keys. privKeys.dat by default.
-          '';
-        };
-      };
-
-      sam = {
-        port = mkOption {
-          type = with types; nullOr int;
-          default = null;
-          description = ''
-            Local SAM tunnel endpoint. Usually 7656. SAM is disabled if not specified.
-          '';
-        };
-      };
+      proto.http = mkEndpointOpt "http" "127.0.0.1" 7070;
+      proto.sam = mkEndpointOpt "sam" "127.0.0.1" 7656;
+      proto.bob = mkEndpointOpt "bob" "127.0.0.1" 2827;
+      proto.i2pControl = mkEndpointOpt "i2pcontrol" "127.0.0.1" 7650;
+      proto.httpProxy = mkEndpointOpt "httpproxy" "127.0.0.1" 4446;
+      proto.socksProxy = mkEndpointOpt "socksproxy" "127.0.0.1" 4447;

      outTunnels = mkOption {
        default = {};
-	      type = with types; loaOf optionSet;
-	      description = ''
-	      '';
-	      options = [ ({ name, config, ... }: {
-
-	        options = {
-	          name = mkOption {
-	            type = types.str;
-	            description = "The name of the tunnel.";
-	          };
-	          destination = mkOption {
-	            type = types.str;
-	            description = "Remote endpoint, I2P hostname or b32.i2p address.";
-	          };
-	          keys = mkOption {
-	            type = types.str;
-	            default = name + "-keys.dat";
-	            description = "Keyset used for tunnel identity.";
-	          };
-	          address = mkOption {
-	            type = types.str;
-	            default = "127.0.0.1";
-	            description = "Local bind address for tunnel.";
-	          };
-	          port = mkOption {
-	            type = types.int;
-	            default = 0;
-	            description = "Local tunnel listen port.";
-	          };
-	        };
-
-	        config = {
-	          name = mkDefault name;
-	        };
-
-	      }) ];
+        type = with types; loaOf optionSet;
+        description = ''
+          Connect to someone as a client and establish a local accept endpoint
+        '';
+        options = [ ({ name, config, ... }: {
+          options = commonTunOpts name;
+          config = {
+            name = mkDefault name;
+          };
+        }) ];
      };

      inTunnels = mkOption {
        default = {};
-	      type = with types; loaOf optionSet;
-	      description = ''
-	      '';
-	      options = [ ({ name, config, ... }: {
+        type = with types; loaOf optionSet;
+        description = ''
+          Serve something on I2P network at port and delegate requests to address inPort.
+        '';
+        options = [ ({ name, config, ... }: {

-	        options = {
+          options = {
+            inPort = mkOption {
+              type = types.int;
+              default = 0;
+              description = "Service port. Default to the tunnel's listen port.";
+            };
+            accessList = mkOption {
+              type = with types; listOf str;
+              default = [];
+              description = "I2P nodes that are allowed to connect to this service.";
+            };
+          } // commonTunOpts name;

-	          name = mkOption {
-	            type = types.str;
-	            description = "The name of the tunnel.";
-	          };
-	          keys = mkOption {
-	            type = types.path;
-	            default = name + "-keys.dat";
-	            description = "Keyset used for tunnel identity.";
-	          };
-	          address = mkOption {
-	            type = types.str;
-	            default = "127.0.0.1";
-	            description = "Local service IP address.";
-	          };
-	          port = mkOption {
-	            type = types.int;
-	            default = 0;
-	            description = "Local tunnel listen port.";
-	          };
-	          inPort = mkOption {
-	            type = types.int;
-	            default = 0;
-	            description = "I2P service port. Default to the tunnel's listen port.";
-	          };
-	          accessList = mkOption {
-	            type = with types; listOf str;
-	            default = [];
-	            description = "I2P nodes that are allowed to connect to this service.";
-	          };
+          config = {
+            name = mkDefault name;
+          };

-	        };
-
-	        config = {
-	          name = mkDefault name;
-	        };
-
-	      }) ];
+        }) ];
      };
    };
  };
--- a/nixos/modules/services/networking/pdnsd.nix
+++ b/nixos/modules/services/networking/pdnsd.nix
@ -0,0 +1,93 @@
+{ config, pkgs, lib, ... }:
+
+with lib;
+
+let
+  cfg = config.services.pdnsd;
+  pdnsd = pkgs.pdnsd;
+  pdnsdUser = "pdnsd";
+  pdnsdGroup = "pdnsd";
+  pdnsdConf = pkgs.writeText "pdnsd.conf"
+    ''
+      global {
+        run_as=${pdnsdUser};
+        cache_dir="${cfg.cacheDir}";
+        ${cfg.globalConfig}
+      }
+
+      server {
+        ${cfg.serverConfig}
+      }
+      ${cfg.extraConfig}
+    '';
+in
+
+{ options =
+    { services.pdnsd =
+        { enable = mkEnableOption "pdnsd";
+
+          cacheDir = mkOption {
+            type = types.str;
+            default = "/var/cache/pdnsd";
+            description = "Directory holding the pdnsd cache";
+          };
+
+          globalConfig = mkOption {
+            type = types.lines;
+            default = "";
+            description = ''
+              Global configuration that should be added to the global directory
+              of <literal>pdnsd.conf</literal>.
+            '';
+          };
+
+          serverConfig = mkOption {
+            type = types.lines;
+            default = "";
+            description = ''
+              Server configuration that should be added to the server directory
+              of <literal>pdnsd.conf</literal>.
+            '';
+          };
+
+          extraConfig = mkOption {
+            type = types.lines;
+            default = "";
+            description = ''
+              Extra configuration directives that should be added to
+              <literal>pdnsd.conf</literal>.
+            '';
+          };
+        };
+    };
+
+  config = mkIf cfg.enable {
+    users.extraUsers = singleton {
+      name = pdnsdUser;
+      uid = config.ids.uids.pdnsd;
+      group = pdnsdGroup;
+      description = "pdnsd user";
+    };
+
+    users.extraGroups = singleton {
+      name = pdnsdGroup;
+      gid = config.ids.gids.pdnsd;
+    };
+
+    systemd.services.pdnsd =
+      { wantedBy = [ "multi-user.target" ];
+        after = [ "network.target" ];
+        preStart =
+          ''
+            mkdir -p "${cfg.cacheDir}"
+            touch "${cfg.cacheDir}/pdnsd.cache"
+            chown -R ${pdnsdUser}:${pdnsdGroup} "${cfg.cacheDir}"
+          '';
+        description = "pdnsd";
+        serviceConfig =
+          {
+            ExecStart = "${pdnsd}/bin/pdnsd -c ${pdnsdConf}";
+          };
+      };
+  };
+}
--- a/nixos/modules/services/networking/tinc.nix
+++ b/nixos/modules/services/networking/tinc.nix
@ -95,6 +95,16 @@ in
            '';
          };

+          chroot = mkOption {
+            default = true;
+            type = types.bool;
+            description = ''
+              Change process root directory to the directory where the config file is located (/etc/tinc/netname/), for added security.
+              The chroot is performed after all the initialization is done, after writing pid files and opening network sockets.
+
+              Note that tinc can't run scripts anymore (such as tinc-down or host-up), unless it is setup to be runnable inside chroot environment.
+            '';
+          };
        };
      };
    };
@ -166,7 +176,7 @@ in
          fi
        '';
        script = ''
-          tincd -D -U tinc.${network} -n ${network} --pidfile /run/tinc.${network}.pid -d ${toString data.debugLevel}
+          tincd -D -U tinc.${network} -n ${network} ${optionalString (data.chroot) "-R"} --pidfile /run/tinc.${network}.pid -d ${toString data.debugLevel}
        '';
      })
    );
--- a/nixos/modules/services/networking/unbound.nix
+++ b/nixos/modules/services/networking/unbound.nix
@ -16,6 +16,11 @@ let
    "forward-zone:\n  name: .\n" +
    concatMapStrings (x: "  forward-addr: ${x}\n") cfg.forwardAddresses;

+  rootTrustAnchorFile = "${stateDir}/root.key";
+
+  trustAnchor = optionalString cfg.enableRootTrustAnchor
+    "auto-trust-anchor-file: ${rootTrustAnchorFile}";
+
  confFile = pkgs.writeText "unbound.conf" ''
    server:
      directory: "${stateDir}"
@ -24,6 +29,7 @@ let
      pidfile: ""
      ${interfaces}
      ${access}
+      ${trustAnchor}
    ${cfg.extraConfig}
    ${forward}
  '';
@ -38,28 +44,39 @@ in
    services.unbound = {

      enable = mkOption {
-	default = false;
-	description = "Whether to enable the Unbound domain name server.";
+        default = false;
+        type = types.bool;
+        description = "Whether to enable the Unbound domain name server.";
      };

      allowedAccess = mkOption {
-	default = ["127.0.0.0/24"];
-	description = "What networks are allowed to use unbound as a resolver.";
+        default = ["127.0.0.0/24"];
+        type = types.listOf types.str;
+        description = "What networks are allowed to use unbound as a resolver.";
      };

      interfaces = mkOption {
-	default = [ "127.0.0.1" "::1" ];
-	description = "What addresses the server should listen on.";
+        default = [ "127.0.0.1" "::1" ];
+        type = types.listOf types.str;
+        description = "What addresses the server should listen on.";
      };

      forwardAddresses = mkOption {
-	default = [ ];
-	description = "What servers to forward queries to.";
+        default = [ ];
+        type = types.listOf types.str;
+        description = "What servers to forward queries to.";
+      };
+
+      enableRootTrustAnchor = mkOption {
+        default = true;
+        type = types.bool;
+        description = "Use and update root trust anchor for DNSSEC validation.";
      };

      extraConfig = mkOption {
-	default = "";
-	description = "Extra lines of unbound config.";
+        default = "";
+        type = types.str;
+        description = "Extra lines of unbound config.";
      };

    };
@ -88,9 +105,10 @@ in

      preStart = ''
        mkdir -m 0755 -p ${stateDir}/dev/
-	cp ${confFile} ${stateDir}/unbound.conf
-	chown unbound ${stateDir}
-	touch ${stateDir}/dev/random
+        cp ${confFile} ${stateDir}/unbound.conf
+        ${pkgs.unbound}/bin/unbound-anchor -a ${rootTrustAnchorFile}
+        chown unbound ${stateDir} ${rootTrustAnchorFile}
+        touch ${stateDir}/dev/random
        ${pkgs.utillinux}/bin/mount --bind -n /dev/random ${stateDir}/dev/random
      '';

--- a/nixos/modules/services/networking/unifi.nix
+++ b/nixos/modules/services/networking/unifi.nix
@ -61,6 +61,8 @@ in
      partOf = systemdMountPoints;
      bindsTo = systemdMountPoints;
      unitConfig.RequiresMountsFor = stateDir;
+      # This a HACK to fix missing dependencies of dynamic libs extracted from jars
+      environment.LD_LIBRARY_PATH = with pkgs.stdenv; "${cc.cc}/lib";

      preStart = ''
        # Ensure privacy of state
--- a/nixos/modules/services/networking/wpa_supplicant.nix
+++ b/nixos/modules/services/networking/wpa_supplicant.nix
@ -8,11 +8,15 @@ let
    ${optionalString cfg.userControlled.enable ''
      ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=${cfg.userControlled.group}
      update_config=1''}
-    ${concatStringsSep "\n" (mapAttrsToList (ssid: networkConfig: ''
+    ${concatStringsSep "\n" (mapAttrsToList (ssid: networkConfig: let
+      psk = if networkConfig.psk != null
+        then ''"${networkConfig.psk}"''
+        else networkConfig.pskRaw;
+    in ''
      network={
        ssid="${ssid}"
-        ${optionalString (networkConfig.psk != null) ''psk="${networkConfig.psk}"''}
-        ${optionalString (networkConfig.psk == null) ''key_mgmt=NONE''}
+        ${optionalString (psk != null) ''psk=${psk}''}
+        ${optionalString (psk == null) ''key_mgmt=NONE''}
      }
    '') cfg.networks)}
  '' else "/etc/wpa_supplicant.conf";
@ -49,6 +53,19 @@ in {

                Be aware that these will be written to the nix store
                in plaintext!
+
+                Mutually exclusive with <varname>pskRaw</varname>.
+              '';
+            };
+
+            pskRaw = mkOption {
+              type = types.nullOr types.str;
+              default = null;
+              description = ''
+                The network's pre-shared key in hex defaulting
+                to being a network without any authentication.
+
+                Mutually exclusive with <varname>psk</varname>.
              '';
            };
          };
@ -95,6 +112,11 @@ in {

  config = mkMerge [
    (mkIf cfg.enable {
+      assertions = flip mapAttrsToList cfg.networks (name: cfg: {
+        assertion = cfg.psk == null || cfg.pskRaw == null;
+        message = ''networking.wireless."${name}".psk and networking.wireless."${name}".pskRaw are mutually exclusive'';
+      });
+
      environment.systemPackages =  [ pkgs.wpa_supplicant ];

      services.dbus.packages = [ pkgs.wpa_supplicant ];
--- a/nixos/modules/services/search/elasticsearch.nix
+++ b/nixos/modules/services/search/elasticsearch.nix
@ -9,6 +9,8 @@ let
    network.host: ${cfg.listenAddress}
    network.port: ${toString cfg.port}
    network.tcp.port: ${toString cfg.tcp_port}
+    # TODO: find a way to enable security manager
+    security.manager.enabled: false
    cluster.name: ${cfg.cluster_name}
    ${cfg.extraConf}
  '';
@ -39,8 +41,8 @@ in {

    package = mkOption {
      description = "Elasticsearch package to use.";
-      default = pkgs.elasticsearch;
-      defaultText = "pkgs.elasticsearch";
+      default = pkgs.elasticsearch2;
+      defaultText = "pkgs.elasticsearch2";
      type = types.package;
    };

@ -129,7 +131,9 @@ in {
      wantedBy = [ "multi-user.target" ];
      after = [ "network-interfaces.target" ];
      path = [ pkgs.inetutils ];
-      environment = { ES_HOME = cfg.dataDir; };
+      environment = {
+        ES_HOME = cfg.dataDir;
+      };
      serviceConfig = {
        ExecStart = "${cfg.package}/bin/elasticsearch -Des.path.conf=${configDir} ${toString cfg.extraCmdLineOptions}";
        User = "elasticsearch";
@ -137,10 +141,11 @@ in {
      };
      preStart = ''
        mkdir -m 0700 -p ${cfg.dataDir}
-        if [ "$(id -u)" = 0 ]; then chown -R elasticsearch ${cfg.dataDir}; fi

        # Install plugins
        ln -sfT ${esPlugins}/plugins ${cfg.dataDir}/plugins
+        ln -sfT ${cfg.package}/lib ${cfg.dataDir}/lib
+        if [ "$(id -u)" = 0 ]; then chown -R elasticsearch ${cfg.dataDir}; fi
      '';
      postStart = mkBefore ''
        until ${pkgs.curl}/bin/curl -s -o /dev/null ${cfg.listenAddress}:${toString cfg.port}; do
--- a/nixos/modules/services/search/kibana.nix
+++ b/nixos/modules/services/search/kibana.nix
@ -7,37 +7,33 @@ let

  cfgFile = pkgs.writeText "kibana.json" (builtins.toJSON (
    (filterAttrsRecursive (n: v: v != null) ({
-      server = {
-        host = cfg.listenAddress;
-        port = cfg.port;
-        ssl = {
-          cert = cfg.cert;
-          key = cfg.key;
-        };
-      };
+      host = cfg.listenAddress;
+      port = cfg.port;
+      ssl_cert_file = cfg.cert;
+      ssl_key_file = cfg.key;

-      kibana = {
-        index = cfg.index;
-        defaultAppId = cfg.defaultAppId;
-      };
+      kibana_index = cfg.index;
+      default_app_id = cfg.defaultAppId;

-      elasticsearch = {
-        url = cfg.elasticsearch.url;
-        username = cfg.elasticsearch.username;
-        password = cfg.elasticsearch.password;
-        ssl = {
-          cert = cfg.elasticsearch.cert;
-          key = cfg.elasticsearch.key;
-          ca = cfg.elasticsearch.ca;
-        };
-      };
+      elasticsearch_url = cfg.elasticsearch.url;
+      kibana_elasticsearch_username = cfg.elasticsearch.username;
+      kibana_elasticsearch_password = cfg.elasticsearch.password;
+      kibana_elasticsearch_cert = cfg.elasticsearch.cert;
+      kibana_elasticsearch_key = cfg.elasticsearch.key;
+      ca = cfg.elasticsearch.ca;

-      logging = {
-        verbose = cfg.logLevel == "verbose";
-        quiet = cfg.logLevel == "quiet";
-        silent = cfg.logLevel == "silent";
-        dest = "stdout";
-      };
+      bundled_plugin_ids = [
+        "plugins/dashboard/index"
+        "plugins/discover/index"
+        "plugins/doc/index"
+        "plugins/kibana/index"
+        "plugins/markdown_vis/index"
+        "plugins/metric_vis/index"
+        "plugins/settings/index"
+        "plugins/table_vis/index"
+        "plugins/vis_types/index"
+        "plugins/visualize/index"
+      ];
    } // cfg.extraConf)
  )));
 in {
@ -118,12 +114,6 @@ in {
      };
    };

-    logLevel = mkOption {
-      description = "Kibana log level";
-      default = "normal";
-      type = types.enum ["verbose" "normal" "silent" "quiet"];
-    };
-
    package = mkOption {
      description = "Kibana package to use";
      default = pkgs.kibana;
@ -149,6 +139,7 @@ in {
      description = "Kibana Service";
      wantedBy = [ "multi-user.target" ];
      after = [ "network-interfaces.target" "elasticsearch.service" ];
+      environment = { BABEL_CACHE_PATH = "${cfg.dataDir}/.babelcache.json"; };
      serviceConfig = {
        ExecStart = "${cfg.package}/bin/kibana --config ${cfgFile}";
        User = "kibana";
--- a/nixos/modules/services/web-servers/apache-httpd/mediawiki.nix
+++ b/nixos/modules/services/web-servers/apache-httpd/mediawiki.nix
@ -83,11 +83,11 @@ let

  # Unpack Mediawiki and put the config file in its root directory.
  mediawikiRoot = pkgs.stdenv.mkDerivation rec {
-    name= "mediawiki-1.23.9";
+    name= "mediawiki-1.23.13";

    src = pkgs.fetchurl {
      url = "http://download.wikimedia.org/mediawiki/1.23/${name}.tar.gz";
-      sha256 = "1l7k4g0pgz92yvrfr52w26x740s4362v0gc95pk0i30vn2sp5bql";
+      sha256 = "168wpf53n4ksj2g5q5r0hxapx6238dvsfng5ff9ixk6axsn0j5d0";
    };

    skins = config.skins;
--- a/nixos/modules/services/x11/hardware/synaptics.nix
+++ b/nixos/modules/services/x11/hardware/synaptics.nix
@ -62,6 +62,13 @@ in {
        description = "Cursor speed factor for highest-speed finger motion.";
      };

+      scrollDelta = mkOption {
+        type = types.nullOr types.int;
+        default = null;
+        example = 75;
+        description = "Move distance of the finger for a scroll event.";
+      };
+
      twoFingerScroll = mkOption {
        type = types.bool;
        default = false;
@ -122,6 +129,20 @@ in {
        description = "Whether to enable palm detection (hardware support required)";
      };

+      palmMinWidth = mkOption {
+        type = types.nullOr types.int;
+        default = null;
+        example = 5;
+        description = "Minimum finger width at which touch is considered a palm";
+      };
+
+      palmMinZ = mkOption {
+        type = types.nullOr types.int;
+        default = null;
+        example = 20;
+        description = "Minimum finger pressure at which touch is considered a palm";
+      };
+
      horizontalScroll = mkOption {
        type = types.bool;
        default = true;
@ -174,8 +195,12 @@ in {
          Option "HorizTwoFingerScroll" "${if cfg.horizTwoFingerScroll then "1" else "0"}"
          Option "VertEdgeScroll" "${if cfg.vertEdgeScroll then "1" else "0"}"
          Option "HorizEdgeScroll" "${if cfg.horizEdgeScroll then "1" else "0"}"
-          ${if cfg.palmDetect then ''Option "PalmDetect" "1"'' else ""}
-          ${if cfg.horizontalScroll then "" else ''Option "HorizScrollDelta" "0"''}
+          ${optionalString cfg.palmDetect ''Option "PalmDetect" "1"''}
+          ${optionalString (cfg.palmMinWidth != null) ''Option "PalmMinWidth" "${toString cfg.palmMinWidth}"''}
+          ${optionalString (cfg.palmMinZ != null) ''Option "PalmMinZ" "${toString cfg.palmMinZ}"''}
+          ${optionalString (cfg.scrollDelta != null) ''Option "VertScrollDelta" "${toString cfg.scrollDelta}"''}
+          ${if !cfg.horizontalScroll then ''Option "HorizScrollDelta" "0"''
+            else (optionalString (cfg.scrollDelta != null) ''Option "HorizScrollDelta" "${toString cfg.scrollDelta}"'')}
          ${cfg.additionalOptions}
        EndSection
      '';
--- a/nixos/modules/services/x11/window-managers/i3.nix
+++ b/nixos/modules/services/x11/window-managers/i3.nix
@ -34,6 +34,6 @@ in
        '';
      }];
    };
-    environment.systemPackages = with pkgs; [ i3 i3status dmenu ];
+    environment.systemPackages = with pkgs; [ i3 ];
  };
 }
--- a/nixos/modules/system/boot/kernel.nix
+++ b/nixos/modules/system/boot/kernel.nix
@ -184,6 +184,9 @@ in
        "ide_disk"
        "ide_generic"

+        # SD cards and internal eMMC drives.
+        "mmc_block"
+
        # Support USB keyboards, in case the boot fails and we only have
        # a USB keyboard.
        "uhci_hcd"
--- a/nixos/modules/system/boot/loader/init-script/init-script-builder.sh
+++ b/nixos/modules/system/boot/loader/init-script/init-script-builder.sh
@ -80,8 +80,13 @@ for generation in $(
    | sort -n -r); do
    link=/nix/var/nix/profiles/system-$generation-link
    date=$(stat --printf="%y\n" $link | sed 's/\..*//')
-    kernelVersion=$(cd $(dirname $(readlink -f $link/kernel))/lib/modules && echo *)
-    addEntry "NixOS - Configuration $generation ($date - $kernelVersion)" $link "$generation ($date)"
+    if [ -d $link/kernel ]; then
+      kernelVersion=$(cd $(dirname $(readlink -f $link/kernel))/lib/modules && echo *)
+      suffix="($date - $kernelVersion)"
+    else
+      suffix="($date)"
+    fi
+    addEntry "NixOS - Configuration $generation $suffix" $link "$generation ($date)"
 done

 mv $tmpOther $targetOther
--- a/nixos/modules/tasks/kbd.nix
+++ b/nixos/modules/tasks/kbd.nix
@ -12,6 +12,8 @@ let
    FONT=${config.i18n.consoleFont}
    ${colors}
  '';
+
+  setVconsole = !config.boot.isContainer;
 in

 {
@ -41,26 +43,33 @@ in

  ###### implementation

-  config = {
+  config = mkMerge [
+    (mkIf (!setVconsole) {
+      systemd.services."systemd-vconsole-setup".enable = false;
+    })

-    environment.systemPackages = [ pkgs.kbd ];
+    (mkIf setVconsole {
+      environment.systemPackages = [ pkgs.kbd ];

-    # Let systemd-vconsole-setup.service do the work of setting up the
-    # virtual consoles.  FIXME: trigger a restart of
-    # systemd-vconsole-setup.service if /etc/vconsole.conf changes.
-    environment.etc."vconsole.conf".source = vconsoleConf;
+      # Let systemd-vconsole-setup.service do the work of setting up the
+      # virtual consoles.  FIXME: trigger a restart of
+      # systemd-vconsole-setup.service if /etc/vconsole.conf changes.
+      environment.etc = [ {
+        target = "vconsole.conf";
+        source = vconsoleConf;
+      } ];

-    # This is identical to the systemd-vconsole-setup.service unit
-    # shipped with systemd, except that it uses /dev/tty1 instead of
-    # /dev/tty0 to prevent putting the X server in non-raw mode, and
-    # it has a restart trigger.
-    systemd.services."systemd-vconsole-setup" =
-      { wantedBy = [ "multi-user.target" ];
-        before = [ "display-manager.service" ];
-        after = [ "systemd-udev-settle.service" ];
-        restartTriggers = [ vconsoleConf ];
-      };
-
-  };
+      # This is identical to the systemd-vconsole-setup.service unit
+      # shipped with systemd, except that it uses /dev/tty1 instead of
+      # /dev/tty0 to prevent putting the X server in non-raw mode, and
+      # it has a restart trigger.
+      systemd.services."systemd-vconsole-setup" =
+        { wantedBy = [ "multi-user.target" ];
+          before = [ "display-manager.service" ];
+          after = [ "systemd-udev-settle.service" ];
+          restartTriggers = [ vconsoleConf ];
+        };
+    })
+  ];

 }
--- a/nixos/modules/tasks/network-interfaces-scripted.nix
+++ b/nixos/modules/tasks/network-interfaces-scripted.nix
@ -144,15 +144,12 @@ in
                  fi
                  ${config.systemd.package}/bin/systemctl start ip-up.target
                '';
-            preStop =
-              ''
-                echo "releasing configured ip's..."
-              '' + flip concatMapStrings (ips) (ip:
+            preStop = flip concatMapStrings (ips) (ip:
                let
                  address = "${ip.address}/${toString ip.prefixLength}";
                in
                ''
-                  echo -n "Deleting ${address}..."
+                  echo -n "deleting ${address}..."
                  ip addr del "${address}" dev "${i.name}" >/dev/null 2>&1 || echo -n " Failed"
                  echo ""
                '');
--- a/nixos/modules/virtualisation/azure-agent.nix
+++ b/nixos/modules/virtualisation/azure-agent.nix
@ -8,10 +8,11 @@ let

  waagent = with pkgs; stdenv.mkDerivation rec {
    name = "waagent-2.0";
-    src = pkgs.fetchgit {
-      url = https://github.com/Phreedom/WALinuxAgent.git;
-      rev = "9dba81c7b1239c7971ec96e405e403c7cd224e6b";
-      sha256 = "0khxk3ns3z37v26f2qj6m3m698a0vqpc9bxg5p7fyr3xza5gzwhs";
+    src = pkgs.fetchFromGitHub {
+      owner = "phreedom";
+      repo = "WALinuxAgent";
+      rev = "1d31fe8cbc7f842993eed9b33a3d3f5410c364e3";
+      sha256 = "1s53pfmy3azp0rmympmnphyq96sr9jy07pbsfza6mdzpalx1ripl";
    };
    buildInputs = [ makeWrapper python pythonPackages.wrapPython ];
    runtimeDeps = [ findutils gnugrep gawk coreutils openssl openssh
--- a/nixos/modules/virtualisation/qemu-vm.nix
+++ b/nixos/modules/virtualisation/qemu-vm.nix
@ -110,6 +110,7 @@ let

  # Generate a hard disk image containing a /boot partition and GRUB
  # in the MBR.  Used when the `useBootLoader' option is set.
+  # FIXME: use nixos/lib/make-disk-image.nix.
  bootDisk =
    pkgs.vmTools.runInLinuxVM (
      pkgs.runCommand "nixos-boot-disk"
--- a/nixos/tests/simple.nix
+++ b/nixos/tests/simple.nix
@ -4,7 +4,9 @@ import ./make-test.nix ({ pkgs, ...} : {
    maintainers = [ eelco ];
  };

-  machine = { config, pkgs, ... }: { };
+  machine = { config, pkgs, ... }: {
+    imports = [ ../modules/profiles/minimal.nix ];
+  };

  testScript =
    ''
--- a/pkgs/applications/audio/aeolus/default.nix
+++ b/pkgs/applications/audio/aeolus/default.nix
@ -0,0 +1,28 @@
+{ stdenv, fetchurl, libclthreads, zita-alsa-pcmi, alsaLib, libjack2
+, libclxclient, libX11, libXft, readline}:
+
+stdenv.mkDerivation rec {
+  name = "aeolus-${version}";
+  version = "0.9.0";
+  src = fetchurl {
+    url = "http://kokkinizita.linuxaudio.org/linuxaudio/downloads/${name}.tar.bz2";
+    sha256 = "0dkkibza25a6z9446njqlaynx8gfk5wb828pl9v1snmi5390iggp";
+  };
+
+  buildInputs = [ libclthreads zita-alsa-pcmi alsaLib libjack2 libclxclient
+    libX11 libXft readline ];
+
+  patchPhase = ''sed "s@ldconfig.*@@" -i source/Makefile'';
+
+  preBuild = "cd source";
+
+  makeFlags = "DESTDIR= PREFIX=$(out)";
+
+  meta = {
+    description = "Synthetized (not sampled) pipe organ emulator";
+    homepage = http://kokkinizita.linuxaudio.org/linuxaudio/aeolus/index.html;
+    license = stdenv.lib.licenses.lgpl3;
+    platforms = stdenv.lib.platforms.linux;
+    maintainers = [ stdenv.lib.maintainers.nico202 ];
+  };
+}
--- a/pkgs/applications/audio/easytag/default.nix
+++ b/pkgs/applications/audio/easytag/default.nix
@ -5,11 +5,12 @@

 stdenv.mkDerivation rec {
  name = "easytag-${version}";
-  version = "2.3.2";
+  majorVersion = "2.4";
+  version = "${majorVersion}.1";

  src = fetchurl {
-    url = "mirror://gnome/sources/easytag/2.3/${name}.tar.xz";
-    sha256 = "0bj3sj4yzlnhan38j84acs7qv27fl3xy4rdrfq6dnpz4q6qccm84";
+    url = "mirror://gnome/sources/easytag/${majorVersion}/${name}.tar.xz";
+    sha256 = "1mbpwp3lh6yz5xkaq3a329x4r3chmjsr83r349crhi1gax3mzvxr";
  };

  preFixup = ''
--- a/pkgs/applications/audio/gpodder/default.nix
+++ b/pkgs/applications/audio/gpodder/default.nix
@ -1,50 +1,43 @@
-{ pkgs, stdenv, fetchurl, python, buildPythonPackage, pythonPackages, mygpoclient, intltool,
-  ipodSupport ? true, libgpod, gnome3 }:
+{ stdenv, fetchurl, buildPythonPackage, pythonPackages, mygpoclient, intltool
+, ipodSupport ? true, libgpod
+, gnome3
+}:

-with pkgs.lib;
+buildPythonPackage rec {
+  name = "gpodder-${version}";
+  namePrefix = "";

-let
-  inherit (pythonPackages) coverage feedparser minimock sqlite3 dbus pygtk eyeD3;
-
-in buildPythonPackage rec {
-  name = "gpodder-3.8.4";
+  version = "3.9.0";

  src = fetchurl {
    url = "http://gpodder.org/src/${name}.tar.gz";
-    sha256 = "0cjpk92qjsws7ddbnq0r2h7vm5019zlpafgbxwsgllmjzkknj6pn";
+    sha256 = "1ik954idi0ldnw0wrv7mm71smyb6x66332jxcaf1dxsl12ccm44l";
  };

+  postPatch = with stdenv.lib; ''
+    sed -i -re 's,^( *gpodder_dir *= *).*,\1"'"$out"'",' bin/gpodder
+
+    makeWrapperArgs="--suffix XDG_DATA_DIRS : '${concatStringsSep ":" [
+      "${gnome3.gnome_themes_standard}/share"
+      "$XDG_ICON_DIRS"
+      "$GSETTINGS_SCHEMAS_PATH"
+    ]}'"
+  '';
+
  buildInputs = [
-    coverage minimock sqlite3 mygpoclient intltool
+    intltool pythonPackages.coverage pythonPackages.minimock
    gnome3.gnome_themes_standard gnome3.defaultIconTheme
    gnome3.gsettings_desktop_schemas
  ];

-  propagatedUserEnvPkgs = [ gnome3.gnome_themes_standard ];
+  propagatedBuildInputs = with pythonPackages; [
+    feedparser dbus mygpoclient sqlite3 pygtk eyeD3
+  ] ++ stdenv.lib.optional ipodSupport libgpod;

-  pythonPath = [ feedparser dbus mygpoclient sqlite3 pygtk eyeD3 ]
-    ++ stdenv.lib.optional ipodSupport libgpod;
-
-  postPatch = "sed -ie 's/PYTHONPATH=src/PYTHONPATH=\$(PYTHONPATH):src/' makefile";
-
-  preFixup = ''
-    wrapProgram $out/bin/gpodder \
-      --prefix XDG_DATA_DIRS : "${gnome3.gnome_themes_standard}/share:$XDG_ICON_DIRS:$GSETTINGS_SCHEMAS_PATH"
+  checkPhase = ''
+    LC_ALL=C python -m gpodder.unittests
  '';

-  # The `wrapPythonPrograms` script in the postFixup phase breaks gpodder. The
-  # easiest way to fix this is to call wrapPythonPrograms and then to clean up
-  # the wrapped file.
-  postFixup = ''
-    wrapPythonPrograms
-
-    sed -i "$out/bin/..gpodder-wrapped-wrapped" -e '{
-        /import sys; sys.argv/d
-    }'
-  '';
-
-  installPhase = "DESTDIR=/ PREFIX=$out make install";
-
  meta = {
    description = "A podcatcher written in python";
    longDescription = ''
--- a/pkgs/applications/audio/iannix/default.nix
+++ b/pkgs/applications/audio/iannix/default.nix
@ -0,0 +1,29 @@
+{ stdenv, fetchFromGitHub, alsaLib, pkgconfig, qt5
+}:
+
+stdenv.mkDerivation rec {
+  name = "iannix-${version}";
+  version = "2016-01-31";
+  src = fetchFromGitHub {
+    owner = "iannix";
+    repo = "IanniX";
+    rev = "f84becdcbe154b20a53aa2622068cb8f6fda0755";
+    sha256 = "184ydb9f1303v332k5k3f1ki7cb6nkxhh6ij0yn72v7dp7figrgj";
+  };
+
+    buildInputs = [ alsaLib pkgconfig qt5.qtbase qt5.qtscript ];
+
+  configurePhase = ''qmake PREFIX=/'';
+
+  installFlags = [ "INSTALL_ROOT=$(out)" ];
+
+  enableParallelBuilding = true;
+
+  meta = {
+    description = "Graphical open-source sequencer,";
+    homepage = http://www.iannix.org/;
+    license = stdenv.lib.licenses.lgpl3;
+    platforms = stdenv.lib.platforms.linux;
+    maintainers = [ stdenv.lib.maintainers.nico202 ];
+  };
+}
--- a/pkgs/applications/audio/jamin/default.nix
+++ b/pkgs/applications/audio/jamin/default.nix
@ -0,0 +1,29 @@
+{ stdenv, fetchurl, fftwFloat, gtk2, ladspaPlugins, libjack2, liblo, libxml2
+, makeWrapper, pkgconfig, perl, perlXMLParser
+}:
+
+stdenv.mkDerivation {
+  name = "jamin-0.95.0";
+
+  src = fetchurl {
+    url = mirror://sourceforge/jamin/jamin-0.95.0.tar.gz;
+    sha256 = "0g5v74cm0q3p3pzl6xmnp4rqayaymfli7c6z8s78h9rgd24fwbvn";
+  };
+
+  buildInputs = [
+    fftwFloat gtk2 ladspaPlugins libjack2 liblo libxml2 pkgconfig perl
+    perlXMLParser makeWrapper
+  ];
+  
+  postInstall = ''
+    wrapProgram $out/bin/jamin --set LADSPA_PATH ${ladspaPlugins}/lib/ladspa
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = http://jamin.sourceforge.net;
+    description = "JACK Audio Mastering interface";
+    license = licenses.gpl2;
+    maintainers = [ maintainers.nico202 ];
+    platforms = platforms.linux;
+  };
+}
--- a/pkgs/applications/audio/non/default.nix
+++ b/pkgs/applications/audio/non/default.nix
@ -4,12 +4,12 @@ ladspaH, liblrdf, liblo, libsigcxx

 stdenv.mkDerivation rec {
  name = "non-${version}";
-  version = "2015-12-16";
+  version = "2016-02-07";
  src = fetchFromGitHub {
    owner = "original-male";
    repo = "non";
-    rev = "5d274f430c867f73ed1dcb306b49be0371d28128";
-    sha256 = "1yckac3r1hqn5p450j4lf4349v4knjj7n9s5p3wdcvxhs0pjv2sy";
+    rev = "1ef382fbbea598fdb56b25244a703c64ecaf8446";
+    sha256 = "1mi3nm0nrrqlk36920irvqf5080lbnj1qc8vnxspgwkjjqgdc22g";
  };

    buildInputs = [ pkgconfig python2 cairo libjpeg ntk libjack2 libsndfile
--- a/pkgs/applications/audio/patchage/default.nix
+++ b/pkgs/applications/audio/patchage/default.nix
@ -0,0 +1,30 @@
+{ stdenv, alsaLib, boost, dbus_glib, fetchsvn, ganv, glibmm, gtk2
+, gtkmm, libjack2, pkgconfig, python2
+}:
+
+stdenv.mkDerivation rec {
+  name = "patchage-${version}";
+  version = "1.0.1";
+  src = fetchsvn {
+    url = http://svn.drobilla.net/lad/trunk/patchage/;
+    rev = "5821";
+    sha256 = "1ar64l0sg468qzxj7i6ppgfqjpm92awcp5lzskamrf3ln17lrgj7";
+  };
+
+  buildInputs = [
+    alsaLib boost dbus_glib ganv glibmm gtk2 gtkmm libjack2
+    pkgconfig python2
+  ];
+
+  configurePhase = "python waf configure --prefix=$out";
+  buildPhase = "python waf build";
+  installPhase = "python waf install";
+
+  meta = {
+    description = "Modular patch bay for Jack and ALSA systems";
+    homepage = http://non.tuxfamily.org;
+    license = stdenv.lib.licenses.lgpl3;
+    platforms = stdenv.lib.platforms.linux;
+    maintainers = [ stdenv.lib.maintainers.nico202 ];
+  };
+}
--- a/pkgs/applications/audio/qtscrobbler/default.nix
+++ b/pkgs/applications/audio/qtscrobbler/default.nix
@ -0,0 +1,36 @@
+{ stdenv, lib, fetchurl, withMtp ? true, libmtp, pkgconfig, which, qt4 }:
+
+stdenv.mkDerivation rec {
+  name = "qtscrobbler-${version}";
+  version = "0.11";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/qtscrob/qtscrob/${version}/qtscrob-${version}.tar.bz2";
+    sha256 = "01c8e48f616ed09504833d27d92fd62f455bd645ea2d1cc2a5f4c287d641daba";
+  };
+
+  nativeBuildInputs = lib.optionals withMtp [ pkgconfig which ];
+  buildInputs = [ qt4 ] ++ lib.optional withMtp libmtp;
+
+  enableParallelBuilding = true;
+
+  postPatch = ''
+    cd src
+    sed -i "s,/usr/local,$out," common.pri
+  '';
+
+  configurePhase = "qmake";
+
+  meta = with lib; {
+    description = "Qt based last.fm scrobbler";
+    longDescription = ''
+      QTScrobbler is a tool to upload information about the tracks you have played from your Digital Audio Player (DAP) to your last.fm account.
+      It is able to gather this information from Apple iPods or DAPs running the Rockbox replacement firmware.
+    '';
+
+    homepage = http://qtscrob.sourceforge.net;
+    license = licenses.gpl2;
+    maintainers = [ maintainers.vanzef ];
+    platforms = platforms.linux;
+  };
+}
--- a/pkgs/applications/audio/sonata/default.nix
+++ b/pkgs/applications/audio/sonata/default.nix
@ -0,0 +1,73 @@
+{ pkgs, stdenv, fetchFromGitHub, pkgconfig, intltool, wrapGAppsHook,
+  python, buildPythonPackage, isPy3k,
+  gnome3, gtk3, gobjectIntrospection,
+  dbus, pygobject3, mpd2 }:
+
+with pkgs.lib;
+
+buildPythonPackage rec {
+  name = "sonata-${version}";
+  version = "1.7b1";
+  namePrefix = "";
+
+  src = fetchFromGitHub {
+    owner = "multani";
+    repo = "sonata";
+    rev = "v${version}";
+    sha256 = "1npbxlrg6k154qybfd250nq2p96kxdsdkj9wwnp93gljnii3g8wh";
+  };
+
+  disabled = !isPy3k;
+
+  buildInputs = [
+    pkgconfig intltool wrapGAppsHook
+    gnome3.gnome_themes_standard gnome3.defaultIconTheme
+    gnome3.gsettings_desktop_schemas
+  ];
+
+  postPatch = ''
+    # Remove "Local MPD" tab which is not suitable for NixOS.
+    sed -i '/localmpd/d' sonata/consts.py
+  '';
+
+  propagatedUserEnvPkgs = [ gnome3.gnome_themes_standard ];
+
+  propagatedBuildInputs = [
+    gobjectIntrospection gtk3 pygobject3
+  ];
+
+  # The optional tagpy dependency (for editing metadata) is not yet
+  # included because it's difficult to build.
+  pythonPath = [ dbus pygobject3 mpd2 ];
+
+  meta = {
+    description = "An elegant client for the Music Player Daemon";
+    longDescription = ''
+      Sonata is an elegant client for the Music Player Daemon.
+
+      Written in Python and using the GTK+ 3 widget set, its features
+      include:
+
+       - Expanded and collapsed views
+       - Automatic remote and local album art
+       - Library browsing by folders, or by genre/artist/album
+       - User-configurable columns
+       - Automatic fetching of lyrics
+       - Playlist and stream support
+       - Support for editing song tags (not in NixOS version)
+       - Drag and drop to copy files
+       - Popup notification
+       - Library and playlist searching, filter as you type
+       - Audioscrobbler (last.fm) 1.2 support
+       - Multiple MPD profiles
+       - Keyboard friendly
+       - Support for multimedia keys
+       - Commandline control
+       - Available in 24 languages
+    '';
+    homepage = "http://www.nongnu.org/sonata/";
+    license = stdenv.lib.licenses.gpl3;
+    platforms = stdenv.lib.platforms.linux;
+    maintainers = [ stdenv.lib.maintainers.rvl ];
+  };
+}
--- a/pkgs/applications/audio/spectrojack/default.nix
+++ b/pkgs/applications/audio/spectrojack/default.nix
@ -0,0 +1,30 @@
+{ stdenv, fetchurl, pkgconfig, libjack2, fftwFloat, gtk2 }:
+
+stdenv.mkDerivation rec {
+  name = "spectrojack-${version}";
+  version = "0.4";
+
+  src = fetchurl {
+    url = "http://sed.free.fr/spectrojack/${name}.tar.gz";
+    sha256 = "0p5aa55hnazv5djw0431mza068h7mjkb9pnglxfpqkx5z0czisdx";
+  };
+  buildInputs = [ pkgconfig libjack2 fftwFloat gtk2 ];
+  configurePhase= ''
+    sed -i 's/.*home.*/#&/' ./Makefile
+    substituteInPlace ./Makefile \
+      --replace "/usr/share" "$out/usr/share"
+  '';
+  installPhase= ''
+    install -Dm755 spectrojack $out/bin/spectrojack
+    install -Dm644 spectrojack_icon.svg $out/usr/share/spectrojack/icon.svg
+    install -Dm644 -t $out/usr/share/spectrojack/colormaps colormaps/*
+  '';
+
+  meta = {
+    description = "A little spectrogram/audiogram/sonogram/whatever for JACK";
+    homepage = http://sed.free.fr/spectrojack;
+    license = stdenv.lib.licenses.publicDomain;
+    maintainers = with stdenv.lib.maintainers; [ sleexyz ];
+    platforms = with stdenv.lib.platforms; linux;
+  };
+}
--- a/pkgs/applications/audio/timemachine/default.nix
+++ b/pkgs/applications/audio/timemachine/default.nix
@ -0,0 +1,29 @@
+{ stdenv, fetchFromGitHub, autoconf, automake, pkgconfig, gtk2
+, libjack2, libsndfile
+}:
+
+stdenv.mkDerivation rec {
+  name = "timemachine-${version}";
+  version = "0.3.1";
+  src = fetchFromGitHub {
+    owner = "swh";
+    repo = "timemachine";
+    rev = "1966d8524d4e4c47c525473bab3b010a168adc98";
+    sha256 = "0w5alysixnvlkfl79wf7vs5wsw2vgxl3gqxxcm0zbmhjdpmjpcal";
+  };
+
+    buildInputs = [ autoconf automake pkgconfig gtk2 libjack2
+      libsndfile
+    ];
+
+  preConfigure = "./autogen.sh";
+
+  meta = {
+    description = "JACK audio recorder";
+    homepage = http://plugin.org.uk/timemachine/;
+    license = stdenv.lib.licenses.lgpl2;
+    platforms = stdenv.lib.platforms.linux;
+    maintainers = [ stdenv.lib.maintainers.nico202 ];
+  };
+}
+
--- a/pkgs/applications/editors/atom/default.nix
+++ b/pkgs/applications/editors/atom/default.nix
@ -16,11 +16,11 @@ let
  };
 in stdenv.mkDerivation rec {
  name = "atom-${version}";
-  version = "1.4.0";
+  version = "1.5.3";

  src = fetchurl {
    url = "https://github.com/atom/atom/releases/download/v${version}/atom-amd64.deb";
-    sha256 = "0dipww58p0sm99jn1ariisha9wsnhl7rnd8achpxqkf4b3vwi5iz";
+    sha256 = "101fz4c5pj7yp7fg7kg7vcpqjzpwfrbxdyb6va5liip1llg1i2z3";
    name = "${name}.deb";
  };

@ -51,7 +51,7 @@ in stdenv.mkDerivation rec {
    description = "A hackable text editor for the 21st Century";
    homepage = https://atom.io/;
    license = licenses.mit;
-    maintainers = [ maintainers.offline ];
+    maintainers = [ maintainers.offline maintainers.nequissimus ];
    platforms = [ "x86_64-linux" ];
  };
 }
--- a/pkgs/applications/editors/emacs-modes/color-theme-solarized/default.nix
+++ b/pkgs/applications/editors/emacs-modes/color-theme-solarized/default.nix
@ -27,7 +27,7 @@ stdenv.mkDerivation rec {
  meta = {
    description = "Precision colors for machines and people";
    homepage = http://ethanschoonover.com/solarized;
-    maintainer = "Samuel Rivas <samuelrivas@gmail.com>";
+    maintainers = "Samuel Rivas <samuelrivas@gmail.com>";
    license = stdenv.lib.licenses.mit;

    platforms = stdenv.lib.platforms.all;
--- a/pkgs/applications/editors/neovim/default.nix
+++ b/pkgs/applications/editors/neovim/default.nix
@ -21,8 +21,8 @@ let
    version = "2015-11-06";

    src = fetchFromGitHub {
-      sha256 = "0f9r0wnr9ajcdd6as24igmch0n8s1annycb9f4k0vg6fngwaypy9";
-      rev = "04781d37ce5af3f580376dc721bd3b89c434966b";
+      sha256 = "090pyf1n5asaw1m2l9bsbdv3zd753aq1plb0w0drbc2k43ds7k3g";
+      rev = "a9c7c6fd20fa35e0ad3e0e98901ca12dfca9c25c";
      repo = "libvterm";
      owner = "neovim";
    };
@ -60,10 +60,10 @@ let

  neovim = stdenv.mkDerivation rec {
    name = "neovim-${version}";
-    version = "0.1.1";
+    version = "0.1.2";

    src = fetchFromGitHub {
-      sha256 = "0crswjslp687yp1cpn7nmm0j2sccqhcxryzxv1s81cgpai0fzf60";
+      sha256 = "128aznp2gj08bdz05ri8mqday7wcsy9yz7dw7vdgzk0pk23vjz89";
      rev = "v${version}";
      repo = "neovim";
      owner = "neovim";
--- a/pkgs/applications/editors/sublime3/default.nix
+++ b/pkgs/applications/editors/sublime3/default.nix
@ -6,7 +6,7 @@ assert stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux";
 assert gksuSupport -> gksu != null;

 let
-  build = "3101";
+  build = "3103";
  libPath = stdenv.lib.makeLibraryPath [glib xorg.libX11 gtk cairo pango];
  redirects = [ "/usr/bin/pkexec=${pkexecPath}" ]
    ++ stdenv.lib.optional gksuSupport "/usr/bin/gksudo=${gksu}/bin/gksudo";
@ -20,13 +20,13 @@ in let
        fetchurl {
          name = "sublimetext-${build}.tar.bz2";
          url = "https://download.sublimetext.com/sublime_text_3_build_${build}_x32.tar.bz2";
-          sha256 = "1klssh79mxm7i6r77p9a6a1rqzssnkv5y4k37bnxv8bilwqhfrcz";
+          sha256 = "1qidnczndyhyp9rfzmpqah00lrx7z1a0fy7a13lzwqq3gslhwf1l";
        }
      else
        fetchurl {
          name = "sublimetext-${build}.tar.bz2";
          url = "https://download.sublimetext.com/sublime_text_3_build_${build}_x64.tar.bz2";
-          sha256 = "0yrhn2mc5f2y4cy2ydya4h97bij0cm51yd4q06l6yjshl6qyc2db";
+          sha256 = "1x8kb3prs6wa5s5rj0gfq96zx6k5q3s168yhfsa36x2szi6x6y4x";
        };

    dontStrip = true;
--- a/pkgs/applications/editors/vim/configurable.nix
+++ b/pkgs/applications/editors/vim/configurable.nix
@ -154,6 +154,7 @@ composableDerivation {
    multibyteSupport = config.vim.multibyte or false;
    cscopeSupport    = config.vim.cscope or true;
    netbeansSupport  = config.netbeans or true; # eg envim is using it
+    ximSupport       = config.vim.xim or false;

    # by default, compile with darwin support if we're compiling on darwin, but
    # allow this to be disabled by setting config.vim.darwin to false
--- a/pkgs/applications/graphics/ImageMagick/default.nix
+++ b/pkgs/applications/graphics/ImageMagick/default.nix
@ -7,6 +7,7 @@ let
  arch =
    if stdenv.system == "i686-linux" then "i686"
    else if stdenv.system == "x86_64-linux" || stdenv.system == "x86_64-darwin" then "x86-64"
+    else if stdenv.system == "armv7l-linux" then "armv7l"
    else throw "ImageMagick is not supported on this platform.";
 in

--- a/pkgs/applications/graphics/glabels/default.nix
+++ b/pkgs/applications/graphics/glabels/default.nix
@ -0,0 +1,38 @@
+{ stdenv, fetchFromGitHub, autoconf, automake, barcode, gnome3
+, gtk3, gtk_doc, libxml2, librsvg , libtool, libe-book
+, intltool, itstool, makeWrapper, pkgconfig, which
+}:
+
+stdenv.mkDerivation rec {
+  name = "glabels-${version}";
+  version = "3.2.1";
+  src = fetchFromGitHub {
+    owner = "jimevins";
+    repo = "glabels";
+    rev = "glabels-3_2_1";
+    sha256 = "1y6gz0v9si3cvdzhakbgkyc94fajg19rmykfgnc37alrc21vs9zg";
+  };
+
+  buildInputs = [
+    autoconf automake barcode gtk3 gtk_doc gnome3.yelp_tools
+    gnome3.gnome_common gnome3.gsettings_desktop_schemas
+    intltool itstool libxml2 librsvg libe-book libtool
+    makeWrapper pkgconfig 
+  ];
+
+  preFixup = ''
+    rm "$out/share/icons/hicolor/icon-theme.cache"
+    wrapProgram "$out/bin/glabels-3" \
+      --prefix XDG_DATA_DIRS : "$GSETTINGS_SCHEMAS_PATH"
+  '';
+
+  preConfigure = "./autogen.sh";
+
+  meta = {
+    description = "Create labels and business cards";
+    homepage = http://glabels.org/;
+    license = stdenv.lib.licenses.gpl2;
+    platforms = stdenv.lib.platforms.unix;
+    maintainers = [ stdenv.lib.maintainers.nico202 ];
+  };
+}
--- a/pkgs/applications/graphics/imv/default.nix
+++ b/pkgs/applications/graphics/imv/default.nix
@ -1,19 +1,16 @@
-{ stdenv, fetchFromGitHub,
-  SDL2, freeimage
-}:
+{ stdenv, fetchgit, SDL2, SDL2_ttf, freeimage }:

 stdenv.mkDerivation rec {
  name = "imv-${version}";
-  version = "1.1.0";
+  version = "2.0.0";

-  src = fetchFromGitHub {
-    owner = "eXeC64";
-    repo  = "imv";
-    rev = "4d1a6d581b70b25d9533c5c788aab6900ebf82bb";
-    sha256 = "1c5r4pqqypir8ymicxyn2k7mhq8nl88b3x6giaafd77ssjn0vz9r";
+  src = fetchgit {
+    url = "https://github.com/eXeC64/imv.git";
+    rev = "bc90a0adcc5b22d2bf0158333eb6dfb34c402d48";
+    sha256 = "1bzx57d9mcxw9s72pdbdbwq9pns946jl6p2g881z43w68gimlpw7";
  };

-  buildInputs = [ SDL2 freeimage ];
+  buildInputs = [ SDL2 SDL2_ttf freeimage ];

  configurePhase = "substituteInPlace Makefile --replace /usr $out";

--- a/pkgs/applications/graphics/sane/backends/generic.nix
+++ b/pkgs/applications/graphics/sane/backends/generic.nix
@ -50,6 +50,9 @@ stdenv.mkDerivation {
    mkdir -p $out/etc/udev/rules.d/
    ./tools/sane-desc -m udev > $out/etc/udev/rules.d/49-libsane.rules || \
    cp tools/udev/libsane.rules $out/etc/udev/rules.d/49-libsane.rules
+    # the created 49-libsane references /bin/sh
+    substituteInPlace $out/etc/udev/rules.d/49-libsane.rules \
+      --replace "RUN+=\"/bin/sh" "RUN+=\"${stdenv.shell}"

    substituteInPlace $out/lib/libsane.la \
      --replace "-ljpeg" "-L${libjpeg}/lib -ljpeg"
--- a/pkgs/applications/graphics/simple-scan/default.nix
+++ b/pkgs/applications/graphics/simple-scan/default.nix
@ -3,10 +3,10 @@

 stdenv.mkDerivation rec {
  name = "simple-scan-${version}";
-  version = "3.19.4";
+  version = "3.19.90";

  src = fetchurl {
-    sha256 = "1v9sify1s38qd5sfg26m7sdg9bkrfmai2nijs4wzah7xa9p23c83";
+    sha256 = "16s8855sqrn5iiirpqva0mys8abfpzk9xryrb6rpjbynvx2lanmd";
    url = "https://launchpad.net/simple-scan/3.19/${version}/+download/${name}.tar.xz";
  };

--- a/pkgs/applications/misc/adobe-reader/default.nix
+++ b/pkgs/applications/misc/adobe-reader/default.nix
@ -22,6 +22,8 @@ stdenv.mkDerivation {
  libPath = stdenv.lib.makeLibraryPath
    [ stdenv.cc.cc libX11 zlib libxml2 cups pango atk gtk glib gdk_pixbuf ];

+  passthru.mozillaPlugin = "/libexec/adobe-reader/Browser/intellinux";
+
  meta = {
    description = "Adobe Reader, a viewer for PDF documents";
    homepage = http://www.adobe.com/products/reader;
--- a/pkgs/applications/misc/calibre/default.nix
+++ b/pkgs/applications/misc/calibre/default.nix
@ -5,12 +5,12 @@
 }:

 stdenv.mkDerivation rec {
-  version = "2.50.1";
+  version = "2.51.0";
  name = "calibre-${version}";

  src = fetchurl {
    url = "http://download.calibre-ebook.com/${version}/${name}.tar.xz";
-    sha256 = "0fy5fwj53hl8bcl412d2y61xm1nmkry24dlanj07nn6dhmrs0cm9";
+    sha256 = "1rhpcxic4g2zyr5s3xn8dayyb45l9r8zyniaig8j7pl5kmsfjijn";
  };

  inherit python;
--- a/pkgs/applications/misc/dmenu/wayland.nix
+++ b/pkgs/applications/misc/dmenu/wayland.nix
@ -0,0 +1,34 @@
+{stdenv, fetchurl #, libX11, libXinerama, enableXft, libXft, zlib
+, swc, wld, wayland, libxkbcommon, pixman, fontconfig
+}:
+
+with stdenv.lib;
+
+stdenv.mkDerivation rec {
+  name = "dmenu-wayland-${version}";
+  version = "git-2014-11-02";
+  rev = "6e08b77428cc3c406ed2e90d4cae6c41df76341e";
+
+  src = fetchurl {
+    url = "https://github.com/michaelforney/dmenu/archive/${rev}.tar.gz";
+    sha256 = "d0f73e442baf44a93a3b9d41a72e9cfa14f54af6049c90549f516722e3f88019";
+  };
+
+  buildInputs = [ swc wld wayland libxkbcommon pixman fontconfig ];
+
+  postPatch = ''
+    sed -ri -e 's!\<(dmenu|dmenu_path)\>!'"$out/bin"'/&!g' dmenu_run
+  '';
+
+  preConfigure = [
+    ''sed -i "s@PREFIX = /usr/local@PREFIX = $out@g; s@/usr/share/swc@$(echo "$nativeBuildInputs" | grep -o '[^ ]*-swc-[^ ]*')/share/swc@g" config.mk''
+  ];
+
+  meta = {
+      description = "a generic, highly customizable, and efficient menu for the X Window System";
+      homepage = http://tools.suckless.org/dmenu;
+      license = stdenv.lib.licenses.mit;
+      maintainers = with stdenv.lib.maintainers; [ ];
+      platforms = with stdenv.lib.platforms; all;
+  };
+}
--- a/pkgs/applications/misc/gammu/default.nix
+++ b/pkgs/applications/misc/gammu/default.nix
@ -1,5 +1,8 @@
 { stdenv, fetchurl, python, pkgconfig, cmake, bluez, libusb1, curl
-, libiconv, gettext, sqlite }:
+, libiconv, gettext, sqlite
+, dbiSupport ? false, libdbi ? null, libdbiDrivers ? null
+, postgresSupport ? false, postgresql ? null
+}:

 with stdenv.lib;

@ -14,13 +17,15 @@ stdenv.mkDerivation rec {

  patches = [ ./bashcomp-dir.patch ];

-  buildInputs = [ python pkgconfig cmake bluez libusb1 curl gettext sqlite libiconv ];
+  buildInputs = [ python pkgconfig cmake bluez libusb1 curl gettext sqlite libiconv ]
+  ++ optionals dbiSupport [ libdbi libdbiDrivers ]
+  ++ optionals postgresSupport [ postgresql ];

  enableParallelBuilding = true;

  meta = {
    homepage = "http://wammu.eu/gammu/";
-    description = "Command line utility and library to control mobil phones";
+    description = "Command line utility and library to control mobile phones";
    license = licenses.gpl2;
    platforms = platforms.linux;
    maintainers = [ maintainers.coroa ];
--- a/pkgs/applications/misc/gollum/Gemfile
+++ b/pkgs/applications/misc/gollum/Gemfile
@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gem 'gollum'
--- a/pkgs/applications/misc/gollum/Gemfile.lock
+++ b/pkgs/applications/misc/gollum/Gemfile.lock
@ -0,0 +1,55 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    charlock_holmes (0.7.3)
+    diff-lcs (1.2.5)
+    github-markup (1.3.3)
+    gitlab-grit (2.7.3)
+      charlock_holmes (~> 0.6)
+      diff-lcs (~> 1.1)
+      mime-types (~> 1.15)
+      posix-spawn (~> 0.3)
+    gollum (4.0.1)
+      gollum-lib (~> 4.0, >= 4.0.1)
+      kramdown (~> 1.8.0)
+      mustache (>= 0.99.5, < 1.0.0)
+      sinatra (~> 1.4, >= 1.4.4)
+      useragent (~> 0.14.0)
+    gollum-grit_adapter (1.0.0)
+      gitlab-grit (~> 2.7, >= 2.7.1)
+    gollum-lib (4.1.0)
+      github-markup (~> 1.3.3)
+      gollum-grit_adapter (~> 1.0)
+      nokogiri (~> 1.6.4)
+      rouge (~> 1.9)
+      sanitize (~> 2.1.0)
+      stringex (~> 2.5.1)
+    kramdown (1.8.0)
+    mime-types (1.25.1)
+    mini_portile2 (2.0.0)
+    mustache (0.99.8)
+    nokogiri (1.6.7.2)
+      mini_portile2 (~> 2.0.0.rc2)
+    posix-spawn (0.3.11)
+    rack (1.6.4)
+    rack-protection (1.5.3)
+      rack
+    rouge (1.10.1)
+    sanitize (2.1.0)
+      nokogiri (>= 1.4.4)
+    sinatra (1.4.7)
+      rack (~> 1.5)
+      rack-protection (~> 1.4)
+      tilt (>= 1.3, < 3)
+    stringex (2.5.2)
+    tilt (2.0.2)
+    useragent (0.14.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  gollum
+
+BUNDLED WITH
+   1.10.6
--- a/pkgs/applications/misc/gollum/default.nix
+++ b/pkgs/applications/misc/gollum/default.nix
@ -0,0 +1,18 @@
+{ stdenv, lib, bundlerEnv, ruby_2_2, icu, zlib }:
+
+bundlerEnv rec {
+  name = "gollum-${version}";
+  version = "4.0.1";
+
+  ruby = ruby_2_2;
+  gemfile = ./Gemfile;
+  lockfile = ./Gemfile.lock;
+  gemset = ./gemset.nix;
+
+  meta = with lib; {
+    description = "A simple, Git-powered wiki";
+    license = licenses.mit;
+    maintainers = with maintainers; [ jgillich ];
+    platforms = platforms.unix;
+  };
+}
--- a/pkgs/applications/misc/gollum/gemset.nix
+++ b/pkgs/applications/misc/gollum/gemset.nix
@ -0,0 +1,170 @@
+{
+  useragent = {
+    version = "0.14.0";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "124r3mgkw1zjymsqq9r25zh1vwjrjgiji5fm620z53lpmmryj22j";
+    };
+  };
+  tilt = {
+    version = "2.0.2";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "0lkd40xfdqkp333vdfhrfjmi2y7k2hjs4azawfb62mrkfp7ivj84";
+    };
+  };
+  stringex = {
+    version = "2.5.2";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "150adm7rfh6r9b5ra6vk75mswf9m3wwyslcf8f235a08m29fxa17";
+    };
+  };
+  sinatra = {
+    version = "1.4.7";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "1b81kbr65mmcl9cdq2r6yc16wklyp798rxkgmm5pr9fvsj7jwmxp";
+    };
+  };
+  sanitize = {
+    version = "2.1.0";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "0xsv6xqrlz91rd8wifjknadbl3z5h6qphmxy0hjb189qbdghggn3";
+    };
+  };
+  rouge = {
+    version = "1.10.1";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "0wp8as9ypdy18kdj9h70kny1rdfq71mr8cj2bpahr9vxjjvjasqz";
+    };
+  };
+  rack-protection = {
+    version = "1.5.3";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "0cvb21zz7p9wy23wdav63z5qzfn4nialik22yqp6gihkgfqqrh5r";
+    };
+  };
+  rack = {
+    version = "1.6.4";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "09bs295yq6csjnkzj7ncj50i6chfxrhmzg1pk6p0vd2lb9ac8pj5";
+    };
+  };
+  posix-spawn = {
+    version = "0.3.11";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "052lnxbkvlnwfjw4qd7vn2xrlaaqiav6f5x5bcjin97bsrfq6cmr";
+    };
+  };
+  nokogiri = {
+    version = "1.6.7.2";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "11sbmpy60ynak6s3794q32lc99hs448msjy8rkp84ay7mq7zqspv";
+    };
+  };
+  mustache = {
+    version = "0.99.8";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "1g5hplm0k06vwxwqzwn1mq5bd02yp0h3rym4zwzw26aqi7drcsl2";
+    };
+  };
+  mini_portile2 = {
+    version = "2.0.0";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "056drbn5m4khdxly1asmiik14nyllswr6sh3wallvsywwdiryz8l";
+    };
+  };
+  mime-types = {
+    version = "1.25.1";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "0mhzsanmnzdshaba7gmsjwnv168r1yj8y0flzw88frw1cickrvw8";
+    };
+  };
+  kramdown = {
+    version = "1.8.0";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "0ryqq055h5n10c1cfba6pxsssa907l2hkw29anp0d41ryh47ca2l";
+    };
+  };
+  gollum-lib = {
+    version = "4.1.0";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "01s8pgzhc3cgcmsy6hh79wrcbn5vbadniq2a7d4qw87kpq7mzfdm";
+    };
+  };
+  gollum-grit_adapter = {
+    version = "1.0.0";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "02c5qfq0s0kx2ifnpbnbgz6258fl7rchzzzc7vpx72shi8gbpac7";
+    };
+  };
+  gollum = {
+    version = "4.0.1";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "02pgx083sns75zgnqx94p5h5bpr7cfiw5mys4ayb4k33hcjm6ydg";
+    };
+  };
+  gitlab-grit = {
+    version = "2.7.3";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "0nv8shx7w7fww8lf5a2rbvf7bq173rllm381m6x7g1i0qqc68q1b";
+    };
+  };
+  github-markup = {
+    version = "1.3.3";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "01r901wcgn0gs0n9h684gs5n90y1vaj9lxnx4z5ig611jwa43ivq";
+    };
+  };
+  diff-lcs = {
+    version = "1.2.5";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "1vf9civd41bnqi6brr5d9jifdw73j9khc6fkhfl1f8r9cpkdvlx1";
+    };
+  };
+  charlock_holmes = {
+    version = "0.7.3";
+    source = {
+      type = "gem";
+      remotes = ["https://rubygems.org"];
+      sha256 = "0jsl6k27wjmssxbwv9wpf7hgp9r0nvizcf6qpjnr7qs2nia53lf7";
+    };
+  };
+}
--- a/pkgs/applications/misc/mdp/default.nix
+++ b/pkgs/applications/misc/mdp/default.nix
@ -1,12 +1,12 @@
 { stdenv, fetchurl, ncurses }:

 stdenv.mkDerivation rec {
-  version = "1.0.4";
+  version = "1.0.5";
  name = "mdp-${version}";

  src = fetchurl {
    url = "https://github.com/visit1985/mdp/archive/${version}.tar.gz";
-    sha256 = "1wvys3sb0ki7zz5b0y4bl9x6jdj7h88lxsf8vap95k1sj2ymanlm";
+    sha256 = "0ckd9k5571zc7pzxdx84gv8k103d5qp49f2i477a395fy2pnq4m8";
  };

  makeFlags = "PREFIX=$(out)";
--- a/pkgs/applications/misc/mediainfo-gui/default.nix
+++ b/pkgs/applications/misc/mediainfo-gui/default.nix
@ -1,11 +1,11 @@
 { stdenv, fetchurl, automake, autoconf, libtool, pkgconfig, libzen, libmediainfo, wxGTK, desktop_file_utils, libSM, imagemagick }:

 stdenv.mkDerivation rec {
-  version = "0.7.81";
+  version = "0.7.82";
  name = "mediainfo-gui-${version}";
  src = fetchurl {
    url = "http://mediaarea.net/download/source/mediainfo/${version}/mediainfo_${version}.tar.xz";
-    sha256 = "1aah8y4kqhghqhcfm6ydgf3hj6q05dllfh0m1lbaij0y8yrrwz07";
+    sha256 = "0ivvmxx93aldfbms6wg46x9npghg304j2zxl5i70m710gybjr232";
  };

  buildInputs = [ automake autoconf libtool pkgconfig libzen libmediainfo wxGTK desktop_file_utils libSM imagemagick ];
--- a/pkgs/applications/misc/mediainfo/default.nix
+++ b/pkgs/applications/misc/mediainfo/default.nix
@ -1,11 +1,11 @@
 { stdenv, fetchurl, automake, autoconf, libtool, pkgconfig, libzen, libmediainfo, zlib }:

 stdenv.mkDerivation rec {
-  version = "0.7.81";
+  version = "0.7.82";
  name = "mediainfo-${version}";
  src = fetchurl {
    url = "http://mediaarea.net/download/source/mediainfo/${version}/mediainfo_${version}.tar.xz";
-    sha256 = "1aah8y4kqhghqhcfm6ydgf3hj6q05dllfh0m1lbaij0y8yrrwz07";
+    sha256 = "0ivvmxx93aldfbms6wg46x9npghg304j2zxl5i70m710gybjr232";
  };

  buildInputs = [ automake autoconf libtool pkgconfig libzen libmediainfo zlib ];
--- a/pkgs/applications/misc/pdfpc/default.nix
+++ b/pkgs/applications/misc/pdfpc/default.nix
@ -4,13 +4,13 @@
 stdenv.mkDerivation rec {
  name = "${product}-${version}";
  product = "pdfpc";
-  version = "4.0.1";
+  version = "4.0.2";

  src = fetchFromGitHub {
    repo = "pdfpc";
    owner = "pdfpc";
    rev = "v${version}";
-    sha256 = "06m30xz9jzfj6ljnsgqqg1myj13nqpc7ria9wr8aa62kp4n7bcfp";
+    sha256 = "0151i9msagcqcfaddgd1vkmman0qgqy6s3714sqas568r4r9ngdk";
  };

  nativeBuildInputs = [ cmake pkgconfig ];
--- a/pkgs/applications/misc/pstree/default.nix
+++ b/pkgs/applications/misc/pstree/default.nix
@ -4,7 +4,10 @@ stdenv.mkDerivation rec {
  name = "pstree-2.39";

  src = fetchurl {
-    url = "http://www.sfr-fresh.com/unix/misc/${name}.tar.gz";
+    urls = [
+      "http://www.sfr-fresh.com/unix/misc/${name}.tar.gz"
+      "http://distfiles.macports.org/pstree/${name}.tar.gz"
+    ];
    sha256 = "17s7v15c4gryjpi11y1xq75022nkg4ggzvjlq2dkmyg67ssc76vw";
  };

--- a/pkgs/applications/misc/sc-im/default.nix
+++ b/pkgs/applications/misc/sc-im/default.nix
@ -1,4 +1,4 @@
-{ stdenv, fetchurl, yacc, ncurses, libxml2 }:
+{ stdenv, fetchFromGitHub, yacc, ncurses, libxml2 }:

 let
  version = "0.2.1";
@ -7,9 +7,11 @@ stdenv.mkDerivation rec {

  name = "sc-im-${version}";

-  src = fetchurl {
-    url = "https://github.com/andmarti1424/sc-im/archive/v${version}.tar.gz";
-    sha256 = "08yks8grj5w434r81dy2knzbdhdnkc23r0d9v848mcl706xnjl6j";
+  src = fetchFromGitHub {
+    owner = "andmarti1424";
+    repo = "sc-im";
+    rev = "v${version}";
+    sha256 = "0v6b8xksvd12vmz198vik2ranyr5mhnp85hl9yxh9svibs7jxsbb";
  };

  buildInputs = [ yacc ncurses libxml2 ];
@ -28,12 +30,12 @@ stdenv.mkDerivation rec {
    make install prefix=
  '';

-  meta = {
+  meta = with stdenv.lib; {
    homepage = "https://github.com/andmarti1424/sc-im";
    description = "SC-IM - Spreadsheet Calculator Improvised - SC fork";
-    license = stdenv.lib.licenses.bsdOriginal;
-    maintainers = [ stdenv.lib.maintainers.matthiasbeyer ];
-    platforms = with stdenv.lib.platforms; linux; # Cannot test others
+    license = licenses.bsdOriginal;
+    maintainers = [ maintainers.matthiasbeyer ];
+    platforms = platforms.linux; # Cannot test others
  };

 }
--- a/pkgs/applications/misc/st/wayland.nix
+++ b/pkgs/applications/misc/st/wayland.nix
@ -0,0 +1,34 @@
+{ stdenv, fetchurl, pkgconfig, writeText
+, ncurses, wayland, wld, libxkbcommon, fontconfig, pixman
+, conf? null}:
+
+with stdenv.lib;
+
+stdenv.mkDerivation rec {
+  name = "st-wayland-${version}";
+  version = "git-2015-08-29";
+  rev = "61b47b76a09599c8093214e28c48938f5b424daa";
+
+  src = fetchurl {
+    url = "https://github.com/michaelforney/st/archive/${rev}.tar.gz";
+    sha256 = "7164da135f02405dba5ae3131dfd896e072df29ac6c0928f3b887beffb8a7d97";
+  };
+
+  configFile = optionalString (conf!=null) (writeText "config.def.h" conf);
+  preBuild = optionalString (conf!=null) "cp ${configFile} config.def.h";
+
+  buildInputs = [ pkgconfig ncurses wayland wld libxkbcommon fontconfig pixman ];
+
+  NIX_LDFLAGS = "-lfontconfig";
+
+  installPhase = ''
+    TERMINFO=$out/share/terminfo make install PREFIX=$out
+  '';
+
+  meta = {
+    homepage = http://st.suckless.org/;
+    license = stdenv.lib.licenses.mit;
+    maintainers = with maintainers; [ ];
+    platforms = with platforms; linux;
+  };
+}
--- a/pkgs/applications/misc/synergy/default.nix
+++ b/pkgs/applications/misc/synergy/default.nix
@ -5,13 +5,13 @@ with stdenv.lib;

 stdenv.mkDerivation rec {
  name = "synergy-${version}";
-  version = "1.7.4";
+  version = "1.7.5";

  src = fetchFromGitHub {
-    owner = "synergy";
+    owner = "symless";
    repo = "synergy";
    rev = "v${version}-stable";
-    sha256 = "0pxj0qpnsaffpaxik8vc5rjfinmx8ab3b2lssrxkfbs7isskvs33";
+    sha256 = "02zv8m7yagx80wi7m0ckglfqjqyrj6rd1gywxzqzl6841scmf87n";
  };

  postPatch = ''
--- a/pkgs/applications/networking/browsers/chromium/plugins.nix
+++ b/pkgs/applications/networking/browsers/chromium/plugins.nix
@ -80,7 +80,7 @@ let
      wvName = "Widevine Content Decryption Module";
      wvDescription = "Playback of encrypted HTML audio/video content";
      wvMimeTypes = "application/x-ppapi-widevine-cdm";
-      wvModule = "$widevine/lib/libwidevinecdmadapter.so";
+      wvModule = "@widevine@/lib/libwidevinecdmadapter.so";
      wvInfo = "#${wvName}#${wvDescription};${wvMimeTypes}";
    in ''
      flashVersion="$(
--- a/pkgs/applications/networking/browsers/firefox-bin/sources.nix
+++ b/pkgs/applications/networking/browsers/firefox-bin/sources.nix
@ -4,185 +4,185 @@
 # ruby generate_sources.rb > sources.nix

 {
-  version = "44.0";
+  version = "44.0.2";
  sources = [
-    { locale = "ach"; arch = "linux-i686"; sha256 = "c0c65ced611dcc7b788aff7f0e32cd1823467c06dc99ced2e0aca0539ce545a2"; }
-    { locale = "ach"; arch = "linux-x86_64"; sha256 = "87068d8072d0312af90524c7470c874d33e23c2b3e94be3fe9d934998330e898"; }
-    { locale = "af"; arch = "linux-i686"; sha256 = "7c8f08471fe561a345175c350c6414e72721baeb41a3ff47a429f5b79c33c82c"; }
-    { locale = "af"; arch = "linux-x86_64"; sha256 = "4768a53842d40e81a2e357ba58da56b0a81d2224878b6ab2ffad0bfc50c20ec1"; }
-    { locale = "an"; arch = "linux-i686"; sha256 = "cdb921661a6b20738f38ab2d0fb285aa81a323401f360f77b9ae6d9e8642210d"; }
-    { locale = "an"; arch = "linux-x86_64"; sha256 = "cff97655831940b84bfa5f73dfa3dc48de084ae6503e7a5824c3e57e373f0ff0"; }
-    { locale = "ar"; arch = "linux-i686"; sha256 = "9f6322577809b557f325168953170706af6d29a29b5347886f928b5f495799b8"; }
-    { locale = "ar"; arch = "linux-x86_64"; sha256 = "d5a1a956d7f9afe5867e2dbeaea4ba2a94e743d291062d18232d20ace29d2c94"; }
-    { locale = "as"; arch = "linux-i686"; sha256 = "750c5cddd2d436993a4630f0ebf31e9d0ac679cc23a84298071a682e7a8a8de1"; }
-    { locale = "as"; arch = "linux-x86_64"; sha256 = "5b5a2376daef30eae3ff1a94213937381148ade79783546b1f38687c9fc4489e"; }
-    { locale = "ast"; arch = "linux-i686"; sha256 = "99b5bc2c709a923a43debfe746c70c3613c206424c88d553f7593c200053a8b6"; }
-    { locale = "ast"; arch = "linux-x86_64"; sha256 = "2fd75ff22d3b75f03c6a9ab005e369373f999ef4c38ea49438ab2adaa8e9a2c2"; }
-    { locale = "az"; arch = "linux-i686"; sha256 = "0781239c9c8f237d66ce0c8d9f39136e0eb71365f6ca8b695014648060c18c38"; }
-    { locale = "az"; arch = "linux-x86_64"; sha256 = "9fd6f6047ec3c4103c4aa761882053d4e00e018a1509fa1fbede1757394aa3fe"; }
-    { locale = "be"; arch = "linux-i686"; sha256 = "098e932b708ebc71a2aa7fe86ced4835dbc6725f8714904b25e7ebd1ca7b7d69"; }
-    { locale = "be"; arch = "linux-x86_64"; sha256 = "d9284a84e7e55ad6d73e7d599c5b6824774d7a9e6f7484064fd2985e5634d102"; }
-    { locale = "bg"; arch = "linux-i686"; sha256 = "02879ea328d1536781f2f9765db51bcb9fa05d0a0b7ad426fd659156c293f347"; }
-    { locale = "bg"; arch = "linux-x86_64"; sha256 = "70f55197d8ff67d52f090bd58dcc106fcc08492fe6989494eee3aa3cd1c3552a"; }
-    { locale = "bn-BD"; arch = "linux-i686"; sha256 = "227873ac53fdac5f27b569a5b6a1f3d45caa4e3c822610a5f294a3abdbc2c0fd"; }
-    { locale = "bn-BD"; arch = "linux-x86_64"; sha256 = "0a46de9bfc19fba878104ae2865a092fba7a9eea62a64a31c0decc9fc021b3af"; }
-    { locale = "bn-IN"; arch = "linux-i686"; sha256 = "2cc4d364852fc987e97f169de9039992d4ecb848125eae38c09bced34aae8653"; }
-    { locale = "bn-IN"; arch = "linux-x86_64"; sha256 = "6a722ed42f251e3433d46d9b56ca06f7bc1cf0854de782da10285db6ee4a1bfd"; }
-    { locale = "br"; arch = "linux-i686"; sha256 = "14b75dc8278a946d705210306b50a85795f70d83d0527d2c77a60b13662e89e3"; }
-    { locale = "br"; arch = "linux-x86_64"; sha256 = "73e62d2869fb450b4597ec3d65ae3c36ef78984462a158dbf565bbac539b1fa5"; }
-    { locale = "bs"; arch = "linux-i686"; sha256 = "01e02d4a0e140d962e27e4f1a4ec24837c0646e9373f3ce2eb8337437c274ecf"; }
-    { locale = "bs"; arch = "linux-x86_64"; sha256 = "59fef5429b639a52ee113e855a18080870a2f905212dd0e4aefdd838d040133d"; }
-    { locale = "ca"; arch = "linux-i686"; sha256 = "62f96267e91fb9a8df1c436adb78945f32eb14bccc57e706104ae0547b723682"; }
-    { locale = "ca"; arch = "linux-x86_64"; sha256 = "0be231034e076e162b5568a5247da47ca2038011928f89c729fe9a7e139dd922"; }
-    { locale = "cs"; arch = "linux-i686"; sha256 = "15c8a066fe101a5b9151c96611e2390008ac54a9a1909b9430ed6f440c856920"; }
-    { locale = "cs"; arch = "linux-x86_64"; sha256 = "40400da9851782418a12b224b74c3b5c8c112912bb98dc8f368972cc898ea155"; }
-    { locale = "cy"; arch = "linux-i686"; sha256 = "b9b8d3d4c5160eb1676f6c4531123ec28dc0ca6b51e7dcf20716611f93f1c975"; }
-    { locale = "cy"; arch = "linux-x86_64"; sha256 = "6e00d5e5c7e50aa24468b802bd53377d8962b146fed8a8588dd5c8db4162da93"; }
-    { locale = "da"; arch = "linux-i686"; sha256 = "760c9d95fe6941847dfd53b254cd662a83f4c9f2d66f84a96b4dd1d3127adbb8"; }
-    { locale = "da"; arch = "linux-x86_64"; sha256 = "e168e7e7e11aabe54f773c960d4c9b9920e15e4ccadef9f728e2016f0240555f"; }
-    { locale = "de"; arch = "linux-i686"; sha256 = "e5c6372f3fd732fddfaa31ed3ddc81cf803386d7842e103fddd0685739ea63c7"; }
-    { locale = "de"; arch = "linux-x86_64"; sha256 = "73da0a0c66c18dddf5de7b7dda677cb9cef1e0b3c8cff5e22f48bf743ece8116"; }
-    { locale = "dsb"; arch = "linux-i686"; sha256 = "509b8233c403b629803fb0d67a29f2d6f649627d4b91c592121acd3e2ff62282"; }
-    { locale = "dsb"; arch = "linux-x86_64"; sha256 = "6089971aa6e19e2cbcb49724e2eea7922d9408936aa8e2d396b8f1966ea81eec"; }
-    { locale = "el"; arch = "linux-i686"; sha256 = "451f1a7caea7553fc18e440c2716e1954e7d7ba66f5fbe15cc6954224a36444e"; }
-    { locale = "el"; arch = "linux-x86_64"; sha256 = "d02f4b813cc16b4293f9441bdbdef56acd0a7a510d9edcce223d04270e65f2e4"; }
-    { locale = "en-GB"; arch = "linux-i686"; sha256 = "663b7a6300fa46c4e62e7542135ab2632117496a5b0365276ec5ac94183a1d55"; }
-    { locale = "en-GB"; arch = "linux-x86_64"; sha256 = "d50895a71408e74d8b5b1965be279011214c50eba56e0046f360f216326f1135"; }
-    { locale = "en-US"; arch = "linux-i686"; sha256 = "84a5fa00271f90356bbfedb1fdbcc033489d1759fef53c4dda92bd285633ae3d"; }
-    { locale = "en-US"; arch = "linux-x86_64"; sha256 = "49e55275df9e902bc234fa59b4b614a084d76dc2c256ce6218fa96663cabe2dd"; }
-    { locale = "en-ZA"; arch = "linux-i686"; sha256 = "dfe926680b0bc5852db920ba8b3e4febecf1ead33d9865568ac69e9494337072"; }
-    { locale = "en-ZA"; arch = "linux-x86_64"; sha256 = "83c8480482dd154519d26e43a3f79d32c82f149d81a1c6e8ef98e9511ecbf35a"; }
-    { locale = "eo"; arch = "linux-i686"; sha256 = "a27703068ff3be53e8944c750bde0316414f51ee4c10569018d121db7ec1b705"; }
-    { locale = "eo"; arch = "linux-x86_64"; sha256 = "981462cf59716c17fc0630d0cf12b03e7cc96d72c2d8d33109c1db633895f18a"; }
-    { locale = "es-AR"; arch = "linux-i686"; sha256 = "16b2efda57842f29c6f4432cd51296d5e9a709d30f2310e885c786fc68a96e65"; }
-    { locale = "es-AR"; arch = "linux-x86_64"; sha256 = "7b6c8a2bbae8e72ec820df741b8f4a2e162c4b628db8e669a5e85dc190db6c51"; }
-    { locale = "es-CL"; arch = "linux-i686"; sha256 = "ad18bc224500c834a159d91fa568461cbf131edd1b044ae8c97e887b2151e112"; }
-    { locale = "es-CL"; arch = "linux-x86_64"; sha256 = "84c414c64bff02d8e82a4ca4c01e1b4dfae21991ee9a6850203ccbe15469cfe8"; }
-    { locale = "es-ES"; arch = "linux-i686"; sha256 = "142db7f0bb92976345aace30d9ba53ab4ba98a47332c3f7ae7372d9d80300781"; }
-    { locale = "es-ES"; arch = "linux-x86_64"; sha256 = "337de34606e018ec5b600d559d928e35c79fb28800c9b5ad28e2defe259f9b58"; }
-    { locale = "es-MX"; arch = "linux-i686"; sha256 = "51cecc939011135842bb51c41cfda0fb4ae53c5180e49bd66a810c243b1d68be"; }
-    { locale = "es-MX"; arch = "linux-x86_64"; sha256 = "cfe309df7412f68abf487c1f9065e6b9d4b4f384254576c8d1098878012e5b53"; }
-    { locale = "et"; arch = "linux-i686"; sha256 = "1540b0f0c1d867c87d1e109b4e9ad417be51306c324a03e07706d7e215f7ae4f"; }
-    { locale = "et"; arch = "linux-x86_64"; sha256 = "e7c0e4e61d17164a648ae51bcff92d99f76055a1a6a29dfec6ea12a0359f1285"; }
-    { locale = "eu"; arch = "linux-i686"; sha256 = "c2c88bf65329b168fde8fe02613eb89069d85da8b2a3114ac647158b8a345055"; }
-    { locale = "eu"; arch = "linux-x86_64"; sha256 = "9d10a2f8a0e889a6ebe99bc486cf56cc44535b6f67ce3667ac61e87430a24eea"; }
-    { locale = "fa"; arch = "linux-i686"; sha256 = "21ba5e79f5fbe3c3a8a8a71f8fe9a4280f8e47d4c58070443bbf53305c906175"; }
-    { locale = "fa"; arch = "linux-x86_64"; sha256 = "99d8d2e81e2a8f495d5568d7a9cbbfbcdc8a0e1d67fa297adf8a021988948a80"; }
-    { locale = "ff"; arch = "linux-i686"; sha256 = "3e1812cd98e04fcf575783eafdef2c89739c51e6648f4cd7ba7bed44fbe5f960"; }
-    { locale = "ff"; arch = "linux-x86_64"; sha256 = "cbe37600da8bfdabe683473dbb4f2ccc96beda89a9ca15810432a8fce65a591f"; }
-    { locale = "fi"; arch = "linux-i686"; sha256 = "ecf982266072b4a15a06b939d4f0cc22c3653982404974baa51871af0e411ab5"; }
-    { locale = "fi"; arch = "linux-x86_64"; sha256 = "345b7f038e454e6efd513e923ad2aa0a45d76d846539563bbfc79293ec84a6ec"; }
-    { locale = "fr"; arch = "linux-i686"; sha256 = "e71b05083a122ef20b5d75481129fa2e3d1e2ac608cea2c5baf7b300a5fbe5df"; }
-    { locale = "fr"; arch = "linux-x86_64"; sha256 = "1897112ce462b341abba4c2b1664fbf39b5072a11ea6fb61c66cbfb3336358f0"; }
-    { locale = "fy-NL"; arch = "linux-i686"; sha256 = "5557347f19ab6d7c90a34bf8a9729d39eb65a02a021040091cc1863e08fb72c9"; }
-    { locale = "fy-NL"; arch = "linux-x86_64"; sha256 = "c77b86d5512f8343674248b9b4d31165975f0eeea002313311339ae45d9effe3"; }
-    { locale = "ga-IE"; arch = "linux-i686"; sha256 = "7a68d7de10abf095fd9240807a6a553b60ba75f3d8edc56afcf5ad1832a05eaf"; }
-    { locale = "ga-IE"; arch = "linux-x86_64"; sha256 = "f935b317c5aadd60553f497ceae2cc663dec3729b2fc8e48e6a98d1eb91fe263"; }
-    { locale = "gd"; arch = "linux-i686"; sha256 = "21bbca4e12b3fa230b879f190d279ba9314090454e0263b65e77dbf8f99dcbf3"; }
-    { locale = "gd"; arch = "linux-x86_64"; sha256 = "027630690ecff7ad56f6e992ef243d2a734dac1a3e6365bb22c56a571f938fcb"; }
-    { locale = "gl"; arch = "linux-i686"; sha256 = "6973787b5136491ef28bb2e10976d49c3717a866ec6fe357a995dbf3179a751c"; }
-    { locale = "gl"; arch = "linux-x86_64"; sha256 = "0ca57d72bf11ddf74eb79904be607c479c01f31f11fc0ff567a9ad7beef8067d"; }
-    { locale = "gu-IN"; arch = "linux-i686"; sha256 = "6f422fdcf2fd514e132b33fa079631a6bd4b12deab17a3463b1f3f1ce3f2f535"; }
-    { locale = "gu-IN"; arch = "linux-x86_64"; sha256 = "19cc20d1bd838ebfb8518b8076800cc3255376e4928cf2f37be86258307f1104"; }
-    { locale = "he"; arch = "linux-i686"; sha256 = "f8eb56fea0e73c247fc767541bc97cc3556e4db75ad446e01b0978a5c0b11d3f"; }
-    { locale = "he"; arch = "linux-x86_64"; sha256 = "8ee0ae75d179bfec9e081777e9a34fdae72d8d55ade73983fdac433649b596ac"; }
-    { locale = "hi-IN"; arch = "linux-i686"; sha256 = "bb64fc5285bca12542669ef83bfc465bf593154f9bca2548510f525bde5a55f3"; }
-    { locale = "hi-IN"; arch = "linux-x86_64"; sha256 = "52bb0b68a5f282e65d077166a3a0716fe6c9368ab88f6d5e2a8669515bcc000a"; }
-    { locale = "hr"; arch = "linux-i686"; sha256 = "f36e7b656e5898191801d6e04f3ebef9f9f7080c011dd695ddccfe12c3cb2f6b"; }
-    { locale = "hr"; arch = "linux-x86_64"; sha256 = "9c553d5312363980364c6a9a6591fe5e0229668ff1de3a78943af18235098eee"; }
-    { locale = "hsb"; arch = "linux-i686"; sha256 = "e58662111147e836ac404cf7fc9d9e52ac141b204004c813c6b8d180a378af57"; }
-    { locale = "hsb"; arch = "linux-x86_64"; sha256 = "5aa7dcce6e48dfcb7b8b4f9f48b4bdd496bd606d901896fd37f2a2cd6b4a06bf"; }
-    { locale = "hu"; arch = "linux-i686"; sha256 = "d352b7d67ebbd5e45f972a804cccbb769f6a79700506297c0808d2f9b0f5ca8d"; }
-    { locale = "hu"; arch = "linux-x86_64"; sha256 = "0f7e5cf8306e1fa9b8ab56cdb39b5ca1fe2ff1a3f4ded38e5982bbd842438dde"; }
-    { locale = "hy-AM"; arch = "linux-i686"; sha256 = "bf057113e03190fbfc6947f24a0fb432f53991f02e56d2b5e8270002cd742d4d"; }
-    { locale = "hy-AM"; arch = "linux-x86_64"; sha256 = "aa0fdba0a703f06ab5a6b667448316f9de9729c20602fecaf872d14e43a0b822"; }
-    { locale = "id"; arch = "linux-i686"; sha256 = "eb8fc36302a63113e9891f8153aeffc1da4f990f1473d9d779f28df6658bada0"; }
-    { locale = "id"; arch = "linux-x86_64"; sha256 = "6f2262e13a649499a0783922a3f2d85a71727ef37629a529f084590828746bca"; }
-    { locale = "is"; arch = "linux-i686"; sha256 = "312f1af8601c24417672383063085f1c588d9301a09ddeef15b8c54e130547ff"; }
-    { locale = "is"; arch = "linux-x86_64"; sha256 = "ed3165767c2a14329869930d2b618a5a795d3c3d34e06cbae0d1694ccdfb0c97"; }
-    { locale = "it"; arch = "linux-i686"; sha256 = "7555b6f4aac9bcc270fcd5204d15a3cb7b84cdd845f66cea2fbb843315100107"; }
-    { locale = "it"; arch = "linux-x86_64"; sha256 = "b6c2799434bceda271a004769372dfe416584953be5950fe7125920e4e428737"; }
-    { locale = "ja"; arch = "linux-i686"; sha256 = "e8606fc60aaf6ba91a2616dc991d268e8099eb8d5d3eb3c19fdeace93c6453a7"; }
-    { locale = "ja"; arch = "linux-x86_64"; sha256 = "5da4d4c307d661868ff7076e2fc1d929e9d3b9816be25adeba02bd4f9a56f15b"; }
-    { locale = "kk"; arch = "linux-i686"; sha256 = "f77db4c679c687bd33ed125419666226989ef5da88c2a4c8a81aea0ece602e25"; }
-    { locale = "kk"; arch = "linux-x86_64"; sha256 = "3af207c5e2b6bf089739056f2be6e585529c87d5f142e7100fee55728faaf785"; }
-    { locale = "km"; arch = "linux-i686"; sha256 = "d48c3f0952d354b9c6539d9e333a8e9c359006a25f1ca6a0895f7e3344504f70"; }
-    { locale = "km"; arch = "linux-x86_64"; sha256 = "5bc3f65a205a78b110293df5a94a9bde27a491d61b1f9e340a7fe983c1ee1b3f"; }
-    { locale = "kn"; arch = "linux-i686"; sha256 = "50efbbad9ea231a9281a00dc702d9c6103bfd09b712b45b6809d78a176714897"; }
-    { locale = "kn"; arch = "linux-x86_64"; sha256 = "001f41e86fcf93fd6a714e5ee0450fe8424bbb3ff40cebad29cb233cb0667bca"; }
-    { locale = "ko"; arch = "linux-i686"; sha256 = "11539b78bc650b19be2d25af10242a61ee043b47a15000f2e07e50df00875e2e"; }
-    { locale = "ko"; arch = "linux-x86_64"; sha256 = "a4f0b466c5d544f0abecec8861e1d24132755fff54091a49370414ba27c9cc7f"; }
-    { locale = "lij"; arch = "linux-i686"; sha256 = "eede4d95ac6c7f55b312aaadce690016732bb143f3926c1d1533f64efd7306e8"; }
-    { locale = "lij"; arch = "linux-x86_64"; sha256 = "6900bfd4af3146881cc045eed187b88a58ea0fe3e0ed6acbff034f68f43b5935"; }
-    { locale = "lt"; arch = "linux-i686"; sha256 = "4cdf1ced9a687daa34235ae82aa439d69e517d5c31b8f61e12615f361440a54a"; }
-    { locale = "lt"; arch = "linux-x86_64"; sha256 = "873f75d77adc9c142f64523c199799f7e9b0460ae0252c514fc1caa5ac5dcdb0"; }
-    { locale = "lv"; arch = "linux-i686"; sha256 = "65af6b876aeda23827c57d5886cc67665fe2c3fe93cfc2cc5b614400828b6eb7"; }
-    { locale = "lv"; arch = "linux-x86_64"; sha256 = "1b2f6ef94bb5a1ea999af797e2aa8ff267b4a9945fd0e8afc6c9df12273ce60d"; }
-    { locale = "mai"; arch = "linux-i686"; sha256 = "65fec172ddfce096f367338c8b95b32fb2415655e900f8dc628b8ac660270e48"; }
-    { locale = "mai"; arch = "linux-x86_64"; sha256 = "238a78c2bb240609fd0c777399d3307ef659b95cf4e88ae85700321030000eb7"; }
-    { locale = "mk"; arch = "linux-i686"; sha256 = "e591486c66c9b7175b1ab180e9646976a413338dca225eb50d7db457f95afe98"; }
-    { locale = "mk"; arch = "linux-x86_64"; sha256 = "f8d04696d02b0af221b8642d4780d79a76be68c07096c7f9c5915a9db6d5f768"; }
-    { locale = "ml"; arch = "linux-i686"; sha256 = "19dd334052bd9c98ec9afe7b8e5141728b25d2278b7b946921b031aaedd01b2d"; }
-    { locale = "ml"; arch = "linux-x86_64"; sha256 = "a307739cb6de6f80258c28797125f78fe7746d0edd3182e3716f312f1b0915f8"; }
-    { locale = "mr"; arch = "linux-i686"; sha256 = "c86343db611dbca1b8fac25ea1e9364b30fcd6c31d5c856f699bacf6e4128c3c"; }
-    { locale = "mr"; arch = "linux-x86_64"; sha256 = "b25fd422e6b3b1535fbb8839d04a77dec22dfcc0abf14062f5465c0a5aa5c99c"; }
-    { locale = "ms"; arch = "linux-i686"; sha256 = "e437939df4de54d415224db8fbf6ce9e8ae21fc0402052a72612085c73faa493"; }
-    { locale = "ms"; arch = "linux-x86_64"; sha256 = "5d9051de7a1bdc68018511d38e29658f00c0db113438a3ec84e68fa99b89f760"; }
-    { locale = "nb-NO"; arch = "linux-i686"; sha256 = "04d0bdd6235a9321d1a5467c48240cbdb790485b580c1b818b048817fae22f49"; }
-    { locale = "nb-NO"; arch = "linux-x86_64"; sha256 = "30afe02bd7090929841edc88eadcd745435f64189782d95477568b3b41cb107c"; }
-    { locale = "nl"; arch = "linux-i686"; sha256 = "83b01feb621cb9c7c64edb125c19aa0765bc2d16b2c20551be12690f835539da"; }
-    { locale = "nl"; arch = "linux-x86_64"; sha256 = "c5af070524b828313a5e819f4c446cdc7a72f6bffd62e734bb8752438e5d28ef"; }
-    { locale = "nn-NO"; arch = "linux-i686"; sha256 = "527c9c2dd61a318c5b6ca5e9b26ee9b81b71ae8d7c23cdab6efee1bb5caaa685"; }
-    { locale = "nn-NO"; arch = "linux-x86_64"; sha256 = "6f3d800c347a70c5ed7a8838365599c7401e4805037f5e980865794d395b416a"; }
-    { locale = "or"; arch = "linux-i686"; sha256 = "e5f9ba3ebe3d641b3dd948ec51dd25671327a35e5ee87b274079a8a3ce7a26b1"; }
-    { locale = "or"; arch = "linux-x86_64"; sha256 = "53fea5b84051fea6c247fe2baf9f9d3c87b3f78d4655fc8509068fd60ff3c942"; }
-    { locale = "pa-IN"; arch = "linux-i686"; sha256 = "dc8d60a3f94da475fea5c1c748c52072f69d4642ea2c3b305e92c56fb3b09324"; }
-    { locale = "pa-IN"; arch = "linux-x86_64"; sha256 = "c06eb60b39cef2564e248e3d9dd711b863e46cc6d45803002c641a1335927bdc"; }
-    { locale = "pl"; arch = "linux-i686"; sha256 = "95cbcf68c03ed83590b6e257003282d710c8dd366fd75bd218880735731ed7d2"; }
-    { locale = "pl"; arch = "linux-x86_64"; sha256 = "9f59a86501cbb9d8813fbf5812646e87d400f136f2cca5d791dd5ac0bc4964c9"; }
-    { locale = "pt-BR"; arch = "linux-i686"; sha256 = "690772121588229f34e9a9d5e6042c56a3fdb9fdcafea53f45a12997cd1d1e53"; }
-    { locale = "pt-BR"; arch = "linux-x86_64"; sha256 = "fce60e0a3787a2362bdab4d566766c22a4b4f777d1dde7552e195eefc8fe98b1"; }
-    { locale = "pt-PT"; arch = "linux-i686"; sha256 = "35a4981bc819fa7cba9e2f73ebb28eafd68b464eacc9da4e3e651882ae8b84bd"; }
-    { locale = "pt-PT"; arch = "linux-x86_64"; sha256 = "eb4f25e99cc681a6113f9de016a6993e46575caba84f5cba6195c88379e4e661"; }
-    { locale = "rm"; arch = "linux-i686"; sha256 = "cef140f0b0c4da31235147871679d009f05aeec3e1b138e56bd6acabf79cb666"; }
-    { locale = "rm"; arch = "linux-x86_64"; sha256 = "e6aba016e9909cc43a9ab285ed8cbfc15dadf2cf7bba9c78ba340512dd9bbcc5"; }
-    { locale = "ro"; arch = "linux-i686"; sha256 = "d159bd682f8db01fea12e25bc0d4c24ef2ffffca07b3c5d64223ae75d6f77d23"; }
-    { locale = "ro"; arch = "linux-x86_64"; sha256 = "e82f1ad5461e25c25a8c6db480a733e95b81578ec280e93a52b00b650211a0ac"; }
-    { locale = "ru"; arch = "linux-i686"; sha256 = "fc2e1166c4d9614bcf9c8ccd01aa157bc229cccbdcd2854bbc52302465d24d75"; }
-    { locale = "ru"; arch = "linux-x86_64"; sha256 = "c08fcc4457bad70ff5861168364306753df7f03d7817a52dda8c6aad74bde389"; }
-    { locale = "si"; arch = "linux-i686"; sha256 = "78f60d4ba047d323ec2a36e2f8a775d86bb2c00bb671009105f5fe368419366f"; }
-    { locale = "si"; arch = "linux-x86_64"; sha256 = "d9c84c673378721c0bc45e767176b879858ba0feacdeeca503e600567569ad33"; }
-    { locale = "sk"; arch = "linux-i686"; sha256 = "1bbddd4c07cffc083997d3b43034438eccf8647bd9b078cbca86f63c50c588ae"; }
-    { locale = "sk"; arch = "linux-x86_64"; sha256 = "f8278a40b25bd24a951855b633218c8d0884fec7468291d947890f2e98310acb"; }
-    { locale = "sl"; arch = "linux-i686"; sha256 = "18e9f99de5847e996ab66202e8718d9844f26ffef771a236ae16ee68098853fa"; }
-    { locale = "sl"; arch = "linux-x86_64"; sha256 = "bbc818432701696fd140e914943d076e4d11741180a04ea27f4be75ec3558d1c"; }
-    { locale = "son"; arch = "linux-i686"; sha256 = "e1d8c54d8b1149f98adb1b46c4973e01fa76bb132f0df9b0f090c4ead0ec4676"; }
-    { locale = "son"; arch = "linux-x86_64"; sha256 = "a57f3971825a40c8dfce2d987384292f1ad3ebe6a96ff762bc38e69c6ce2889f"; }
-    { locale = "sq"; arch = "linux-i686"; sha256 = "b452ab04c4bae6079bbdc293bc6c41882dac30ec1b1483340e49d072ecf2ced4"; }
-    { locale = "sq"; arch = "linux-x86_64"; sha256 = "b8aaff5e70e7690481a5c22fb2da97ce63de67246217fb106441173573aeb4d9"; }
-    { locale = "sr"; arch = "linux-i686"; sha256 = "135f60c2012e63622d1a75cab6fd5f686fee71138b1f1f01e367fac0b3b583c8"; }
-    { locale = "sr"; arch = "linux-x86_64"; sha256 = "ce464a8ec58fe19e037a26a1b94e346ad314eacbe94232f4b136e0fc7b3919ac"; }
-    { locale = "sv-SE"; arch = "linux-i686"; sha256 = "937bb415ca95996207c371d111a888f68a24d690db8c31b8c1df530b2b7b30a7"; }
-    { locale = "sv-SE"; arch = "linux-x86_64"; sha256 = "0ee83de9b3bb77a6e3d1120194700b720d441ee116f9728823c5a78f59d28a10"; }
-    { locale = "ta"; arch = "linux-i686"; sha256 = "fb908dcbc4fa42c6472e4cb5bd9d8ae7c845bbf9965498091b32f7d1669ede24"; }
-    { locale = "ta"; arch = "linux-x86_64"; sha256 = "5c8f1c1c09ff2eccf6becf9136f9da3517fabbb0192f157676962fd3bfd31bb8"; }
-    { locale = "te"; arch = "linux-i686"; sha256 = "5478af8e757d8282993afacd10fc78bc7a207fbdc50705d2d8a665aa98e5f910"; }
-    { locale = "te"; arch = "linux-x86_64"; sha256 = "719945b8d7a945e556137cc3bdc4a8d7ddf5693e4ac49a3884f912ec471da1f5"; }
-    { locale = "th"; arch = "linux-i686"; sha256 = "4f0dfccef932beec90f7de951bb2d454bedc192b376caf25c3ba89ecdb5de9df"; }
-    { locale = "th"; arch = "linux-x86_64"; sha256 = "e14a4cdff4cc89f85043efbf56a82211f1040bc5b369c2113866efb639969017"; }
-    { locale = "tr"; arch = "linux-i686"; sha256 = "aa5bc43997a6669b1c8da7b04a12c7a16ce8b1fedae8b0bb1a317c83176e88c5"; }
-    { locale = "tr"; arch = "linux-x86_64"; sha256 = "3a0a5883b4e4442985fa8e24a80d0849ac450a20d278858e1b3847974cc212f2"; }
-    { locale = "uk"; arch = "linux-i686"; sha256 = "3ea926ea98fd3506cdcccc32266fd8910f7c6b563818d58fa9708872712daad9"; }
-    { locale = "uk"; arch = "linux-x86_64"; sha256 = "c1d596a00831ed30446f8a6f9e7b455329a402939d5c7318616ad182e9564aa5"; }
-    { locale = "uz"; arch = "linux-i686"; sha256 = "d17a26657562ee017388c878867ff43a1d1d86f80c86a18fcf63268b477bd889"; }
-    { locale = "uz"; arch = "linux-x86_64"; sha256 = "7115c30ae7c0528f54aa8629402ddcfc54687e3a439d7a96c18f15e903e283c8"; }
-    { locale = "vi"; arch = "linux-i686"; sha256 = "37fe2af25d7068569770573e605f3d325e41169b3b0a82ca4ff007a0636b155b"; }
-    { locale = "vi"; arch = "linux-x86_64"; sha256 = "5bb2b8a27065b9a71a06dbec136a1774e43fbe27a30a03092f718042d58ec26c"; }
-    { locale = "xh"; arch = "linux-i686"; sha256 = "fa44efebbc0f1174ad10f540668447ddf6bd26a2c918694dd11e63e4d6f36b9c"; }
-    { locale = "xh"; arch = "linux-x86_64"; sha256 = "2c179d4613b0b7456d900f9b6c02a1041c39d4cf98a0ca0ea2ea97d1d7546199"; }
-    { locale = "zh-CN"; arch = "linux-i686"; sha256 = "e3c06fbffb4b2c135d31499d1a3490d23baedbed5125b46a4153ad9d60ea2fa8"; }
-    { locale = "zh-CN"; arch = "linux-x86_64"; sha256 = "3402f491b016e791c9f40f8ac5df5f7017dd6dd71d872020a27eae3634e4fb52"; }
-    { locale = "zh-TW"; arch = "linux-i686"; sha256 = "c77d79a6b1602c9f8c6538be18c974b8557af3ad3898910e1bccfe0a54993207"; }
-    { locale = "zh-TW"; arch = "linux-x86_64"; sha256 = "651e4a28750ea9376636293b934cf646b0e6981825a9801fe8bf47785114e34d"; }
+    { locale = "ach"; arch = "linux-i686"; sha256 = "2d0ab9fba584576d67ccb600339efeb5ad7aac1629b2d7865e121825b1a5a6d5"; }
+    { locale = "ach"; arch = "linux-x86_64"; sha256 = "188b9aab64ab1beda84dbe7b36d899210472a3e445dd827b64ca7083ae3c0b32"; }
+    { locale = "af"; arch = "linux-i686"; sha256 = "e6b5fb28e5ad03240f0e156c81db1df16bfaf99a946ffab9672c06d8561de9c3"; }
+    { locale = "af"; arch = "linux-x86_64"; sha256 = "c2856308c9e87bf82f621c5d4c96e9c5a70e5ebb86a8e4ba8ecb4d08c1ae98ec"; }
+    { locale = "an"; arch = "linux-i686"; sha256 = "f138b17a230e9b42b334d3900bebf23156fe1dec1f4ec75f9a3b94348523e241"; }
+    { locale = "an"; arch = "linux-x86_64"; sha256 = "82d24b07dc8d887837e8fbd610c2feb1ff4975917d8a19836ec0d0db56522de8"; }
+    { locale = "ar"; arch = "linux-i686"; sha256 = "b530e58161331bff3222083298ddc5af0055c6b3337b58b1a4eb1d5d4e348d62"; }
+    { locale = "ar"; arch = "linux-x86_64"; sha256 = "67c0e4ce7dfe54d0e4fedb168342ea86a82458e2d3ce6aca78b4497f4e813bfd"; }
+    { locale = "as"; arch = "linux-i686"; sha256 = "f17e991e97e85b981c3191a0becad6df457a29b7042d31a667fd227dadc24e80"; }
+    { locale = "as"; arch = "linux-x86_64"; sha256 = "2d955443b785a65d2f9f914232d521aeb9082b4dead8fedc89cfa29329ab8e2a"; }
+    { locale = "ast"; arch = "linux-i686"; sha256 = "c9e2784047b58eddfd72c1e56964eea8ac098240436d029665bc940c7b8d8f8d"; }
+    { locale = "ast"; arch = "linux-x86_64"; sha256 = "4bd5cc7c34f0a1fc1e2e899942c4ebec6bdab2fbd9e3d331ecc0c67a6f8c16e4"; }
+    { locale = "az"; arch = "linux-i686"; sha256 = "1789f6c5524314df239e4b4beb677adf48ce926a097128e053b352067d13016f"; }
+    { locale = "az"; arch = "linux-x86_64"; sha256 = "4881ccb7521512b4275faa2598efda6bbcc3d7838b6200e79c8fcae358d32c23"; }
+    { locale = "be"; arch = "linux-i686"; sha256 = "e9e31e92e0732188f6c4494023de260e5b64e97c56ff07857b290355c50e25f4"; }
+    { locale = "be"; arch = "linux-x86_64"; sha256 = "00ef0cea013cdb8606d8786bb5a21e502a6054ab57b2fad4d24161c47768f418"; }
+    { locale = "bg"; arch = "linux-i686"; sha256 = "6428fa1d4f2bd0b703f207a1571e425f8076438954f955f60c0e8c1525743823"; }
+    { locale = "bg"; arch = "linux-x86_64"; sha256 = "fc156d3d76582c95eb6a0a7ee88dbdbd6c99d46ca42b011e1d789b0552bb5885"; }
+    { locale = "bn-BD"; arch = "linux-i686"; sha256 = "d0b69158e5ce85eec29dc70c4942bfc76eaf2d8e3359c45de5783d39fe1ccaf0"; }
+    { locale = "bn-BD"; arch = "linux-x86_64"; sha256 = "928575b759e4ae89d3e5ee475ffa18c69e945846981102d540de01c9bd87582e"; }
+    { locale = "bn-IN"; arch = "linux-i686"; sha256 = "a92a902e4380ddda37b8e70922e91ee029d47f866adea53220dd76182c52b596"; }
+    { locale = "bn-IN"; arch = "linux-x86_64"; sha256 = "022b9ff7141cd89df35477d357df74556bc4a24639141d21111eccfbf8e2f98c"; }
+    { locale = "br"; arch = "linux-i686"; sha256 = "c398c00b98edcaa2618363637075ccf749a4d3567dfdae070b4b0cbe23832f56"; }
+    { locale = "br"; arch = "linux-x86_64"; sha256 = "60f471fdf1b71072751396049f12a198c73d11892ec69fc142f925a12c6515f4"; }
+    { locale = "bs"; arch = "linux-i686"; sha256 = "d9e3c1b5c94ad207071cea86295ef3f98d4bd9201e896f6b9d67a2e475ea2898"; }
+    { locale = "bs"; arch = "linux-x86_64"; sha256 = "2ea3bb1c14a849b5039b633963687629839174ea886d3f8314f67eddafa2b16b"; }
+    { locale = "ca"; arch = "linux-i686"; sha256 = "bf1c1c3aaa900d66c4684cf48623bb0c9e0313cd919ad0e67e8a2e3ca5987aa6"; }
+    { locale = "ca"; arch = "linux-x86_64"; sha256 = "30c0217722c599ed8fc0e713e0b763a01dc0da37dc2f290a2a4d02cb2a86b6a3"; }
+    { locale = "cs"; arch = "linux-i686"; sha256 = "5ebd809827cdc85da0e6c973855c60426ab98e2cb898c030acd403577d3bb78a"; }
+    { locale = "cs"; arch = "linux-x86_64"; sha256 = "a1d55b7c54fd7eb89bcf5dbdadcaea0f5d2da7110a090c424c52a55ae23150f2"; }
+    { locale = "cy"; arch = "linux-i686"; sha256 = "55df045619bbe01af6f33c6cd563d6097b9c9023ab9133fa7def0800cc9aec83"; }
+    { locale = "cy"; arch = "linux-x86_64"; sha256 = "2ddb8bcd515aad4ddb029cf4e5c49e771aa1da14394924c4ec532c5125b7ca7b"; }
+    { locale = "da"; arch = "linux-i686"; sha256 = "b322bef3e95b24337f294b2786fc5a819d954adb43f98dee69674d41fd234b5c"; }
+    { locale = "da"; arch = "linux-x86_64"; sha256 = "3e5164351808ef2f8f4e9cea6bb1121c4d3394de56536d17869a56df3b783d3b"; }
+    { locale = "de"; arch = "linux-i686"; sha256 = "a404bf7c19dbc65adea8872b8bd080a17417bc0f1ffa3015513d86750b2903a9"; }
+    { locale = "de"; arch = "linux-x86_64"; sha256 = "3590e100bf84f2734d1b3c81508d8fa137fd100bdd1e764ae5da1f88602d5b9d"; }
+    { locale = "dsb"; arch = "linux-i686"; sha256 = "c4be1a5cc431f3aeb26694bfd0749da0dfc85c119f75b551e69083a384042833"; }
+    { locale = "dsb"; arch = "linux-x86_64"; sha256 = "36f451bb07af47aff7c930a2810ef628e3382f92560efbe396133735275f7075"; }
+    { locale = "el"; arch = "linux-i686"; sha256 = "736ee0dffe7c5dc0d5abc7755a83e29da718901252034ee503775fc3f11e31c1"; }
+    { locale = "el"; arch = "linux-x86_64"; sha256 = "1638e1fd69d1887bbfd2de95ffe7945f52934055f8e15eb919d9ccac930959e0"; }
+    { locale = "en-GB"; arch = "linux-i686"; sha256 = "1f9c8404fd01c1cac530c0e2b1fb488a2b4f7a02d8c2f0e568e0db050dc66f18"; }
+    { locale = "en-GB"; arch = "linux-x86_64"; sha256 = "4f7491b919ca7a0563cd3444bd4a1abf48a4448ccdd743c5b5eb58584e5b1e94"; }
+    { locale = "en-US"; arch = "linux-i686"; sha256 = "abe3e5d23cf557ee81e7064d6d1b2d3a8f6b6e1a5f80947fc7229f0b2b631380"; }
+    { locale = "en-US"; arch = "linux-x86_64"; sha256 = "a4b439e28274feb4bf5494ba180143e6b8617428a63d11fa2fd0e650dda41908"; }
+    { locale = "en-ZA"; arch = "linux-i686"; sha256 = "9de2931e926e0b0667f6916283a7ef019d1c067b29d6bd5b4b903fdf87ad9c17"; }
+    { locale = "en-ZA"; arch = "linux-x86_64"; sha256 = "6ada8b6a9a2b19f9515a1aaf63ad66cf35a1ab5491fc8ffc86a17fe1378ab553"; }
+    { locale = "eo"; arch = "linux-i686"; sha256 = "92db868c78ae49a8275d217327ca442ef6733b955ddc5b4940183c9a596da3de"; }
+    { locale = "eo"; arch = "linux-x86_64"; sha256 = "2e8267fb43ba6b7636c98fe386c35ddb9032265565844dcbc90f3dba18a2bc05"; }
+    { locale = "es-AR"; arch = "linux-i686"; sha256 = "6343bacb35c929c8f7c5cb554aa0e5f67100032c71bc24203b663409e45cbf40"; }
+    { locale = "es-AR"; arch = "linux-x86_64"; sha256 = "0b5a07e745aab7d1e0bb8bcf0afe12ab71a88679024ef6e9edd53bab7518df7f"; }
+    { locale = "es-CL"; arch = "linux-i686"; sha256 = "7288765c2222624e69b367ab83686c21a348330a8f26eff7c6ea8dca03a3aabf"; }
+    { locale = "es-CL"; arch = "linux-x86_64"; sha256 = "543778259a5d7c4198c8125b72f9e66e9ae98b398bc3b07ac0e103f07ab7ef2c"; }
+    { locale = "es-ES"; arch = "linux-i686"; sha256 = "c1aec91c45591eaa6df8b15ba13ea58d15ab2cce20361719ea2549896d26ea1f"; }
+    { locale = "es-ES"; arch = "linux-x86_64"; sha256 = "ee3b11c04ca280ff77e3cedd3dc2040b7b1722384639c02507bedc927c7b558b"; }
+    { locale = "es-MX"; arch = "linux-i686"; sha256 = "8adb9435f57da461150d8b283161760683e46b068eaade916119c2240f0a9c66"; }
+    { locale = "es-MX"; arch = "linux-x86_64"; sha256 = "b624c4345794a22a7c63b4f6b7a1ed6f52472fa5cba4173f69f3c12ee3b4cbe1"; }
+    { locale = "et"; arch = "linux-i686"; sha256 = "efb6c6753e8a9d8174e8bd1ae7cbf3f75b479e5da3ebe07dbbbb4ac140e60eb9"; }
+    { locale = "et"; arch = "linux-x86_64"; sha256 = "c84bb0597fa14e8a7a2d086f24d71ad2f3c04b3fca794b76977d1a4cb1aea479"; }
+    { locale = "eu"; arch = "linux-i686"; sha256 = "d116553c492ec41b811befb35393553b9174da3960034ce5106558befbf9728a"; }
+    { locale = "eu"; arch = "linux-x86_64"; sha256 = "16c922f152d5e14c46277e23d30cfe0792c8e9828b8862df603aeff242c7ec96"; }
+    { locale = "fa"; arch = "linux-i686"; sha256 = "744ad5a8cb4473d502d1db50b6bf343e23525927b3a982677dd8a68aea111b3f"; }
+    { locale = "fa"; arch = "linux-x86_64"; sha256 = "968fea07386b96215af400524062447245fa038766caf0b133c932db6f105077"; }
+    { locale = "ff"; arch = "linux-i686"; sha256 = "0fdf06aa42cbd4d031fdad74d8ac9d6056708fc783180d72c5806cc45c5b8eec"; }
+    { locale = "ff"; arch = "linux-x86_64"; sha256 = "bfb65ec25192288b2f04f94bdcc9ce36a40a27c8a1f35f728f932c071b6756ce"; }
+    { locale = "fi"; arch = "linux-i686"; sha256 = "334c121cbd9a1469996ebc5535d838e3fecfcc419861cc70d5cdeb0cd584d5f5"; }
+    { locale = "fi"; arch = "linux-x86_64"; sha256 = "44883a9b819a24bef03c3322681e1b9f3fe61779e382a740900dfc16a5f7db06"; }
+    { locale = "fr"; arch = "linux-i686"; sha256 = "cd196dff293aabc39156e82deb5163e139a4b0173de92a2ba72df49bb4b0afe5"; }
+    { locale = "fr"; arch = "linux-x86_64"; sha256 = "77da207f48d7af908cb5e95767e61a2e6c04f1851e55430820ff8207da172361"; }
+    { locale = "fy-NL"; arch = "linux-i686"; sha256 = "39e8da569f2a6f67abac7782a938a906c810f8474fbb2c799dd26fb846c82707"; }
+    { locale = "fy-NL"; arch = "linux-x86_64"; sha256 = "44dbf644b3f96dd607e5c88eece8aaafd61ec42af9f7ba4c6ed06a272a45fa4a"; }
+    { locale = "ga-IE"; arch = "linux-i686"; sha256 = "783532acf3967f94232f42c9cd559e288db499c0ff74776543b59d71d281a74c"; }
+    { locale = "ga-IE"; arch = "linux-x86_64"; sha256 = "39509082dbeb935f481e95d6038943a17c5053f7001fbf71bdb0edea536adb9d"; }
+    { locale = "gd"; arch = "linux-i686"; sha256 = "dd73e1bf159f3d437d69306c5daeb7a06c951d6c5841315363c354f9aa1570c5"; }
+    { locale = "gd"; arch = "linux-x86_64"; sha256 = "a2fb4aa1ba4a50bdb308e8c12090158c5e040ae85617171786e93852d4f48de5"; }
+    { locale = "gl"; arch = "linux-i686"; sha256 = "8ac3fd13e0f173aa1dfffd44c91511bd457c6a751daa978fbaae3f9901427cae"; }
+    { locale = "gl"; arch = "linux-x86_64"; sha256 = "cf52827a18b400f8c3e426b00e2984bd5835014f3e97e9c1279f0b285ca5a5dc"; }
+    { locale = "gu-IN"; arch = "linux-i686"; sha256 = "1ef44836085733b52c338fdcaea78e7df5f78a0f0f470b9de3ac7b13e3ec4844"; }
+    { locale = "gu-IN"; arch = "linux-x86_64"; sha256 = "374280216142897536979fff6f876253caaf0eeb12a3d12d17b013e7ab3ba722"; }
+    { locale = "he"; arch = "linux-i686"; sha256 = "1dcca6ae796da1a1317a4f094f06369242cdf7c0f8ce3df7c9fabd22910996ab"; }
+    { locale = "he"; arch = "linux-x86_64"; sha256 = "e032513a673ba091207996b8a6a6b9da6ef05d5c080a93ed326fc4ac4ca6976a"; }
+    { locale = "hi-IN"; arch = "linux-i686"; sha256 = "2057287b406513a332d162f03f75ef7ff4c83834809163c8b870d9e5ab3f8cdf"; }
+    { locale = "hi-IN"; arch = "linux-x86_64"; sha256 = "8d19043416484c382fc9caec5dff4914fbc28feefd41a089591ef2b21f822a43"; }
+    { locale = "hr"; arch = "linux-i686"; sha256 = "995a6dd027a5a6b2123c62b74f524db53940e2c8fa6c7254dc41dca236f7889b"; }
+    { locale = "hr"; arch = "linux-x86_64"; sha256 = "4410e7d1cbce028de083b82ee68f442d27c2219544ec1be72ef2c274cb7c445a"; }
+    { locale = "hsb"; arch = "linux-i686"; sha256 = "0dcb0de11e35475cab33e11b08b88ff766915d7d98ceeb466a0fee90883ebaed"; }
+    { locale = "hsb"; arch = "linux-x86_64"; sha256 = "1695167eea386aec4fca23bb0bf4e5b83876a22f8c584f4e81886be229e9a43b"; }
+    { locale = "hu"; arch = "linux-i686"; sha256 = "31026a26c9fa9b3777c2f9dd1d55da7e0204e4d98586f887b67588ccb86c3843"; }
+    { locale = "hu"; arch = "linux-x86_64"; sha256 = "82d8fbe932765f100a116b6d572035297be2f027b4f0e0ba84ef88cb4b651000"; }
+    { locale = "hy-AM"; arch = "linux-i686"; sha256 = "864c112f13628bd9bc715a6a405dc92c3f8027b0e505722d819b84775fb27066"; }
+    { locale = "hy-AM"; arch = "linux-x86_64"; sha256 = "dddd71e651056c373225baab9bb190810f8ed6849abfa76587fcd05cc5060d89"; }
+    { locale = "id"; arch = "linux-i686"; sha256 = "3425906d6513d3e06286b9b3c62c30d702a47a3d7a31638a58f926e2fa4a254f"; }
+    { locale = "id"; arch = "linux-x86_64"; sha256 = "095d970add8bf54fc2fb2581532013f4792f648b58fa12d49a6a859f26a0e579"; }
+    { locale = "is"; arch = "linux-i686"; sha256 = "f3687eb0e7ce24e14621345543abdf2b92435466ededc98a4ec4a117c4593c3c"; }
+    { locale = "is"; arch = "linux-x86_64"; sha256 = "dbac8774c64e6c978a3eb900cf61d85a210d0c39c28df4a21e4295ba5febd0ea"; }
+    { locale = "it"; arch = "linux-i686"; sha256 = "62091c6f5214f4717462d9e2f6bacd7f30417b7e714de3fdec6fc2f703970eb7"; }
+    { locale = "it"; arch = "linux-x86_64"; sha256 = "480b9ffd4326a9a2e2002510027a15d4fdaf8ba1ea023ee6e55b2aa78b119a6c"; }
+    { locale = "ja"; arch = "linux-i686"; sha256 = "ef143bf31fa67cab3ccafc0083d81ffa8997e3365312b12312623755eb24f48d"; }
+    { locale = "ja"; arch = "linux-x86_64"; sha256 = "f74808de8fb999dceb067b3fda64e891c37bde7190e9eff68f1693f5b5feae0d"; }
+    { locale = "kk"; arch = "linux-i686"; sha256 = "a532d49011b632aa83f6b881b39c74bcb66fab0237e3e4f8682445aa0a053d4c"; }
+    { locale = "kk"; arch = "linux-x86_64"; sha256 = "7f32ee329e8281e89472b092248a26e1d38089bdc9830d2d1d0b1af8230ca20b"; }
+    { locale = "km"; arch = "linux-i686"; sha256 = "34ecf596b0870aca2db30513ef5d6522d86caf70fce38b23a7bff08c55551b69"; }
+    { locale = "km"; arch = "linux-x86_64"; sha256 = "6e7efd621e941674038887d1e8d90c36d0ac06a095386caa01d228494228be14"; }
+    { locale = "kn"; arch = "linux-i686"; sha256 = "062ebd6b27ef9094e65e60ad64be30470ed58eb2d92f247a87a781b97e0654d9"; }
+    { locale = "kn"; arch = "linux-x86_64"; sha256 = "e88428b1cd2e1919336dda303d8795bd02e4967ba8c6d2830205f68fa4c528d0"; }
+    { locale = "ko"; arch = "linux-i686"; sha256 = "6c43a7f86f908cccc7ca3a7ed45f95ea84b69e4a21ff1e1d58136ea19bf7bd2c"; }
+    { locale = "ko"; arch = "linux-x86_64"; sha256 = "9db2bfd818d82ee0c9bc35b6fd651ad8fe80f8d73d51326fde25fc4c2aaa295c"; }
+    { locale = "lij"; arch = "linux-i686"; sha256 = "be87fc2a6863f33f9ff9ad2990e1e6425a65002f2ee411a254dde80cbd5a31c4"; }
+    { locale = "lij"; arch = "linux-x86_64"; sha256 = "9cfb239df8195cfa355bc8ddaf63accd865de21086c5bc3180b2ad9886445f3e"; }
+    { locale = "lt"; arch = "linux-i686"; sha256 = "11e18e6baac8f31c62a301e8ee51056c707ca47332fbeb6f3492e8eaffa25c57"; }
+    { locale = "lt"; arch = "linux-x86_64"; sha256 = "3bb4dca607abc4e08300dfa61667d2f2b06661f47cf0029d078e14fa4686d4b8"; }
+    { locale = "lv"; arch = "linux-i686"; sha256 = "bc484992f230229ab4ab6d47fab9664f43341ad1202010f5dea91d2d78200c85"; }
+    { locale = "lv"; arch = "linux-x86_64"; sha256 = "42bdc60ad7edf2ed3e82f765abfc3815f98095adc2988f8d809a8834eada63ef"; }
+    { locale = "mai"; arch = "linux-i686"; sha256 = "628f0685185f91e695af5ce9a536d9263305cfd747683ef33dccd0c90f3e1bfb"; }
+    { locale = "mai"; arch = "linux-x86_64"; sha256 = "688c33b159b4fcd23fb4c6d3a7f845d03929b4a8b02eaa2ebb93682b396c73a2"; }
+    { locale = "mk"; arch = "linux-i686"; sha256 = "a59b2a8ee82513ef78f3509afc4dba75ec3128f0f42c657bbbfbad117b981b36"; }
+    { locale = "mk"; arch = "linux-x86_64"; sha256 = "3058ff9ac581a65ee0713fe3707f8b98eace0f833b8e7b901fa397538e9503f0"; }
+    { locale = "ml"; arch = "linux-i686"; sha256 = "43c80f530ad3eaf7c138e16b23b9eb32afc1f774374fe213f580cf68e4d0e245"; }
+    { locale = "ml"; arch = "linux-x86_64"; sha256 = "43f061317f9eb5a174cd13539bb3972535b552113d38c05d9888e7a37346ef22"; }
+    { locale = "mr"; arch = "linux-i686"; sha256 = "30c0ee68eadffcc95271f1e7c1c1b0151ee21ca3744fad61a723a9a6bfb751b0"; }
+    { locale = "mr"; arch = "linux-x86_64"; sha256 = "d9dd27af41ca021f323499be556d208f69b706aff079c8d7392c7f19092705d8"; }
+    { locale = "ms"; arch = "linux-i686"; sha256 = "adb5e1968c66378ff9b59dc57c00a2c953ad1f54f67e1bc40abc499bcf79653f"; }
+    { locale = "ms"; arch = "linux-x86_64"; sha256 = "3e4b43a88b3aa2887673e1962fa4ccbd895640113e683c849a3c9733677e1fe1"; }
+    { locale = "nb-NO"; arch = "linux-i686"; sha256 = "f4be0cff21abdc80fba10db2bf781fecfb4e503c70cb95a8b083c5f7123f8dc8"; }
+    { locale = "nb-NO"; arch = "linux-x86_64"; sha256 = "e9b191268a6694805a5ba86559e798c9a4e29eae39a7f64dab92a925fb31611d"; }
+    { locale = "nl"; arch = "linux-i686"; sha256 = "581c73084993be0bf1ab23bb468674d062fb98e99573d823e977a263b4cfaa91"; }
+    { locale = "nl"; arch = "linux-x86_64"; sha256 = "3fd8929341ae048187379b7648ec8e008ace53e4a5f0af1421ecabcb5ad3bf61"; }
+    { locale = "nn-NO"; arch = "linux-i686"; sha256 = "b2104d5895a727903f6a273888989887542ad9e61c998cc651bb24d64efc6cfd"; }
+    { locale = "nn-NO"; arch = "linux-x86_64"; sha256 = "1bf582e66da985cbb01c22f865fc291196c55b14d2f84516f68f184ea842a664"; }
+    { locale = "or"; arch = "linux-i686"; sha256 = "1ffbc776fb3ae030e6dedea009b71873bff57f9294e63331404b53e1ba36499c"; }
+    { locale = "or"; arch = "linux-x86_64"; sha256 = "b988f433a238b2cb3766042d911a1f002a5f91a47dbed5b937f70cb59ed060d2"; }
+    { locale = "pa-IN"; arch = "linux-i686"; sha256 = "6ba4941b5bef7b860194114c2704662a42f9f3007a0b634662e42f38c0aa601a"; }
+    { locale = "pa-IN"; arch = "linux-x86_64"; sha256 = "0d9920d4b358cfdcf8cdf4b2d2e07ceb191709eee9dbae4c59f9dbfcfffbf0f5"; }
+    { locale = "pl"; arch = "linux-i686"; sha256 = "e080fb35bf49f9eb2fc39a435a188164eedf2ea7a24f8e950d62567620a91954"; }
+    { locale = "pl"; arch = "linux-x86_64"; sha256 = "cc37624f0c1e82d2de2048129f58e85fe8a518ee4b0ebdbee0a5205517602cf9"; }
+    { locale = "pt-BR"; arch = "linux-i686"; sha256 = "d19bf65889c686cbb284e697e8ba1315b6ec004b57096725fb576898ef105346"; }
+    { locale = "pt-BR"; arch = "linux-x86_64"; sha256 = "0d00d2d0bbc6045117c4df93045f70ebe0468e004504a06dfc508bfca6c6df1f"; }
+    { locale = "pt-PT"; arch = "linux-i686"; sha256 = "5225afadf2ea62792376dfda1d2b3533d986f1ee3a281781a5be294b8883ac8b"; }
+    { locale = "pt-PT"; arch = "linux-x86_64"; sha256 = "0c1d841ba80e32d51d41c99b551e68c6b591e97af4ccee4d7c7d6ef03f8707ea"; }
+    { locale = "rm"; arch = "linux-i686"; sha256 = "2cc9200a132c967a7158f5422dad8f4b2d90dfc7e46ada305daebabc44806de8"; }
+    { locale = "rm"; arch = "linux-x86_64"; sha256 = "0dff628773d4f2e24b767501b9c768586a27e82c0e8b259ef1cc676985ad0125"; }
+    { locale = "ro"; arch = "linux-i686"; sha256 = "500142fe612fe6144a14ebaad486da04050940a755e205297473c1be6b9dc428"; }
+    { locale = "ro"; arch = "linux-x86_64"; sha256 = "f3a57abec8553c8b9d8db9fb5600cd7b6e1189ebf0225df96608eaf2863e41b3"; }
+    { locale = "ru"; arch = "linux-i686"; sha256 = "1266ed09db881af90794bef049cdfee777d7179026de8c0de2931275f3f288e9"; }
+    { locale = "ru"; arch = "linux-x86_64"; sha256 = "0f1b44177633149aaa31574ba3cf343971bd4e11ac6b4bb92a5875b6a30a42af"; }
+    { locale = "si"; arch = "linux-i686"; sha256 = "e027afd86b00379c12e014b8d0d11a05811c598f53490edf7070e7acccbf0d79"; }
+    { locale = "si"; arch = "linux-x86_64"; sha256 = "518c19c5351a2c1bd05afe63e9d8c2a0be3a9cedccf7aa1d84d1af9de7ecf7fd"; }
+    { locale = "sk"; arch = "linux-i686"; sha256 = "e3dcda7406d00166a601b77fbdf0b84181ba5372f760eb08d5476fe9d219caef"; }
+    { locale = "sk"; arch = "linux-x86_64"; sha256 = "019c03ecd24f394b0ff76aff5cd9f0db017ffd3b8dd65388c4f5ee3188e77a6c"; }
+    { locale = "sl"; arch = "linux-i686"; sha256 = "a88391cc29643277f9d8c58a205ac959af825326b61c16361d4def6f7da31235"; }
+    { locale = "sl"; arch = "linux-x86_64"; sha256 = "fcf45e13a0bc543988495a83e5e96400707564d2ed4fcd0579219c999ee71e83"; }
+    { locale = "son"; arch = "linux-i686"; sha256 = "a75e273e01df51ffbe2c8666545f1e6f4d00af373d7aac08978947d7afc1e5f4"; }
+    { locale = "son"; arch = "linux-x86_64"; sha256 = "9f28df29d980e6c7467e99b2b81740cb078ce8e6896fe4e2a6b1473770e6bef5"; }
+    { locale = "sq"; arch = "linux-i686"; sha256 = "2243773d7d38608e17233e1d98e4fc1ca19f40f27a3e87557ad7fbd958c080ba"; }
+    { locale = "sq"; arch = "linux-x86_64"; sha256 = "c18faf9d8971c43db18fcc66329a85018a04e8cf4819c4843d826bc86414cadb"; }
+    { locale = "sr"; arch = "linux-i686"; sha256 = "0cd5e6a3910923aed9a88fafd95bc11263de7359c38685e209212339bb2f50dc"; }
+    { locale = "sr"; arch = "linux-x86_64"; sha256 = "1ec48c65323b15332932060ec5193908d89715736bd0abd88472dc05e639a62a"; }
+    { locale = "sv-SE"; arch = "linux-i686"; sha256 = "6718eb3e71a3d4f5487b80bbd784fd61422345f94d3271f6de6f6feab9e2f6da"; }
+    { locale = "sv-SE"; arch = "linux-x86_64"; sha256 = "5b356a6334d424b5e47ea4b1c32403a858ff5dc8727bbc0b2f72e6a29c9b625f"; }
+    { locale = "ta"; arch = "linux-i686"; sha256 = "fdb4e36497a61af9badb848a067eff4e4dada7dfffefbfe6bb7266ad89a8707a"; }
+    { locale = "ta"; arch = "linux-x86_64"; sha256 = "de5f0b871425412f9f261eff5b1abb3ddbd40f588647fd8e174e2d6c5ba17b90"; }
+    { locale = "te"; arch = "linux-i686"; sha256 = "0cc82774a46580c9e2f890848f705b1dc4effac197a902f9d244f0b6f6258650"; }
+    { locale = "te"; arch = "linux-x86_64"; sha256 = "65ceda67a572053dd4d9e15b9bd47c91364651736417414d4ca4a0a7ded9775a"; }
+    { locale = "th"; arch = "linux-i686"; sha256 = "1c0084ed26218713c4606ab073bf09de888051e9dcc49652a87fb58209a8c614"; }
+    { locale = "th"; arch = "linux-x86_64"; sha256 = "5a70e29d282961e27350d26cf164472fe51247db1d7d1228dca693423c32d0a6"; }
+    { locale = "tr"; arch = "linux-i686"; sha256 = "f7fa2029a36eda63544beebb6534fc2f8432c87d7a8d08d4c8927275e659b686"; }
+    { locale = "tr"; arch = "linux-x86_64"; sha256 = "1e3744f5908164e163818522fa902bd57edb62837b2b399983ea5a4ed487cda8"; }
+    { locale = "uk"; arch = "linux-i686"; sha256 = "0f465eda0f7e87eef88bc17b3e6868ad90a270e6993d327fecca532637442df4"; }
+    { locale = "uk"; arch = "linux-x86_64"; sha256 = "6530af36cfab509fff37519b435c7939110c000dbdd94000fe964283a14b1622"; }
+    { locale = "uz"; arch = "linux-i686"; sha256 = "7ee5997bcb4915c3907cee90e350e3bc2b67965975faecffa738a728cf2e12e3"; }
+    { locale = "uz"; arch = "linux-x86_64"; sha256 = "d7b34e36bcb423977a2a7667504c096730ca684c9f2e861b17e8f0174f5bb0d0"; }
+    { locale = "vi"; arch = "linux-i686"; sha256 = "e9497a8eed98ec34b31e3b1ec7086a4d219121f0edf21fd8f6a01599afa41f12"; }
+    { locale = "vi"; arch = "linux-x86_64"; sha256 = "b94fbaee83014b88490bf19cc37dbda87fb9260ed5879be3b688a2abbe709a87"; }
+    { locale = "xh"; arch = "linux-i686"; sha256 = "d5a86db6b9f3bb5162a86f976cbbc01f542a924c05729eb54a2c24dabc711065"; }
+    { locale = "xh"; arch = "linux-x86_64"; sha256 = "d765b2d324e89119fee522ad8972031c8727841c2fa2700d010be7d23633bbbc"; }
+    { locale = "zh-CN"; arch = "linux-i686"; sha256 = "fb3bbc44952207f42112c291dccb82f02fbd23bba7b54b06a1047809d2bb18d2"; }
+    { locale = "zh-CN"; arch = "linux-x86_64"; sha256 = "255d19959cb0e0efbcb2eeceb39b43bbb567ab2474af4da6675574a0110781e1"; }
+    { locale = "zh-TW"; arch = "linux-i686"; sha256 = "cfc90ac621dc57d7eb922c564aa3a7d5ad7f2aacc95196606d34cba7b7e30d1a"; }
+    { locale = "zh-TW"; arch = "linux-x86_64"; sha256 = "ff119be821acb8f99a485a60de506123c76a7a3a13ac678576248f97ff1ab882"; }
  ];
 }
--- a/pkgs/applications/networking/browsers/firefox/default.nix
+++ b/pkgs/applications/networking/browsers/firefox/default.nix
@ -133,14 +133,14 @@ in {

  firefox-unwrapped = common {
    pname = "firefox";
-    version = "44.0";
-    sha256 = "07ac1h6ib36nm4a0aykh1z36vgw6wqlblil0zsj0lchdhksb10pa";
+    version = "44.0.2";
+    sha256 = "17id7ala1slb2mjqkikryqjadcsmdzqmkxrrnb5m1316m50qichb";
  };

  firefox-esr-unwrapped = common {
    pname = "firefox-esr";
-    version = "38.5.2esr";
-    sha256 = "0xqirpiys2pgzk9hs4s93svknc0sss8ry60zar7n9jj74cgz590m";
+    version = "38.6.1esr";
+    sha256 = "1zyhzczhknplxfmk2r7cczavbsml8ckyimibj2sphwdc300ls5wi";
  };

 }
--- a/pkgs/applications/networking/browsers/firefox/wrapper.nix
+++ b/pkgs/applications/networking/browsers/firefox/wrapper.nix
@ -4,7 +4,7 @@
 , gnash, flashplayer, hal-flash
 , MPlayerPlugin, gecko_mediaplayer, gst_all, xorg, libpulseaudio, libcanberra
 , supportsJDK, jrePlugin, icedtea_web
-, trezor-bridge, bluejeans, djview4
+, trezor-bridge, bluejeans, djview4, adobe-reader
 , google_talk_plugin, fribid, gnome3/*.gnome_shell*/
 }:

@ -41,6 +41,7 @@ let
      ++ lib.optional (cfg.enableGnomeExtensions or false) gnome3.gnome_shell
      ++ lib.optional (cfg.enableTrezor or false) trezor-bridge
      ++ lib.optional (cfg.enableBluejeans or false) bluejeans
+      ++ lib.optional (cfg.enableAdobeReader or false) adobe-reader
     );
  libs = [ gst_all.gstreamer gst_all.gst-plugins-base ]
         ++ lib.optionals (cfg.enableQuakeLive or false)
--- a/pkgs/applications/networking/browsers/rekonq/default.nix
+++ b/pkgs/applications/networking/browsers/rekonq/default.nix
@ -21,6 +21,6 @@ stdenv.mkDerivation rec {
    platforms = platforms.linux;
    maintainers = [ maintainers.urkud ];
    description = "KDE Webkit browser";
-    homepage = http://rekonq.sourceforge.net;
+    homepage = https://rekonq.kde.org/;
  };
 }
--- a/pkgs/applications/networking/cluster/marathon/default.nix
+++ b/pkgs/applications/networking/cluster/marathon/default.nix
@ -2,11 +2,11 @@

 stdenv.mkDerivation rec {
  name = "marathon-${version}";
-  version = "0.14.1";
+  version = "0.15.1";

  src = fetchurl {
    url = "https://downloads.mesosphere.io/marathon/v${version}/marathon-${version}.tgz";
-    sha256 = "0vdl7jf7yhb985dj3v46qnqjv1zwfkyizlsyf9c5dq7khvxrp1l4";
+    sha256 = "1ch3nvcwj7pzjjqw4k07gdf7nmdbfkks5j07wl3518bagjqrajj2";
  };

  buildInputs = [ makeWrapper jdk mesos ];
--- a/pkgs/applications/networking/cluster/mesos/default.nix
+++ b/pkgs/applications/networking/cluster/mesos/default.nix
@ -1,7 +1,7 @@
 { stdenv, lib, makeWrapper, fetchurl, curl, sasl, openssh, autoconf
-, automake114x, libtool, unzip, gnutar, jdk, maven, python, wrapPython
-, setuptools, boto, pythonProtobuf, apr, subversion
-, leveldb, glog, perf, utillinux, libnl, iproute
+, automake115x, libtool, unzip, gnutar, jdk, maven, python, wrapPython
+, setuptools, boto, pythonProtobuf, apr, subversion, gzip
+, leveldb, glog, perf, utillinux, libnl, iproute, openssl, libevent
 }:

 let
@ -9,25 +9,26 @@ let
  soext = if stdenv.system == "x86_64-darwin" then "dylib" else "so";

 in stdenv.mkDerivation rec {
-  version = "0.23.0";
+  version = "0.26.0";
  name = "mesos-${version}";

  dontDisableStatic = true;

  src = fetchurl {
    url = "mirror://apache/mesos/${version}/${name}.tar.gz";
-    sha256 = "1v5xpn4wal4vcrvcklchx9slkpa8xlwqkdbnxzy9zkzpq5g3arxr";
+    sha256 = "0csvaql9gky15w23gmiw6cvlfnrlhfxvdqd2pv3j3grr44ph0ab5";
  };

  patches = [
    # https://reviews.apache.org/r/36610/
    ./rb36610.patch
+    ./maven_repo.patch
  ];

  buildInputs = [
-    makeWrapper autoconf automake114x libtool curl sasl jdk maven
+    makeWrapper autoconf automake115x libtool curl sasl jdk maven
    python wrapPython boto setuptools leveldb
-    subversion apr glog
+    subversion apr glog openssl libevent
  ] ++ lib.optionals stdenv.isLinux [
    libnl
  ];
@ -37,17 +38,18 @@ in stdenv.mkDerivation rec {
  ];

  preConfigure = ''
-    export MAVEN_OPTS="-Dmaven.repo.local=${mavenRepo}"
+    substituteInPlace src/Makefile.am --subst-var-by mavenRepo ${mavenRepo}

    substituteInPlace src/launcher/fetcher.cpp \
+      --replace '"gzip' '"${gzip}/bin/gzip'    \
      --replace '"tar' '"${gnutar}/bin/tar'    \
      --replace '"unzip' '"${unzip}/bin/unzip'

    substituteInPlace src/cli/mesos-scp        \
      --replace "'scp " "'${openssh}/bin/scp "

-    substituteInPlace src/cli/python/mesos/cli.py \
-      --replace "['mesos-resolve'" "['$out/bin/mesos-resolve'"
+    substituteInPlace src/python/cli/src/mesos/cli.py \
+     --replace "['mesos-resolve'" "['$out/bin/mesos-resolve'"

  '' + lib.optionalString (stdenv.isLinux) ''

@ -57,13 +59,13 @@ in stdenv.mkDerivation rec {
    substituteInPlace src/linux/perf.cpp       \
      --replace '"perf ' '"${perf}/bin/perf '

-    substituteInPlace src/slave/containerizer/isolators/filesystem/shared.cpp \
+    substituteInPlace src/slave/containerizer/mesos/isolators/filesystem/shared.cpp \
      --replace '"mount ' '"${utillinux}/bin/mount ' \

-    substituteInPlace src/slave/containerizer/isolators/namespaces/pid.cpp \
+    substituteInPlace src/slave/containerizer/mesos/isolators/namespaces/pid.cpp \
      --replace '"mount ' '"${utillinux}/bin/mount ' \

-    substituteInPlace src/slave/containerizer/isolators/network/port_mapping.cpp \
+    substituteInPlace src/slave/containerizer/mesos/isolators/network/port_mapping.cpp \
      --replace '"tc ' '"${iproute}/bin/tc '   \
      --replace '"ip ' '"${iproute}/bin/ip '   \
      --replace '"mount ' '"${utillinux}/bin/mount ' \
@ -79,6 +81,10 @@ in stdenv.mkDerivation rec {
    "--with-glog=${glog}"
    "--enable-optimize"
    "--disable-python-dependency-install"
+    "--enable-ssl"
+    "--with-ssl=${openssl}"
+    "--enable-libevent"
+    "--with-libevent=${libevent}"
  ] ++ lib.optionals stdenv.isLinux [
    "--with-network-isolator"
  ];
@ -107,6 +113,14 @@ in stdenv.mkDerivation rec {
      --prefix="$out"
    rm -f "$out/lib/${python.libPrefix}"/site-packages/site.py*
    popd
+
+    # optional python dependency for mesos cli 
+    pushd src/python/cli
+    ${python}/bin/${python.executable} setup.py install \
+      --install-lib=$out/lib/${python.libPrefix}/site-packages \
+      --old-and-unmanageable \
+      --prefix="$out"
+    popd
  '';

  postFixup = ''
@ -127,7 +141,7 @@ in stdenv.mkDerivation rec {
    # wrap the python programs
    for prog in mesos-cat mesos-ps mesos-scp mesos-tail; do
      wrapProgram "$out/bin/$prog" \
-        --prefix PYTHONPATH ":" "$out/libexec/mesos/python"
+        --prefix PYTHONPATH ":" "$out/lib/${python.libPrefix}/site-packages"
      true
    done
  '';
--- a/pkgs/applications/networking/cluster/mesos/maven_repo.patch
+++ b/pkgs/applications/networking/cluster/mesos/maven_repo.patch
@ -0,0 +1,13 @@
+diff --git a/src/Makefile.am b/src/Makefile.am
+index ae2740a..1df91a7 100644
+--- a/src/Makefile.am
+++ b/src/Makefile.am
+@@ -1310,7 +1310,7 @@ if HAS_JAVA
+ 
+ $(MESOS_JAR): $(MESOS_JAR_SOURCE) $(MESOS_JAR_GENERATED) java/mesos.pom
+ 	@echo "Building mesos-$(PACKAGE_VERSION).jar ..."
+-	@cd $(abs_top_builddir)/src/java && $(MVN) -f mesos.pom clean package
+	@cd $(abs_top_builddir)/src/java && $(MVN) -f mesos.pom -Dmaven.repo.local=@mavenRepo@ clean package
+ 
+ # Convenience library for JNI bindings.
+ # TODO(Charles Reiss): We really should be building the Java library
--- a/pkgs/applications/networking/cluster/spark/default.nix
+++ b/pkgs/applications/networking/cluster/spark/default.nix
@ -1,4 +1,4 @@
-{ stdenv, fetchurl, makeWrapper, jre, pythonPackages
+{ stdenv, fetchzip, makeWrapper, jre, pythonPackages
 , mesosSupport ? true, mesos
 }:

@ -6,11 +6,11 @@ with stdenv.lib;

 stdenv.mkDerivation rec {
  name    = "spark-${version}";
-  version = "1.4.0";
+  version = "1.5.2";

-  src = fetchurl {
+  src = fetchzip {
    url    = "mirror://apache/spark/${name}/${name}-bin-cdh4.tgz";
-    sha256 = "1w60xzzg9mcymin1pmqwx1mvcqmdpfyxhd2dmw5alhnrzi21ycxi";
+    sha256 = "0bgpz3bqj24flrbajzhbkz38fjsd53qmji1kls9izji8vprcjr5v";
  };

  buildInputs = [ makeWrapper jre pythonPackages.python pythonPackages.numpy ]
@ -18,9 +18,13 @@ stdenv.mkDerivation rec {

  untarDir = "${name}-bin-cdh4";
  installPhase = ''
-    mkdir -p $out/{lib/${untarDir}/conf,bin}
+    mkdir -p $out/{lib/${untarDir}/conf,bin,/share/java}
    mv * $out/lib/${untarDir}

+    sed -e 's/INFO, console/WARN, console/' < \
+       $out/lib/${untarDir}/conf/log4j.properties.template > \
+       $out/lib/${untarDir}/conf/log4j.properties
+
    cat > $out/lib/${untarDir}/conf/spark-env.sh <<- EOF
    export JAVA_HOME="${jre}"
    export SPARK_HOME="$out/lib/${untarDir}"
@ -33,6 +37,7 @@ stdenv.mkDerivation rec {
    for n in $(find $out/lib/${untarDir}/bin -type f ! -name "*.*"); do
      makeWrapper "$n" "$out/bin/$(basename $n)"
    done
+    ln -s $out/lib/${untarDir}/lib/spark-assembly-*.jar $out/share/java
  '';

  meta = {
--- a/pkgs/applications/networking/dyndns/cfdyndns/default.nix
+++ b/pkgs/applications/networking/dyndns/cfdyndns/default.nix
@ -0,0 +1,30 @@
+{ stdenv, fetchFromGitHub, rustPlatform, makeWrapper, openssl }:
+
+with rustPlatform;
+
+buildRustPackage rec {
+  name = "cfdyndns-${version}";
+  version = "0.0.1";
+  src = fetchFromGitHub {
+    owner = "colemickens";
+    repo = "cfdyndns";
+    rev = "v${version}";
+    sha256 = "1mcdjykrgh0jq6k6y664lai8sbgzk6j7k0r944f43vg63d1jql5b";
+  };
+
+  depsSha256 = "0whs3fgmpb6g1mjajs3qs9g613x5dal4x6ghzzkpl73a9pgydkpn";
+
+  buildInputs = [ makeWrapper openssl ];
+
+  installPhase = ''
+    mkdir -p $out/bin
+    cp -p target/release/cfdyndns $out/bin/
+  '';
+
+  meta = with stdenv.lib; {
+    description = "CloudFlare Dynamic DNS Client";
+    homepage = https://github.com/colemickens/cfdyndns;
+    license = stdenv.lib.licenses.mit;
+    maintainers = with maintainers; [ colemickens ];
+  };
+}
--- a/pkgs/applications/networking/instant-messengers/baresip/default.nix
+++ b/pkgs/applications/networking/instant-messengers/baresip/default.nix
@ -4,11 +4,11 @@
 , gsm, speex, portaudio, spandsp, libuuid
 }:
 stdenv.mkDerivation rec {
-  version = "0.4.16";
+  version = "0.4.17";
  name = "baresip-${version}";
  src=fetchurl {
    url = "http://www.creytiv.com/pub/baresip-${version}.tar.gz";
-    sha256 = "04a9d7il39b1kfqh7al0g0q8v32hphgjx8gkixrlp5qsqlzvk876";
+    sha256 = "106nagdyayyxj3q68bs3fsps5wnwzjh82vcmy98fp42j33q6yzny";
  };
  buildInputs = [zlib openssl libre librem pkgconfig
    cairo mpg123 gstreamer gst_ffmpeg gst_plugins_base gst_plugins_bad gst_plugins_good
--- a/pkgs/applications/networking/instant-messengers/pidgin-plugins/otr/default.nix
+++ b/pkgs/applications/networking/instant-messengers/pidgin-plugins/otr/default.nix
@ -16,6 +16,6 @@ stdenv.mkDerivation rec {
    description = "Plugin for Pidgin 2.x which implements OTR Messaging";
    license = licenses.gpl2;
    platforms = platforms.linux;
-    maintainters = with maintainers; [ abbradar ];
+    maintainers = with maintainers; [ abbradar ];
  };
 }
--- a/pkgs/applications/networking/instant-messengers/pidgin-plugins/pidgin-opensteamworks/default.nix
+++ b/pkgs/applications/networking/instant-messengers/pidgin-plugins/pidgin-opensteamworks/default.nix
@ -26,6 +26,6 @@ stdenv.mkDerivation rec {
    description = "Plugin for Pidgin 2.x which implements Steam Friends/Steam IM compatibility";
    license = licenses.gpl3;
    platforms = platforms.linux;
-    maintainters = with maintainers; [ arobyn ];
+    maintainers = with maintainers; [ arobyn ];
  };
 }
--- a/pkgs/applications/networking/instant-messengers/pidgin-plugins/purple-plugin-pack/default.nix
+++ b/pkgs/applications/networking/instant-messengers/pidgin-plugins/purple-plugin-pack/default.nix
@ -14,6 +14,6 @@ stdenv.mkDerivation rec {
    description = "Plugin pack for Pidgin 2.x";
    license = licenses.gpl2;
    platforms = platforms.linux;
-    maintainters = with maintainers; [ bdimcheff ];
+    maintainers = with maintainers; [ bdimcheff ];
  };
 }
--- a/pkgs/applications/networking/instant-messengers/telegram/cutegram/default.nix
+++ b/pkgs/applications/networking/instant-messengers/telegram/cutegram/default.nix
@ -25,7 +25,7 @@ stdenv.mkDerivation rec {
    description = "Telegram client forked from sigram";
    homepage = "http://aseman.co/en/products/cutegram/";
    license = licenses.gpl3;
-    maintainer = [ maintainers.profpatsch ];
+    maintainers = [ maintainers.profpatsch ];
  };

 }
--- a/pkgs/applications/networking/instant-messengers/telegram/libqtelegram-aseman-edition/default.nix
+++ b/pkgs/applications/networking/instant-messengers/telegram/libqtelegram-aseman-edition/default.nix
@ -28,7 +28,7 @@ stdenv.mkDerivation rec {
    description = "A fork of libqtelegram by Aseman, using qmake";
    homepage = src.meta.homepage;
    license = stdenv.lib.licenses.gpl3;
-    maintainer = [ maintainers.profpatsch ];
+    maintainers = [ maintainers.profpatsch ];
  };

 }
--- a/pkgs/applications/networking/instant-messengers/telegram/telegram-qml/default.nix
+++ b/pkgs/applications/networking/instant-messengers/telegram/telegram-qml/default.nix
@ -29,7 +29,7 @@ stdenv.mkDerivation rec {
    description = "Telegram API tools for QtQml and Qml";
    homepage = src.meta.homepage;
    license = stdenv.lib.licenses.gpl3;
-    maintainer = [ maintainers.profpatsch ];
+    maintainers = [ maintainers.profpatsch ];
  };

 }
--- a/pkgs/applications/networking/irc/irssi/otr/default.nix
+++ b/pkgs/applications/networking/irc/irssi/otr/default.nix
@ -1,16 +1,15 @@
-{ stdenv, fetchurl, libotr, automake, autoconf, libtool, glib, pkgconfig, irssi }:
+{ stdenv, fetchFromGitHub, libotr, automake, autoconf, libtool, glib, pkgconfig, irssi }:

-let
-  rev = "640e98c74b";
-in
 with stdenv.lib;
 stdenv.mkDerivation rec {
-  name = "irssi-otr-20131007-${rev}";
-  
-  src = fetchurl {
-    url = "https://github.com/cryptodotis/irssi-otr/tarball/${rev}";
-    name = "${name}.tar.gz";
-    sha256 = "0d08ianzhy20w0ld8xx7hgrp9psg54l37619pcdpqyrnlzkkdalz";
+  name = "irssi-otr-${version}";
+  version = "1.0.1";
+
+  src = fetchFromGitHub {
+    owner = "cryptodotis";
+    repo = "irssi-otr";
+    rev = "4ad3b7b6c85be0154ab3694fe9831796db20c4fe";
+    sha256 = "1hm1whx1wzlx4fh4xf2y68rx9x6whi8bsbrhd6hqjhskg5msssrg";
  };

  patchPhase = ''
@ -22,7 +21,7 @@ stdenv.mkDerivation rec {
  preConfigure = "sh ./bootstrap";

  buildInputs = [ libotr automake autoconf libtool glib pkgconfig irssi ];
-  
+
  meta = {
    homepage = https://github.com/cryptodotis/irssi-otr;
    license = stdenv.lib.licenses.gpl2Plus;
--- a/pkgs/applications/networking/newsreaders/liferea/default.nix
+++ b/pkgs/applications/networking/newsreaders/liferea/default.nix
@ -13,7 +13,7 @@ stdenv.mkDerivation rec {

  src = fetchurl {
    url = "https://github.com/lwindolf/${pname}/releases/download/v${version}/${name}.tar.bz2";
-    sha256 = "0wpinar2cxyzq2j7ff7lznc08f0n6qjdm9aavsarbgdpaf2s1xvq";
+    sha256 = "0xyy0qm3h22b69if2hmg36jzvvljxb1w0zy2m2a28kdqfzpa6m8g";
  };

  buildInputs = with gst_all_1; [
@ -27,8 +27,6 @@ stdenv.mkDerivation rec {
    makeWrapper
  ];

-  patches = [ ./liferea-fix-notification-header-location.patch ];
-
  preFixup = ''
    for f in "$out"/bin/*; do
      wrapProgram "$f" \
--- a/pkgs/applications/networking/newsreaders/liferea/liferea-fix-notification-header-location.patch
+++ b/pkgs/applications/networking/newsreaders/liferea/liferea-fix-notification-header-location.patch
@ -1,12 +0,0 @@
-diff -Naur a/src/notification/libnotify.c b/src/notification/libnotify.c
--- a/src/notification/libnotify.c	2016-01-28 19:33:19.000000000 +0100
-+++ b/src/notification/libnotify.c	2016-02-01 19:20:39.167580131 +0100
-@@ -40,7 +40,7 @@
- #include "ui/feed_list_view.h"
- #include "ui/ui_tray.h"
- 
-#include "notification/notification.h"
-+#include "../notification.h"
- 
- static gboolean supports_actions = FALSE;
- static gboolean supports_append  = FALSE;
--- a/Show More
+++ b/Show More